diff --git a/.codespellrc b/.codespellrc
new file mode 100644
index 000000000..a6b4ca175
--- /dev/null
+++ b/.codespellrc
@@ -0,0 +1,5 @@
+[codespell]
+skip = *.pulsar.go,*.pb.go,*.pb.gw.go,*.json,*.git,*.bin,*.sum,*.mod,query_test.go
+ignore-words-list = usera
+count =
+quiet-level = 3
\ No newline at end of file
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/chores.yml b/.github/workflows/chores.yml
new file mode 100644
index 000000000..ef47e5f31
--- /dev/null
+++ b/.github/workflows/chores.yml
@@ -0,0 +1,35 @@
+name: chores
+
+on:
+ pull_request:
+
+jobs:
+ link-check:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - uses: gaurav-nelson/github-action-markdown-link-check@1.0.15
+
+ typos:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - name: Run codespell
+ continue-on-error: true
+ run: |
+ # .codespellrc is used
+ sudo apt-get install codespell -y
+ codespell -w --config .codespellrc
+ exit $?
+
+ pr-title-format:
+ name: Lint PR Title
+ permissions:
+ pull-requests: read
+ statuses: write
+ contents: read
+ runs-on: ubuntu-latest
+ steps:
+ - uses: amannn/action-semantic-pull-request@v5.4.0
+ env:
+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
\ No newline at end of file
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 f97c27924..b89bc4582 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -23,16 +23,15 @@
* [\#1221](https://github.com/cosmos/relayer/pull/1221) Update cometbft to v0.37.2 and ibc-go to v7.2.0.
* [\#1226](https://github.com/cosmos/relayer/pull/1226) Avoid invalid Bech32 prefix error in parallel tests when sdk Config get overwritten by each other in single process.
* [\#1231](https://github.com/cosmos/relayer/pull/1231) Reduce get bech32 prefix when get signer.
-* [\#1225](https://github.com/cosmos/relayer/pull/1225) Support build EVM messages to allow signing Ethereum transactions.
-* [\#4](https://github.com/crypto-org-chain/relayer/pull/4) Avoid packet get relayed when estimated gas is higher than max gas.
-* [\#6](https://github.com/crypto-org-chain/relayer/pull/6) Support accurate estimate gas with eth_estimateGas for evm tx.
* [\#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.
+* [\#1303](https://github.com/cosmos/relayer/pull/1303) Add missing max gas amount on txf to avoid estimate less gas when simulate 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.
-* [\#11](https://github.com/crypto-org-chain/relayer/pull/11) Fix gasFeeCap and gasPrice when new evm tx.
* [\#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.
+* [\#6](https://github.com/crypto-org-chain/relayer/pull/6) Support accurate estimate gas with eth_estimateGas for evm tx.
+* [\#11](https://github.com/crypto-org-chain/relayer/pull/11) Fix gasFeeCap and gasPrice when new evm tx.
## v0.9.3
@@ -140,7 +139,7 @@
### CLI/scripts
* [\#412](https://github.com/cosmos/relayer/pull/412) Auto update clients to prevent expiry. `rly start` command supports auto updating a client if it is about to expire. Use the `--time-threshold` flag.
-* [\#323](https://github.com/cosmos/relayer/pull/323) Implmenet an API server. A rest server with API endpoints to support interacting with the relayer
+* [\#323](https://github.com/cosmos/relayer/pull/323) Implement an API server. A rest server with API endpoints to support interacting with the relayer
* [\#406](https://github.com/cosmos/relayer/pull/406) Split `add-dir` into `add-chains` and `add-paths`. You must add a chain, then the keys, and then the paths. This enables support of bottom up validation.
* [\#428](https://github.com/cosmos/relayer/pull/428) Fix add-paths failure when called on exiting configuration
* [\#427](https://github.com/cosmos/relayer/pull/427) Fix nil paths bug which occurred when validating paths
@@ -157,5 +156,5 @@
* (deps) Bump SDK version to [v0.41.0](https://github.com/cosmos/cosmos-sdk/releases/tag/v0.41.0).
* Bug fixes and minor improvements
-* (relayer)[\#329](https://github.com/cosmos/relayer/issues/329) client, conenction, and channel handshake refactor (identifiers generated auto generated on-chain)
+* (relayer)[\#329](https://github.com/cosmos/relayer/issues/329) client, connection, and channel handshake refactor (identifiers generated auto generated on-chain)
* (relayer)[\#386](https://github.com/cosmos/relayer/pull/386) client, connection and channel identifier reuse
diff --git a/Makefile b/Makefile
index 20e9bbb2b..874515ffd 100644
--- a/Makefile
+++ b/Makefile
@@ -115,7 +115,7 @@ get-gaia:
@git clone --branch $(GAIA_VERSION) --depth=1 https://github.com/cosmos/gaia.git $(GAIA_REPO)
build-gaia:
- @[ -d $(GAIA_REPO) ] || { echo "Repositry for gaia does not exist at $(GAIA_REPO). Try running 'make get-gaia'..." ; exit 1; }
+ @[ -d $(GAIA_REPO) ] || { echo "Repository for gaia does not exist at $(GAIA_REPO). Try running 'make get-gaia'..." ; exit 1; }
@cd $(GAIA_REPO) && \
make install &> /dev/null
@gaiad version --long
@@ -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..48af4767a 100644
--- a/README.md
+++ b/README.md
@@ -9,12 +9,12 @@
[](https://goreportcard.com/report/github.com/cosmos/relayer)
[](https://github.com/cosmos/relayer/blob/main/LICENSE)
[](https://github.com/cosmos/relayer)
-[](https://github.com/cosmos/relayer/latest)
+[](https://github.com/cosmos/relayer/releases/latest)
-In IBC, blockchains do not directly pass messages to each other over the network. This is where `relayer` comes in.
+In IBC, blockchains do not directly pass messages to each other over the network. This is where `relayer` comes in.
A relayer process monitors for updates on opens paths between sets of [IBC](https://ibcprotocol.org/) enabled chains.
-The relayer submits these updates in the form of specific message types to the counterparty chain. Clients are then used to
+The relayer submits these updates in the form of specific message types to the counterparty chain. Clients are then used to
track and verify the consensus state.
In addition to relaying packets, this relayer can open paths across chains, thus creating clients, connections and channels.
@@ -24,7 +24,7 @@ Additional information on how IBC works can be found [here](https://ibc.cosmos.n
---
## Table Of Contents
-- [Basic Usage - Relaying Across Chains](#Basic-Usage---Relaying-Packets-Across-Chains)
+- [Basic Usage - Relaying Across Chains](#basic-usage---relaying-packets-across-chains)
- [Create Path Across Chains](./docs/create-path-across-chain.md)
- [Advanced Usage](./docs/advanced_usage.md)
- [Troubleshooting](./docs/troubleshooting.md)
@@ -35,6 +35,7 @@ Additional information on how IBC works can be found [here](https://ibc.cosmos.n
- [Demo/Dev-Environment](./examples/README.md)
---
+
## Basic Usage - Relaying Packets Across Chains
> The `-h` (help) flag tailing any `rly` command will be your best friend. USE THIS IN YOUR RELAYING JOURNEY.
@@ -47,18 +48,18 @@ Additional information on how IBC works can be found [here](https://ibc.cosmos.n
```shell
$ git clone https://github.com/cosmos/relayer.git
- $ cd relayer && git checkout v2.4.0
+ $ cd relayer && git checkout v2.5.2
$ make install
```
2. **Initialize the relayer's configuration directory/file.**
-
+
```shell
$ rly config init
```
**Default config file location:** `~/.relayer/config/config.yaml`
- By default, transactions will be relayed with a memo of `rly(VERSION)` e.g. `rly(v2.4.0)`.
+ By default, transactions will be relayed with a memo of `rly(VERSION)` e.g. `rly(v2.5.2)`.
To customize the memo for all relaying, use the `--memo` flag when initializing the configuration.
@@ -66,26 +67,26 @@ Additional information on how IBC works can be found [here](https://ibc.cosmos.n
$ rly config init --memo "My custom memo"
```
- Custom memos will have `rly(VERSION)` appended. For example, a memo of `My custom memo` running on relayer version `v2.4.0` would result in a transaction memo of `My custom memo | rly(v2.4.0)`.
-
+ Custom memos will have `rly(VERSION)` appended. For example, a memo of `My custom memo` running on relayer version `v2.5.2` would result in a transaction memo of `My custom memo | rly(v2.5.2)`.
+
The `--memo` flag is also available for other `rly` commands also that involve sending transactions such as `rly tx link` and `rly start`. It can be passed there to override the `config.yaml` value if desired.
To omit the memo entirely, including the default value of `rly(VERSION)`, use `-` for the memo.
3. **Configure the chains you want to relay between.**
-
- In our example, we will configure the relayer to operate on the canonical path between the Cosmos Hub and Osmosis.
+
+ In our example, we will configure the relayer to operate on the canonical path between the Cosmos Hub and Osmosis.
The `rly chains add` command fetches chain meta-data from the [chain-registry](https://github.com/cosmos/chain-registry) and adds it to your config file.
-
+
```shell
$ rly chains add cosmoshub osmosis
```
-
- Adding chains from the chain-registry randomly selects an RPC address from the registry entry.
- If you are running your own node, manually go into the config and adjust the `rpc-addr` setting.
- > NOTE: `rly chains add` will check the liveliness of the available RPC endpoints for that chain in the chain-registry.
+ Adding chains from the chain-registry randomly selects an RPC address from the registry entry.
+ If you are running your own node, manually go into the config and adjust the `rpc-addr` setting.
+
+ > NOTE: `rly chains add` will check the liveliness of the available RPC endpoints for that chain in the chain-registry.
> It is possible that the command will fail if none of these RPC endpoints are available. In this case, you will want to manually add the chain config.
To add the chain config files manually, example config files have been included [here](https://github.com/cosmos/relayer/tree/main/docs/example-configs/)
@@ -93,18 +94,18 @@ Additional information on how IBC works can be found [here](https://ibc.cosmos.n
$ rly chains add --url https://raw.githubusercontent.com/cosmos/relayer/main/docs/example-configs/cosmoshub-4.json cosmoshub
$ rly chains add --url https://raw.githubusercontent.com/cosmos/relayer/main/docs/example-configs/osmosis-1.json osmosis
```
-
+
4. **Import OR create new keys for the relayer to use when signing and relaying transactions.**
- >`key-name` is an identifier of your choosing.
+ >`key-name` is an identifier of your choosing.
If you need to generate a new private key you can use the `add` subcommand.
```shell
- $ rly keys add cosmoshub [key-name]
- $ rly keys add osmosis [key-name]
+ $ rly keys add cosmoshub [key-name]
+ $ rly keys add osmosis [key-name]
```
-
+
If you already have a private key and want to restore it from your mnemonic you can use the `restore` subcommand.
```shell
@@ -115,18 +116,18 @@ Additional information on how IBC works can be found [here](https://ibc.cosmos.n
5. **Use the `key-name` created above.**
>This step is necessary if you chose a `key-name` other than "default"
-
+
```shell
- $ rly keys use cosmoshub [key-name]
- $ rly keys use osmosis [key-name]
+ $ rly keys use cosmoshub [key-name]
+ $ rly keys use osmosis [key-name]
```
6. **Ensure the keys associated with the configured chains are funded.**
- >Your configured addresses will need to contain some of the respective native tokens for paying relayer fees.
-
+ >Your configured addresses will need to contain some of the respective native tokens for paying relayer fees.
+
- You can query the balance of each configured key by running:
+ You can query the balance of each configured key by running:
```shell
$ rly q balance cosmoshub
@@ -135,7 +136,7 @@ Additional information on how IBC works can be found [here](https://ibc.cosmos.n
7. **Configure path meta-data in config file.**
- We have the chain meta-data configured, now we need path meta-data. For more info on `path` terminology visit [here](docs/troubleshooting.md).
+ We have the chain meta-data configured, now we need path meta-data. For more info on `path` terminology visit [here](docs/troubleshooting.md).
>NOTE: Thinking of chains in the config as "source" and "destination" can be confusing. Be aware that most path are bi-directional.
@@ -145,22 +146,22 @@ Additional information on how IBC works can be found [here](https://ibc.cosmos.n
```shell
$ rly paths fetch
```
- > **NOTE:** Don't see the path metadata for paths you want to relay on?
+ > **NOTE:** Don't see the path metadata for paths you want to relay on?
> Please open a PR to add this metadata to the GitHub repo!
8. #### **Configure the channel filter.**
-
- By default, the relayer will relay packets over all channels on a given connection.
+
+ By default, the relayer will relay packets over all channels on a given connection.
- Each path has a `src-channel-filter` which you can utilize to specify which channels you would like to relay on.
+ Each path has a `src-channel-filter` which you can utilize to specify which channels you would like to relay on.
- The `rule` can be one of three values:
+ The `rule` can be one of three values:
- `allowlist` which tells the relayer to relay on _ONLY_ the channels in `channel-list`
- `denylist` which tells the relayer to relay on all channels _BESIDES_ the channels in `channel-list`
- - empty value, which is the default setting, and tells the relayer to relay on all channels
+ - empty value, which is the default setting, and tells the relayer to relay on all channels
-
- Since we are only worried about the canonical channel between the Cosmos Hub and Osmosis our filter settings would look like the following.
+
+ Since we are only worried about the canonical channel between the Cosmos Hub and Osmosis our filter settings would look like the following.
Example:
```yaml
@@ -175,9 +176,9 @@ Additional information on how IBC works can be found [here](https://ibc.cosmos.n
connection-id: connection-1
src-channel-filter:
rule: allowlist
- channel-list: [channel-141]
+ channel-list: [channel-141]
```
-
+
>Because two channels between chains are tightly coupled, there is no need to specify the dst channels.
>If you only know the "dst" channel-ID you can query the "src" channel-ID by running: `rly q channel | jq '.channel.counterparty.channel_id'`
@@ -189,9 +190,9 @@ Additional information on how IBC works can be found [here](https://ibc.cosmos.n
$ rly paths list
$ rly start [path]
# Optionally you can omit the `path` argument to start all configured paths
- $ rly start
+ $ rly start
```
-
+
>When running multiple instances of `rly start`, you will need to use the `--debug-addr` flag and provide an address:port. You can also pass an empty string `''` to turn off this feature or pass `localhost:0` to randomly select a port.
---
@@ -200,8 +201,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 9db3e81cc..44aff4736 100644
--- a/cmd/appstate.go
+++ b/cmd/appstate.go
@@ -75,23 +75,6 @@ func (a *appState) loadConfigFile(ctx context.Context) error {
if err != nil {
return fmt.Errorf("error unmarshalling config: %w", err)
}
- if a.log == nil {
- debugMode := a.viper.GetBool("debug")
- logLevel := ""
- if debugMode {
- logLevel = "debug"
- } else {
- logLevel = a.viper.GetString("log-level")
- if logLevel == "" {
- logLevel = cfgWrapper.Global.LogLevel
- }
- }
- log, err := newRootLogger(a.viper.GetString("log-format"), logLevel)
- if err != nil {
- return err
- }
- a.log = log
- }
if a.log == nil {
a.initLogger(cfgWrapper.Global.LogLevel)
diff --git a/cmd/config.go b/cmd/config.go
index a6337ed94..2b8bde934 100644
--- a/cmd/config.go
+++ b/cmd/config.go
@@ -488,21 +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"`
- LogLevel string `yaml:"log-level" json:"log-level"`
+ 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,
- LogLevel: "info",
+ 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/keys.go b/cmd/keys.go
index ec7013c35..a7a907b4e 100644
--- a/cmd/keys.go
+++ b/cmd/keys.go
@@ -73,7 +73,7 @@ $ %s keys use ibc-0 key_name`, appName)),
return cmd
}
-// keysAddCmd respresents the `keys add` command
+// keysAddCmd represents the `keys add` command
func keysAddCmd(a *appState) *cobra.Command {
cmd := &cobra.Command{
Use: "add chain_name key_name",
@@ -143,7 +143,7 @@ $ %s k a cosmoshub testkey`, appName, appName, appName)),
return cmd
}
-// keysRestoreCmd respresents the `keys add` command
+// keysRestoreCmd represents the `keys add` command
func keysRestoreCmd(a *appState) *cobra.Command {
cmd := &cobra.Command{
Use: "restore chain_name key_name mnemonic",
@@ -265,7 +265,7 @@ $ %s k r demo-key "[mnemonic-words]" --restore-all`, appName, appName, appName))
return cmd
}
-// keysDeleteCmd respresents the `keys delete` command
+// keysDeleteCmd represents the `keys delete` command
func keysDeleteCmd(a *appState) *cobra.Command {
cmd := &cobra.Command{
Use: "delete chain_name key_name",
@@ -326,7 +326,7 @@ func askForConfirmation(a *appState, stdin io.Reader, stderr io.Writer) bool {
}
}
-// keysListCmd respresents the `keys list` command
+// keysListCmd represents the `keys list` command
func keysListCmd(a *appState) *cobra.Command {
cmd := &cobra.Command{
Use: "list chain_name",
@@ -364,7 +364,7 @@ $ %s k l ibc-1`, appName, appName)),
return cmd
}
-// keysExportCmd respresents the `keys export` command
+// keysExportCmd represents the `keys export` command
func keysExportCmd(a *appState) *cobra.Command {
cmd := &cobra.Command{
Use: "export chain_name key_name",
@@ -425,7 +425,7 @@ func (a *appState) showAddressByChainAndKey(cmd *cobra.Command, args []string) e
return nil
}
-// keysShowCmd respresents the `keys show` command
+// keysShowCmd represents the `keys show` command
func keysShowCmd(a *appState) *cobra.Command {
cmd := &cobra.Command{
Use: "show chain_name [key_name]",
diff --git a/cmd/query.go b/cmd/query.go
index 2f3c2e3e9..bc8c6376b 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"
@@ -53,6 +53,7 @@ func queryCmd(a *appState) *cobra.Command {
queryIBCDenoms(a),
queryBaseDenomFromIBCDenom(a),
feegrantQueryCmd(a),
+ queryIBCDenomHash(a),
)
return cmd
@@ -123,6 +124,7 @@ $ %s q denom-trace osmosis 9BBA9A1C257E971E38C1422780CE6F0B0686F0A3085E2D61118D9
if !ok {
return errChainNotFound(args[0])
}
+
res, err := c.ChainProvider.QueryDenomTrace(cmd.Context(), args[1])
if err != nil {
return err
@@ -136,6 +138,35 @@ $ %s q denom-trace osmosis 9BBA9A1C257E971E38C1422780CE6F0B0686F0A3085E2D61118D9
return cmd
}
+func queryIBCDenomHash(a *appState) *cobra.Command {
+ cmd := &cobra.Command{
+ Use: "denom-hash chain_id trace",
+ Short: "query the denom hash info from a given denom trace",
+ Args: withUsage(cobra.ExactArgs(2)),
+ Example: strings.TrimSpace(fmt.Sprintf(`
+$ %s query denom-hash osmosis transfer/channel-0/uatom
+$ %s q denom-hash osmosis transfer/channel-0/uatom`,
+ appName, appName,
+ )),
+ RunE: func(cmd *cobra.Command, args []string) error {
+ c, ok := a.config.Chains[args[0]]
+ if !ok {
+ return errChainNotFound(args[0])
+ }
+
+ res, err := c.ChainProvider.QueryDenomHash(cmd.Context(), args[1])
+ if err != nil {
+ return err
+ }
+
+ fmt.Fprintln(cmd.OutOrStdout(), res)
+ return nil
+ },
+ }
+ cmd = addOutputFlag(a.viper, cmd)
+ return cmd
+}
+
func queryTx(a *appState) *cobra.Command {
cmd := &cobra.Command{
Use: "tx chain_name tx_hash",
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/cregistry/chain_info.go b/cregistry/chain_info.go
index fa32701bb..d9024e033 100644
--- a/cregistry/chain_info.go
+++ b/cregistry/chain_info.go
@@ -271,7 +271,6 @@ func (c ChainInfo) GetChainConfig(ctx context.Context, forceAdd, testnet bool, n
Key: "default",
ChainID: c.ChainID,
RPCAddr: rpc,
- JSONRPCAddr: c.JSONRPCAddr,
AccountPrefix: c.Bech32Prefix,
KeyringBackend: "test",
GasAdjustment: 1.2,
@@ -287,5 +286,6 @@ func (c ChainInfo) GetChainConfig(ctx context.Context, forceAdd, testnet bool, n
MaxGasAmount: c.MaxGasAmount,
ExtensionOptions: c.ExtensionOptions,
PrecompiledContractAddress: c.PrecompiledContractAddress,
+ JSONRPCAddr: c.JSONRPCAddr,
}, nil
}
diff --git a/docs/advanced_usage.md b/docs/advanced_usage.md
index 23e76e307..34624083a 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 acknowledgment sequences on a specific path and channel. This is updated after each flush (default is 5 min) | Gauge |
+
@@ -28,7 +31,7 @@ Exported metrics:
## Auto Update Light Client
-By default, the Relayer will automatically update clients (`MsgUpdateClient`) if the client has <= 1/3 of its trusting period left.
+By default, the Relayer will automatically update clients (`MsgUpdateClient`) if the client has <= 1/3 of its trusting period left.
> NOTE: The trusting period of the corresponding client is restored with each transaction a relayer relays. In other words, every time a relayer relays a message, it also sends a `MsgUpdateClient` message restarting the time to the clients expiration.*
@@ -46,8 +49,8 @@ Example:
Selecting a time-threshold that is greater than 2/3 of the client trusting period will deem itself useless.
Use cases for configuring the `--time-threshold` flag:
-- The underlying chain node that the relayer is using as an endpoint has restrictive pruning. Client updates are needed more frequently since states 2/3 trusting period ago would not be available due to pruning.
-- Mitiage relayer operational errors allowing more frequent updates incase a relayer node goes down for > the client trusting period.
+- The underlying chain node that the relayer is using as an endpoint has restrictive pruning. Client updates are needed more frequently since states 2/3 trusting period ago would not be available due to pruning.
+- Mitiage relayer operational errors allowing more frequent updates in case a relayer node goes down for > the client trusting period.
\* It is not mandatory for relayers to include the `MsgUpdateClient` when relaying packets, however most, if not all relayers currently do.
@@ -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
-[<-- 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/node_pruning.md b/docs/node_pruning.md
index d50a30167..f62254075 100644
--- a/docs/node_pruning.md
+++ b/docs/node_pruning.md
@@ -17,4 +17,4 @@ Here are the settings used to configure SDK-based full nodes (assuming 3 week un
Note, operators can tweak `--pruning-keep-every` and `--pruning-interval` to their
liking.
-[<-- Relayer Terminology](./terminology.md) - [Demo -->](./demo.md)
\ No newline at end of file
+[<-- Relayer Terminology](./terminology.md) - [Demo -->](../examples/README.md)
\ No newline at end of file
diff --git a/docs/troubleshooting.md b/docs/troubleshooting.md
index 75f46195e..1988a16fa 100644
--- a/docs/troubleshooting.md
+++ b/docs/troubleshooting.md
@@ -1,18 +1,28 @@
# Troubleshooting
+- [Generic Troubleshooting](#generic-troubleshooting)
+- [Inspect Go Runtime Debug Data](#inspect-go-runtime-debug-data)
+- [Specific Errors](#specific-errors)
-**Ensure `rly` package is properly installed**
+
- Run:
+---
+
+
+
+## Generic Troubleshooting
+
+### **Ensure `rly` package is properly installed**
+
+ Run:
```shell
$ rly version
```
- 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).
+ If this returns an error, make sure you have Go installed and your Go environment is setup. Then redo [Step 1](../README.md#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/README.md b/examples/README.md
index bbac9c71f..293e0992d 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -17,11 +17,11 @@ cd examples/demo/
./dev-env
```
-This script creates a folder called "data": `examples/demo/data/`.
+This script creates a folder called "data": `examples/demo/data/`.
Logs and config info for each chain can be found here.
-Note: After running, two `gaiad` instances will be running on your machine.
+Note: After running, two `gaiad` instances will be running on your machine.
To kill ALL `gaiad` instances run:
```bash
killall gaiad
@@ -40,4 +40,4 @@ This is an example of a config file with:
---
-[<-- Pruning Settings](../node_pruning.md)
\ No newline at end of file
+[<-- Pruning Settings](../docs/node_pruning.md)
\ No newline at end of file
diff --git a/go.mod b/go.mod
index 52f6e86c5..3fe111384 100644
--- a/go.mod
+++ b/go.mod
@@ -3,211 +3,227 @@ 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.3.0
+ cosmossdk.io/store v1.0.2
+ cosmossdk.io/x/feegrant v0.1.0
+ cosmossdk.io/x/tx v0.13.1
+ cosmossdk.io/x/upgrade v0.1.1
+ github.com/avast/retry-go/v4 v4.5.1
+ github.com/btcsuite/btcd v0.24.0
+ github.com/btcsuite/btcd/btcutil v1.1.5
+ github.com/cometbft/cometbft v0.38.7-0.20240412124004-1f67e396cf45
+ github.com/cosmos/cosmos-proto v1.0.0-beta.4
+ github.com/cosmos/cosmos-sdk v0.50.5
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.2.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/evmos/ethermint v0.0.0-00010101000000-000000000000
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/stretchr/testify v1.8.4
+ 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.9.0
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.11.0
+ go.uber.org/zap v1.26.0
+ golang.org/x/sync v0.6.0
+ golang.org/x/text v0.14.0
+ google.golang.org/grpc v1.62.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.112.0 // indirect
+ cloud.google.com/go/compute v1.24.0 // 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.6 // indirect
+ cloud.google.com/go/storage v1.36.0 // 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
- filippo.io/edwards25519 v1.0.0 // indirect
+ cosmossdk.io/log v1.3.1 // indirect
+ filippo.io/edwards25519 v1.1.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 v1.0.0 // indirect
+ github.com/99designs/keyring v1.2.2 // indirect
+ github.com/DataDog/datadog-go v4.8.3+incompatible // indirect
+ github.com/DataDog/zstd v1.5.5 // indirect
+ github.com/Microsoft/go-winio v0.6.1 // indirect
github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6 // indirect
github.com/VictoriaMetrics/fastcache v1.6.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/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/cenkalti/backoff/v4 v4.1.3 // 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/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/cometbft/cometbft-db v0.9.1 // indirect
github.com/cosmos/btcutil v1.0.5 // indirect
+ github.com/cosmos/cosmos-db v1.0.2 // 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/danieljoos/wincred v1.1.2 // indirect
- github.com/davecgh/go-spew v1.1.1 // indirect
- github.com/deckarep/golang-set v1.8.0 // indirect
- github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0 // indirect
+ github.com/cosmos/iavl v1.0.1 // indirect
+ github.com/cosmos/ledger-cosmos-go v0.13.3 // indirect
+ github.com/danieljoos/wincred v1.2.0 // indirect
+ github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
+ github.com/deckarep/golang-set/v2 v2.1.0 // 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/go-kit/kit v0.12.0 // indirect
+ github.com/dvsekhvalnov/jose2go v1.6.0 // indirect
+ github.com/emicklei/dot v1.6.1 // indirect
+ github.com/fatih/color v1.16.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.13.0 // indirect
github.com/go-kit/log v0.2.1 // indirect
github.com/go-logfmt/logfmt v0.6.0 // indirect
+ github.com/go-logr/logr v1.4.1 // indirect
+ github.com/go-logr/stdr v1.2.2 // indirect
github.com/go-ole/go-ole v1.2.6 // indirect
- github.com/go-stack/stack v1.8.0 // indirect
+ github.com/go-stack/stack v1.8.1 // 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/protobuf v1.5.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.6.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.3 // 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.3 // indirect
+ github.com/hashicorp/go-plugin v1.6.0 // 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/hdevalence/ed25519consensus v0.1.0 // indirect
+ github.com/hashicorp/yamux v0.1.1 // indirect
+ github.com/hdevalence/ed25519consensus v0.2.0 // indirect
github.com/holiman/bloomfilter/v2 v2.0.3 // indirect
- github.com/holiman/uint256 v1.2.1 // 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.7 // 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.8.4 // 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/mattn/go-runewidth v0.0.9 // 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/mtibben/percent v0.2.1 // indirect
+ github.com/oasisprotocol/curve25519-voi v0.0.0-20230904125328-1f23a7beb09a // indirect
+ github.com/oklog/run v1.1.0 // indirect
github.com/olekukonko/tablewriter v0.0.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.1 // indirect
+ github.com/petermattis/goid v0.0.0-20231207134359-e60b3f734c67 // 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/prometheus/tsdb v0.7.1 // 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.13.0 // indirect
github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 // indirect
- github.com/rivo/uniseg v0.2.0 // indirect
- github.com/rjeczalik/notify v0.9.1 // indirect
- github.com/rogpeppe/go-internal v1.11.0 // indirect
- github.com/rs/cors v1.8.3 // indirect
- github.com/rs/zerolog v1.30.0 // indirect
+ github.com/rogpeppe/go-internal v1.12.0 // indirect
+ github.com/rs/cors v1.10.1 // 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/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible // 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/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d // indirect
github.com/tendermint/go-amino v0.16.0 // indirect
github.com/tidwall/btree v1.7.0 // indirect
github.com/tklauser/go-sysconf v0.3.10 // indirect
github.com/tklauser/numcpus v0.4.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/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
+ go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.47.0 // indirect
+ go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.47.0 // indirect
+ go.opentelemetry.io/otel v1.22.0 // indirect
+ go.opentelemetry.io/otel/metric v1.22.0 // indirect
+ go.opentelemetry.io/otel/trace v1.22.0 // indirect
+ golang.org/x/crypto v0.21.0 // indirect
+ golang.org/x/exp v0.0.0-20240314144324-c7f7c6466f7f // indirect
+ golang.org/x/mod v0.15.0 // indirect
+ golang.org/x/net v0.23.0 // indirect
+ golang.org/x/oauth2 v0.18.0 // indirect
+ golang.org/x/sys v0.18.0 // indirect
+ golang.org/x/term v0.18.0 // indirect
+ golang.org/x/time v0.5.0 // indirect
+ golang.org/x/tools v0.18.0 // indirect
+ google.golang.org/api v0.162.0 // indirect
+ google.golang.org/appengine v1.6.8 // indirect
+ google.golang.org/genproto v0.0.0-20240213162025-012b6fc9bca9 // indirect
+ google.golang.org/genproto/googleapis/api v0.0.0-20240205150955-31a09d347014 // indirect
+ google.golang.org/genproto/googleapis/rpc v0.0.0-20240221002015-b0ce06bbee7c // indirect
+ google.golang.org/protobuf v1.33.0 // indirect
gopkg.in/ini.v1 v1.67.0 // indirect
gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
- nhooyr.io/websocket v1.8.6 // indirect
- pgregory.net/rapid v0.5.5 // indirect
- sigs.k8s.io/yaml v1.3.0 // indirect
+ gotest.tools/v3 v3.5.1 // indirect
+ nhooyr.io/websocket v1.8.10 // indirect
+ pgregory.net/rapid v1.1.0 // indirect
+ sigs.k8s.io/yaml v1.4.0 // indirect
)
replace (
- github.com/ChainSafe/go-schnorrkel => github.com/ChainSafe/go-schnorrkel v0.0.0-20200405005733-88cbf1b4c40d
- github.com/ethereum/go-ethereum => github.com/evmos/go-ethereum v1.10.26-evmos-rc1
- github.com/evmos/ethermint => github.com/crypto-org-chain/ethermint v0.0.0-20230925064253-4e39e73bae2b
+ github.com/cockroachdb/pebble => github.com/cockroachdb/pebble v0.0.0-20230209160836-829675f94811
+ // release/v1.11.x
+ github.com/ethereum/go-ethereum => github.com/crypto-org-chain/go-ethereum v1.10.20-0.20240425065928-ebb09502e7a7
+ github.com/evmos/ethermint => github.com/crypto-org-chain/ethermint v0.6.1-0.20240429025959-aa05efccfeee
)
diff --git a/go.sum b/go.sum
index 3bb5c7886..54dbf552a 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.112.0 h1:tpFCD7hpHFlQ8yPwT3x+QeXqc2T6+n6T+hmABHfDUSM=
+cloud.google.com/go v0.112.0/go.mod h1:3jEEVwZ/MHU4djK5t5RHuKOA/GbLddgTdVubX1qnPD4=
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.24.0 h1:phWcR2eWzRJaL/kOiJwfFsPs4BaKq1j6vnpZrc1YlVg=
+cloud.google.com/go/compute v1.24.0/go.mod h1:kw1/T+h/+tK2LJK0wiPPx1intgdAM3j/g3hFDlscY40=
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.6 h1:bEa06k05IO4f4uJonbB5iAgKTPpABy1ayxaIZV/GHVc=
+cloud.google.com/go/iam v1.1.6/go.mod h1:O0zxdPeGBoFdWW3HWmBxJsk0pfvNM/p/qa82rWOGTwI=
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.36.0 h1:P0mOkAcaJxhCTvAkMhxMfrTKiNcub4YmmPBtlhAyTr8=
+cloud.google.com/go/storage v1.36.0/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,39 +184,53 @@ 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/simapp v0.0.0-20230608160436-666c345ad23d h1:E/8y0oG3u9hBR8l4F9MtC0LdZIamPCUwUoLlrHrX86I=
-cosmossdk.io/simapp v0.0.0-20230608160436-666c345ad23d/go.mod h1:xbjky3L3DJEylaho6gXplkrMvJ5sFgv+qNX+Nn47bzY=
-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.3.0 h1:RC+jryuKeytIiictDslBP9i1fhkVm6ZDmZEoNP316zE=
+cosmossdk.io/math v1.3.0/go.mod h1:vnRTxewy+M7BtXBNFybkuhSH4WfedVAAnERHgVFhp3k=
+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.1 h1:Mg+EMp67Pz+NukbJqYxuo8uRp7N/a9uR+oVS9pONtj8=
+cosmossdk.io/x/tx v0.13.1/go.mod h1:CBCU6fsRVz23QGFIQBb1DNX2DztJCf3jWyEkHY2nJQ0=
+cosmossdk.io/x/upgrade v0.1.1 h1:aoPe2gNvH+Gwt/Pgq3dOxxQVU3j5P6Xf+DaUJTDZATc=
+cosmossdk.io/x/upgrade v0.1.1/go.mod h1:MNLptLPcIFK9CWt7Ra//8WUZAxweyRDNcbs5nkOcQy0=
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=
+filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
+filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
github.com/99designs/go-keychain v0.0.0-20191008050251-8e49817e8af4 h1:/vQbFIOMbk2FiG/kXiLl8BRyzTWDw7gX/Hz7Dd5eDMs=
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/99designs/keyring v1.2.2 h1:pZd3neh/EmUzWONb35LxQfvuY7kiSXAq3HQd97+XBn0=
+github.com/99designs/keyring v1.2.2/go.mod h1:wes/FrByc8j7lFOAGLGSNEg8f/PaI3cgTBqhFkHUrPk=
+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/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ=
+github.com/DataDog/datadog-go v4.8.3+incompatible h1:fNGaYSuObuQb5nzeTQqowRAd9bpDIRRV4/gUtIBjh8Q=
+github.com/DataDog/datadog-go v4.8.3+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=
@@ -250,20 +261,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=
@@ -273,22 +281,25 @@ 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/go.mod h1:nm3Bko6zh6bWP60UxwoT5LzdGJsQJaPo6HjduXq9p6A=
+github.com/btcsuite/btcd v0.24.0 h1:gL3uHE/IaFj6fcZSu03SvqPMSx7s/dPzfpG/atRwWdo=
+github.com/btcsuite/btcd v0.24.0/go.mod h1:K4IDc1593s8jKXIF7yS7yCTSxrknB9z0STzc2j6XgE4=
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=
@@ -298,16 +309,17 @@ 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/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk=
+github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s=
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=
@@ -336,24 +348,26 @@ github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWH
github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
+github.com/cncf/xds/go v0.0.0-20231128003011-0fa0005c9caa h1:jQCWAUqqlij9Pgj2i/PB79y4KOPYVyFYdROxgaCwdTQ=
+github.com/cncf/xds/go v0.0.0-20231128003011-0fa0005c9caa/go.mod h1:x/1Gn8zydmfq8dk6e9PdstVsDgu9RuyIIJqAaF//0IM=
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.2 h1:H9MtNqVoVhvd9nCBwOyDjUEdZCREqbIdCJD93PBm/jA=
+github.com/cockroachdb/datadriven v1.0.2/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 v0.0.0-20230209160836-829675f94811 h1:ytcWPaNPhNoGMWEhDvS3zToKcDpRsLuRolQJBVGdozk=
+github.com/cockroachdb/pebble v0.0.0-20230209160836-829675f94811/go.mod h1:Nb5lgvnQ2+oGlE/EyZy4+2/CxRh9KfvCXnag1vtpxVM=
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/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.7-0.20240412124004-1f67e396cf45 h1:gZEONnQVW32QEemrDEDCkse4kzd43/HyBmQqZUkjcnU=
+github.com/cometbft/cometbft v0.38.7-0.20240412124004-1f67e396cf45/go.mod h1:HIyf811dFMI73IE0F7RrnY/Fr+d1+HuJAgtkEpQjCMY=
+github.com/cometbft/cometbft-db v0.9.1 h1:MIhVX5ja5bXNHF8EYrThkG9F7r9kSfv8BX4LWaxWJ4M=
+github.com/cometbft/cometbft-db v0.9.1/go.mod h1:iliyWaoV0mRwBJoizElCwwRA9Tf7jZJOURcRZF9m60U=
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=
@@ -364,52 +378,53 @@ 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.2 h1:hwMjozuY1OlJs/uh6vddqnk9j7VamLv+0DBlbEXbAKs=
+github.com/cosmos/cosmos-db v1.0.2/go.mod h1:Z8IXcFJ9PqKK6BIsVOB3QXtkKoqUOp1vRvPT39kOXEA=
+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.5 h1:MOEi+DKYgW67YaPgB+Pf+nHbD3V9S/ayitRKJYLfGIA=
+github.com/cosmos/cosmos-sdk v0.50.5/go.mod h1:oV/k6GJgXV9QPoM2fsYDPPsyPBgQbdotv532O6Mz1OQ=
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.2.0 h1:7oCzyy1sZCcgpeQLnHxC56brsSz3KWwQGKXalXwXFzE=
+github.com/cosmos/ibc-go/v8 v8.2.0/go.mod h1:wj3qx75iC/XNnsMqbPDCIGs0G6Y3E/lo3bdqCyoCy+8=
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/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/crypto-org-chain/ethermint v0.0.0-20230925064253-4e39e73bae2b h1:dzPn4TQpSR3C02To27+hSOZrmyBHqxFMwhdFkazJ/fM=
-github.com/crypto-org-chain/ethermint v0.0.0-20230925064253-4e39e73bae2b/go.mod h1:q+7vqnoEJvfachn5Qtp6EjbKbIDXa1vTEJNV4Beh/LA=
-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/crypto-org-chain/ethermint v0.6.1-0.20240429025959-aa05efccfeee h1:5eoRnEGxLtrO35t+Bgqv/VBCkomAE7uLxDL4Vmv4Fs0=
+github.com/crypto-org-chain/ethermint v0.6.1-0.20240429025959-aa05efccfeee/go.mod h1:9MVSajfKloRP8h2chP78LhCKx5u9O2pCMBvxrmx6+0s=
+github.com/crypto-org-chain/go-ethereum v1.10.20-0.20240425065928-ebb09502e7a7 h1:V43F3JFcqG4MUThf9W/DytnPblpR6CcaLBw2Wx6zTgE=
+github.com/crypto-org-chain/go-ethereum v1.10.20-0.20240425065928-ebb09502e7a7/go.mod h1:+a8pUj1tOyJ2RinsNQD4326YS+leSoKGiG/uVVb0x6Y=
+github.com/danieljoos/wincred v1.2.0 h1:ozqKHaLK0W/ii4KVbbvluM91W2H3Sh0BncbUNPS7jLE=
+github.com/danieljoos/wincred v1.2.0/go.mod h1:FzQLLMKBFdvu+osBrnFODiv32YGwCfx0SkRa/eYHgec=
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/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/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/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/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=
@@ -422,26 +437,23 @@ github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZm
github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13 h1:fAjc9m62+UWV/WAFKLNi6ZS0675eEUC9y3AlwSbQu1Y=
github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
-github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
-github.com/dlclark/regexp2 v1.4.1-0.20201116162257-a2a8dda75c91 h1:Izz0+t1Z5nI16/II7vuEo/nHjodOg0p7+OiDpjX5t1E=
-github.com/dlclark/regexp2 v1.4.1-0.20201116162257-a2a8dda75c91/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc=
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.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
-github.com/dop251/goja v0.0.0-20220405120441-9037c2b61cbf h1:Yt+4K30SdjOkRoRRm3vYNQgR+/ZIy0RmeUDZo7Y8zeQ=
-github.com/dop251/goja v0.0.0-20220405120441-9037c2b61cbf/go.mod h1:R9ET47fwRVRPZnOGvHxxhuZcbrMCuiqOz3Rlrh4KSnk=
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 h1:CEBF7HpRnUCSJgGUb5h1Gm7e3VkmVDrR8lvWVLtrOFw=
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=
@@ -453,33 +465,32 @@ 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/evmos/go-ethereum v1.10.26-evmos-rc1 h1:8+jrotZVyO0eIJGRGa1Kga3Fo7DjgFUE9rd6A8Yrbcg=
-github.com/evmos/go-ethereum v1.10.26-evmos-rc1/go.mod h1:EYFyF19u3ezGLD4RqOkLq+ZCXzYbLoNDdZlMt7kyKFg=
+github.com/envoyproxy/protoc-gen-validate v1.0.4 h1:gVPz/FMfvh57HdSJQyvBtF00j8JU4zdyUgIUNhlgg0A=
+github.com/envoyproxy/protoc-gen-validate v1.0.4/go.mod h1:qys6tmnRsYrQqIhm2bvKZH4Blx/1gTIZ2UKVY1M+Yew=
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.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM=
+github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE=
+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/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-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI=
github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww=
-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/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=
github.com/gin-gonic/gin v1.6.3/go.mod h1:75u5sXoLsGZoRN5Sgbi1eraJ4GU3++wFwWzhwvtwp4M=
-github.com/gin-gonic/gin v1.8.1 h1:4+fr/el88TOO3ewCmQr8cx/CtZ/umlIRIs5M4NTNjf8=
-github.com/gin-gonic/gin v1.8.1/go.mod h1:ji8BvRH1azfM+SYow9zQ6SZMvR8qOMZHmsCuWR9tTTk=
github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA=
github.com/go-errors/errors v1.4.2/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3BopGUQ5a5Og=
github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
@@ -488,8 +499,9 @@ github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2
github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
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/kit v0.13.0 h1:OoneCcHKHQ03LfBpoQCUfCluwd2Vt3ohz+kvbJneZAU=
+github.com/go-kit/kit v0.13.0/go.mod h1:phqEHMMUbyrCFCTgH48JueqrM3md2HcAZ8N3XE4FKDg=
+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=
@@ -497,32 +509,25 @@ 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-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ=
+github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
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-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=
-github.com/go-playground/locales v0.14.0/go.mod h1:sawfccIbzZTqEDETgFXqTho0QybSa7l++s0DH+LDiLs=
github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
-github.com/go-playground/universal-translator v0.18.0 h1:82dyy6p4OuJq4/CByFNOn/jYrnRPArHwAcmLoJZxyho=
-github.com/go-playground/universal-translator v0.18.0/go.mod h1:UvRDBj+xPUEGrFYl+lu/H90nyDXpg0fqeB/AQUGNTVA=
github.com/go-playground/validator/v10 v10.2.0/go.mod h1:uOYAAleCW8F/7oMFd6aG0GOhaH6EGOAJShg8Id5JGkI=
-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-sourcemap/sourcemap v2.1.3+incompatible h1:W1iEw64niKVGogNgBN3ePyLFfuisuzeidWPMPWmECqU=
-github.com/go-sourcemap/sourcemap v2.1.3+incompatible/go.mod h1:F8jJfvm2KbVjc5NqelyYJmf/v5J0dwNLS2mL4sNA1Jg=
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-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/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=
@@ -539,8 +544,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=
@@ -575,12 +580,13 @@ github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw
github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM=
github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-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/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
+github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
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=
@@ -599,8 +605,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=
@@ -627,7 +634,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=
@@ -635,17 +641,18 @@ 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/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.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.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=
@@ -655,37 +662,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=
@@ -693,13 +695,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.3 h1:bN2+Fw9XPFvOCjB0UOevFIMICZ7G2XSQHzfvLUyOM5E=
+github.com/hashicorp/go-getter v1.7.3/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.3 h1:M5uADWMOGCTUNU1YuC4hfknOeHNaX54LDm4oYSucoNE=
+github.com/hashicorp/go-metrics v0.5.3/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.6.0 h1:wgd4KxHJTVGGqWBq4QPB1i5BZNEx9BR8+OFmHDmTk8A=
+github.com/hashicorp/go-plugin v1.6.0/go.mod h1:lBS5MtSSBZk0SHc66KACcjjlU6WzEVP/8pwz68aMkCI=
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=
@@ -707,28 +715,31 @@ 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/hdevalence/ed25519consensus v0.1.0 h1:jtBwzzcHuTmFrQN6xQZn6CQEO/V9f7HsjsjeEZ6auqU=
-github.com/hdevalence/ed25519consensus v0.1.0/go.mod h1:w3BHWjwJbFU29IRHL1Iqkw3sus+7FctEyM4RqDxYNzo=
+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.2.0 h1:37ICyZqdyj0lAZ8P4D1d1id3HqbbG1N3iBb1Tb4rdcU=
+github.com/hdevalence/ed25519consensus v0.2.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.1 h1:XRtyuda/zw2l+Bq/38n5XUoEF72aSOu/77Thd9pPp2o=
-github.com/holiman/uint256 v1.2.1/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=
@@ -737,6 +748,8 @@ github.com/huandu/skiplist v1.2.0/go.mod h1:7v3iFjLcSAzO4fN5B8dvebvo/qsfumiLiDXM
github.com/hudl/fargo v1.3.0/go.mod h1:y3CKSmjA+wD2gak7sUSXTAoopbhU08POFhmITJgmKTg=
github.com/huin/goupnp v1.0.3 h1:N8No57ls+MnjlB+JPiCVSOyy/ot7MJTqlo7rn+NYSqQ=
github.com/huin/goupnp v1.0.3/go.mod h1:ZxNlw5WqJj6wSsRK5+YfflQGXYfccj5VgQsMNixHM7Y=
+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=
@@ -749,8 +762,8 @@ github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7Bd
github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc=
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=
@@ -766,8 +779,6 @@ github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/u
github.com/json-iterator/go v1.1.8/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
-github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
-github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
github.com/jsternberg/zap-logfmt v1.3.0 h1:z1n1AOHVVydOOVuyphbOKyR4NICDQFiJMn1IK5hVQ5Y=
@@ -784,11 +795,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.7 h1:ehO88t2UGzQK66LMdE8tibEd1ErmzZjNEqWkjLAKQQg=
+github.com/klauspost/compress v1.17.7/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
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=
@@ -797,17 +807,17 @@ 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/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=
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/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.8.4 h1:ZMsBpPpJNtRLHiKKp0mI7gW+NT4s7UgfD5xHxx1jVRo=
-github.com/linxGnu/grocksdb v1.8.4/go.mod h1:xZCIb5Muw+nhbDK4Y5UJuOrin5MceOuiXkVUR7vp4WY=
+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=
@@ -815,6 +825,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=
@@ -823,20 +834,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.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
-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=
@@ -853,12 +859,9 @@ github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh
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/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=
github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
-github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
-github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
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/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
@@ -876,9 +879,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/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
+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=
@@ -921,12 +927,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.1 h1:LWAJwfNvjQZCFIDKWYQaM62NcYeYViCmWIwmOStowAI=
+github.com/pelletier/go-toml/v2 v2.1.1/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-20231207134359-e60b3f734c67 h1:jik8PHtAIsPlCRJjJzl4udgEf7hawInF9texMeO2jrU=
+github.com/petermattis/goid v0.0.0-20231207134359-e60b3f734c67/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=
@@ -937,9 +943,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=
@@ -947,60 +953,55 @@ 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/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
+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.13.0 h1:GqzLlQyfsPbaEHaQkO7tbDlriv/4o5Hudv6OXHGKX7o=
+github.com/prometheus/procfs v0.13.0/go.mod h1:cd4PFCR54QLnGKPaKGA6l+cfuNXtht43ZKY6tow0Y1g=
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/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
-github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rjeczalik/notify v0.9.1 h1:CLCKso/QK1snAlnhNR/CNvNiFU2saUtjV0bx3EwNeCE=
-github.com/rjeczalik/notify v0.9.1/go.mod h1:rKwnCoCGeuQnwBtTSPL9Dad03Vh2n40ePRrjvIXnJho=
github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
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/cors v1.10.1 h1:L0uuZVXIKlI1SShY2nhFfo44TYvDPQ1w4oFkUJNfhyo=
+github.com/rs/cors v1.10.1/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=
@@ -1018,39 +1019,42 @@ 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/status-im/keycard-go v0.0.0-20200402102358-957c09536969 h1:Oo2KZNP70KE0+IUJSidPj/BFS/RXNHmKIJOdckzml2E=
-github.com/status-im/keycard-go v0.0.0-20200402102358-957c09536969/go.mod h1:RZLeN1LMWmRsyYjvAu+I6Dm9QmlDaIIt+Y+4Kd7Tp+Q=
+github.com/spf13/viper v1.18.2 h1:LUXCnvUvSM6FXAsj6nnfc8Q2tp1dIgUfY9Kc8GsSOiQ=
+github.com/spf13/viper v1.18.2/go.mod h1:EKmWIqdnk5lOcmR72yw6hS+8OPYcwD0jteitLMVB+yk=
+github.com/status-im/keycard-go v0.2.0 h1:QDLFswOQu1r5jsycloeQh3bVU8n/NatHHaZobtDnDzA=
+github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9+mHxBEeo3Hbg=
+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=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c=
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
@@ -1061,11 +1065,11 @@ 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/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
+github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
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=
@@ -1089,12 +1093,9 @@ github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1
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=
github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U=
-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/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=
@@ -1108,13 +1109,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=
@@ -1127,24 +1128,37 @@ go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk=
go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E=
go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0=
go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.47.0 h1:UNQQKPfTDe1J81ViolILjTKPr9WetKW6uei2hFgJmFs=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.47.0/go.mod h1:r9vWsPS/3AQItv3OSlEJ/E4mbrhUbbw18meOjArPtKQ=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.47.0 h1:sv9kVfal0MK0wBMCOGr+HeJm9v803BkJxGrk2au7j08=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.47.0/go.mod h1:SK2UL73Zy1quvRPonmOmRDiWk1KBV3LyIeeIxcEApWw=
+go.opentelemetry.io/otel v1.22.0 h1:xS7Ku+7yTFvDfDraDIJVpw7XPyuHlB9MCiqqX5mcJ6Y=
+go.opentelemetry.io/otel v1.22.0/go.mod h1:eoV4iAi3Ea8LkAEI9+GFT44O6T/D0GWAVFyZVCC6pMI=
+go.opentelemetry.io/otel/metric v1.22.0 h1:lypMQnGyJYeuYPhOM/bgjbFM6WE44W1/T45er4d8Hhg=
+go.opentelemetry.io/otel/metric v1.22.0/go.mod h1:evJGjVpZv0mQ5QBRJoBF64yMuOf4xCWdXjK8pzFvliY=
+go.opentelemetry.io/otel/sdk v1.21.0 h1:FTt8qirL1EysG6sTQRZ5TokkU8d0ugCj8htOgThZXQ8=
+go.opentelemetry.io/otel/sdk v1.21.0/go.mod h1:Nna6Yv7PWTdgJHVRD9hIYywQBRx7pbox6nwBnZIxl/E=
+go.opentelemetry.io/otel/trace v1.22.0 h1:Hg6pPujv0XG9QaVbGOBVHunyuLcCC3jN7WEhPx83XD0=
+go.opentelemetry.io/otel/trace v1.22.0/go.mod h1:RbbHXVqKES9QhzZq/fE5UnOSILqRt40a21sPw2He1xo=
go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
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.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-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=
@@ -1154,15 +1168,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.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA=
+golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs=
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=
@@ -1174,8 +1184,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-20240314144324-c7f7c6466f7f h1:3CW0unweImhOzd5FmYuRsD4Y4oQFKZIjAnKbjV4WIrw=
+golang.org/x/exp v0.0.0-20240314144324-c7f7c6466f7f/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=
@@ -1202,8 +1212,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=
@@ -1246,7 +1256,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=
@@ -1254,7 +1263,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=
@@ -1267,8 +1275,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.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs=
+golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
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=
@@ -1294,8 +1302,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.18.0 h1:09qnuIAgzdx1XplqJvW6CQqMCtGZykZWcXzPMPUusvI=
+golang.org/x/oauth2 v0.18.0/go.mod h1:Wf7knwG0MPoWIMMBgFlEaSUDaKskp0dCfrlJRJXbBi8=
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=
@@ -1310,8 +1318,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=
@@ -1370,14 +1378,12 @@ 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-20210324051608-47abb6519492/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=
@@ -1386,10 +1392,10 @@ golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBc
golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
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-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=
@@ -1409,17 +1415,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.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4=
+golang.org/x/sys v0.18.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.18.0 h1:FcHjZXDMxI8mM3nwhX9HlKop4C0YQvCVCdwYl2wOtE8=
+golang.org/x/term v0.18.0/go.mod h1:ILwASektA3OnRv7amZ1xhE/KTR+u50pbXfZ03+6Nx58=
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=
@@ -1431,12 +1437,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=
@@ -1458,6 +1466,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=
@@ -1492,7 +1501,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=
@@ -1500,8 +1508,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=
@@ -1560,8 +1568,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.162.0 h1:Vhs54HkaEpkMBdgGdOT2P6F0csGG/vxDS0hWHJzmmps=
+google.golang.org/api v0.162.0/go.mod h1:6SulDkfoBIg4NFmCuZ39XeeAgSHCPecfSUuDyYlAHs0=
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=
@@ -1569,8 +1577,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=
@@ -1609,10 +1618,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=
@@ -1679,12 +1686,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-20240213162025-012b6fc9bca9 h1:9+tzLLstTlPTRyJTh+ah5wIMsBW5c4tQwGTN3thOW9Y=
+google.golang.org/genproto v0.0.0-20240213162025-012b6fc9bca9/go.mod h1:mqHbVIp48Muh7Ywss/AD6I5kNVKZMmAa/QEW58Gxp2s=
+google.golang.org/genproto/googleapis/api v0.0.0-20240205150955-31a09d347014 h1:x9PwdEgd11LgK+orcck69WVRo7DezSO4VUMPI4xpc8A=
+google.golang.org/genproto/googleapis/api v0.0.0-20240205150955-31a09d347014/go.mod h1:rbHMSEDyoYX62nRVLOCc4Qt1HbsdytAYoVwgjiOhF3I=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240221002015-b0ce06bbee7c h1:NUsgEN92SQQqzfA+YtqYNqYmB3DMMYLlIwUZAQFVFbo=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240221002015-b0ce06bbee7c/go.mod h1:H4O17MA/PE9BsGx3w+a+W2VOLLD1Qf7oJneAoU6WktY=
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=
@@ -1726,8 +1733,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.62.1 h1:B4n+nfKzOICUXMgyrNd19h/I9oH0L1pizfk1d4zSgTk=
+google.golang.org/grpc v1.62.1/go.mod h1:IWTG0VlJLCh1SkC58F7np9ka9mx/WNkjl4PGJaiq+QE=
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=
@@ -1744,8 +1751,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.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
+google.golang.org/protobuf v1.33.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=
@@ -1780,9 +1787,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=
@@ -1791,14 +1797,15 @@ honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWh
honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
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=
+nhooyr.io/websocket v1.8.10 h1:mv4p+MnGrLDcPlBoWsvPP7XCzTYMXP9F9eIGoKbgx7Q=
+nhooyr.io/websocket v1.8.10/go.mod h1:rN9OFWIUwuxg4fR5tELlYC04bXYowCP9GX47ivo2l+c=
+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=
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/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..e82dd6fab 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.3.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.1
+ github.com/avast/retry-go/v4 v4.5.1
+ github.com/cometbft/cometbft v0.38.6
+ github.com/cosmos/cosmos-sdk v0.50.5
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.12
+ github.com/cosmos/ibc-go/modules/capability v1.0.0
+ github.com/cosmos/ibc-go/v8 v8.2.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.9+incompatible
+ github.com/google/uuid v1.6.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/stretchr/testify v1.8.4
- go.uber.org/zap v1.24.0
- golang.org/x/sync v0.2.0
+ 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.9.0
+ go.uber.org/zap v1.27.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.112.0 // indirect
+ cloud.google.com/go/compute v1.24.0 // 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.6 // indirect
+ cloud.google.com/go/storage v1.36.0 // 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.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.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.24.0 // 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.2 // 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,183 @@ 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/go-logr/logr v1.4.1 // indirect
+ github.com/go-logr/stdr v1.2.2 // 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/protobuf v1.5.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.3 // 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.2 // 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.7 // 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.13.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.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.47.0 // indirect
+ go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.47.0 // indirect
+ go.opentelemetry.io/otel v1.22.0 // indirect
+ go.opentelemetry.io/otel/metric v1.22.0 // indirect
+ go.opentelemetry.io/otel/trace v1.22.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/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
+ golang.org/x/crypto v0.21.0 // indirect
+ golang.org/x/exp v0.0.0-20240314144324-c7f7c6466f7f // indirect
+ golang.org/x/mod v0.15.0 // indirect
+ golang.org/x/net v0.23.0 // indirect
+ golang.org/x/oauth2 v0.18.0 // indirect
+ golang.org/x/sys v0.18.0 // indirect
+ golang.org/x/term v0.18.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
+ google.golang.org/api v0.162.0 // indirect
+ google.golang.org/appengine v1.6.8 // indirect
+ google.golang.org/genproto v0.0.0-20240213162025-012b6fc9bca9 // indirect
+ google.golang.org/genproto/googleapis/api v0.0.0-20240205150955-31a09d347014 // indirect
+ google.golang.org/genproto/googleapis/rpc v0.0.0-20240221002015-b0ce06bbee7c // indirect
+ google.golang.org/grpc v1.62.1 // indirect
+ google.golang.org/protobuf v1.33.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..e58d8bb78 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.112.0 h1:tpFCD7hpHFlQ8yPwT3x+QeXqc2T6+n6T+hmABHfDUSM=
+cloud.google.com/go v0.112.0/go.mod h1:3jEEVwZ/MHU4djK5t5RHuKOA/GbLddgTdVubX1qnPD4=
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.24.0 h1:phWcR2eWzRJaL/kOiJwfFsPs4BaKq1j6vnpZrc1YlVg=
+cloud.google.com/go/compute v1.24.0/go.mod h1:kw1/T+h/+tK2LJK0wiPPx1intgdAM3j/g3hFDlscY40=
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.6 h1:bEa06k05IO4f4uJonbB5iAgKTPpABy1ayxaIZV/GHVc=
+cloud.google.com/go/iam v1.1.6/go.mod h1:O0zxdPeGBoFdWW3HWmBxJsk0pfvNM/p/qa82rWOGTwI=
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.36.0 h1:P0mOkAcaJxhCTvAkMhxMfrTKiNcub4YmmPBtlhAyTr8=
+cloud.google.com/go/storage v1.36.0/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.3.0 h1:RC+jryuKeytIiictDslBP9i1fhkVm6ZDmZEoNP316zE=
+cosmossdk.io/math v1.3.0/go.mod h1:vnRTxewy+M7BtXBNFybkuhSH4WfedVAAnERHgVFhp3k=
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.1 h1:Mg+EMp67Pz+NukbJqYxuo8uRp7N/a9uR+oVS9pONtj8=
+cosmossdk.io/x/tx v0.13.1/go.mod h1:CBCU6fsRVz23QGFIQBb1DNX2DztJCf3jWyEkHY2nJQ0=
+cosmossdk.io/x/upgrade v0.1.1 h1:aoPe2gNvH+Gwt/Pgq3dOxxQVU3j5P6Xf+DaUJTDZATc=
+cosmossdk.io/x/upgrade v0.1.1/go.mod h1:MNLptLPcIFK9CWt7Ra//8WUZAxweyRDNcbs5nkOcQy0=
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,25 @@ 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/go.mod h1:nm3Bko6zh6bWP60UxwoT5LzdGJsQJaPo6HjduXq9p6A=
+github.com/btcsuite/btcd v0.24.0 h1:gL3uHE/IaFj6fcZSu03SvqPMSx7s/dPzfpG/atRwWdo=
+github.com/btcsuite/btcd v0.24.0/go.mod h1:K4IDc1593s8jKXIF7yS7yCTSxrknB9z0STzc2j6XgE4=
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 +328,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 +352,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=
@@ -354,89 +367,100 @@ github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWH
github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
+github.com/cncf/xds/go v0.0.0-20231128003011-0fa0005c9caa h1:jQCWAUqqlij9Pgj2i/PB79y4KOPYVyFYdROxgaCwdTQ=
+github.com/cncf/xds/go v0.0.0-20231128003011-0fa0005c9caa/go.mod h1:x/1Gn8zydmfq8dk6e9PdstVsDgu9RuyIIJqAaF//0IM=
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.6 h1:QSgpCzrGWJ2KUq1qpw+FCfASRpE27T6LQbfEHscdyOk=
+github.com/cometbft/cometbft v0.38.6/go.mod h1:8rSPxzUJYquCN8uuBgbUHOMg2KAwvr7CyUw+6ukO4nw=
+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.2 h1:hwMjozuY1OlJs/uh6vddqnk9j7VamLv+0DBlbEXbAKs=
+github.com/cosmos/cosmos-db v1.0.2/go.mod h1:Z8IXcFJ9PqKK6BIsVOB3QXtkKoqUOp1vRvPT39kOXEA=
+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.5 h1:MOEi+DKYgW67YaPgB+Pf+nHbD3V9S/ayitRKJYLfGIA=
+github.com/cosmos/cosmos-sdk v0.50.5/go.mod h1:oV/k6GJgXV9QPoM2fsYDPPsyPBgQbdotv532O6Mz1OQ=
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.12 h1:vB6Lbe/rtnYGjQuFxkPiPYiCybqFT8QvLipDZP8JpFE=
+github.com/cosmos/gogoproto v1.4.12/go.mod h1:LnZob1bXRdUoqMMtwYlcR3wjiElmlC+FkjaZRv1/eLY=
+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.2.0 h1:7oCzyy1sZCcgpeQLnHxC56brsSz3KWwQGKXalXwXFzE=
+github.com/cosmos/ibc-go/v8 v8.2.0/go.mod h1:wj3qx75iC/XNnsMqbPDCIGs0G6Y3E/lo3bdqCyoCy+8=
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 +475,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.9+incompatible h1:HPGzNmwfLZWdxHqK9/II92pyi1EpYKsAqcl4G0Of9v0=
+github.com/docker/docker v24.0.9+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 +504,33 @@ 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/envoyproxy/protoc-gen-validate v1.0.4 h1:gVPz/FMfvh57HdSJQyvBtF00j8JU4zdyUgIUNhlgg0A=
+github.com/envoyproxy/protoc-gen-validate v1.0.4/go.mod h1:qys6tmnRsYrQqIhm2bvKZH4Blx/1gTIZ2UKVY1M+Yew=
+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 +547,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 +555,13 @@ 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-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ=
+github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+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 +574,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 +594,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=
@@ -594,12 +630,13 @@ github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw
github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM=
github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-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/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
+github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
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 +655,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 +684,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.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.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 +715,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 +753,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.3 h1:bN2+Fw9XPFvOCjB0UOevFIMICZ7G2XSQHzfvLUyOM5E=
+github.com/hashicorp/go-getter v1.7.3/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.2 h1:ErEYO2f//CjKsUDw4SmLzelsK6L3ZmOAR/4P9iS7ruY=
+github.com/hashicorp/go-metrics v0.5.2/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 +773,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 +816,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 +855,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.7 h1:ehO88t2UGzQK66LMdE8tibEd1ErmzZjNEqWkjLAKQQg=
+github.com/klauspost/compress v1.17.7/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
+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 +880,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 +893,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 +902,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 +912,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 +935,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 +957,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 +988,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 +1011,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 +1038,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 +1056,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 +1066,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.13.0 h1:GqzLlQyfsPbaEHaQkO7tbDlriv/4o5Hudv6OXHGKX7o=
+github.com/prometheus/procfs v0.13.0/go.mod h1:cd4PFCR54QLnGKPaKGA6l+cfuNXtht43ZKY6tow0Y1g=
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 +1105,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,48 +1132,48 @@ 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=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c=
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
github.com/stretchr/testify v1.1.5-0.20170601210322-f6abca593680/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
@@ -1138,24 +1185,24 @@ 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/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+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 +1213,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 +1228,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=
@@ -1202,23 +1247,37 @@ go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk=
go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E=
go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0=
go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.47.0 h1:UNQQKPfTDe1J81ViolILjTKPr9WetKW6uei2hFgJmFs=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.47.0/go.mod h1:r9vWsPS/3AQItv3OSlEJ/E4mbrhUbbw18meOjArPtKQ=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.47.0 h1:sv9kVfal0MK0wBMCOGr+HeJm9v803BkJxGrk2au7j08=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.47.0/go.mod h1:SK2UL73Zy1quvRPonmOmRDiWk1KBV3LyIeeIxcEApWw=
+go.opentelemetry.io/otel v1.22.0 h1:xS7Ku+7yTFvDfDraDIJVpw7XPyuHlB9MCiqqX5mcJ6Y=
+go.opentelemetry.io/otel v1.22.0/go.mod h1:eoV4iAi3Ea8LkAEI9+GFT44O6T/D0GWAVFyZVCC6pMI=
+go.opentelemetry.io/otel/metric v1.22.0 h1:lypMQnGyJYeuYPhOM/bgjbFM6WE44W1/T45er4d8Hhg=
+go.opentelemetry.io/otel/metric v1.22.0/go.mod h1:evJGjVpZv0mQ5QBRJoBF64yMuOf4xCWdXjK8pzFvliY=
+go.opentelemetry.io/otel/sdk v1.21.0 h1:FTt8qirL1EysG6sTQRZ5TokkU8d0ugCj8htOgThZXQ8=
+go.opentelemetry.io/otel/sdk v1.21.0/go.mod h1:Nna6Yv7PWTdgJHVRD9hIYywQBRx7pbox6nwBnZIxl/E=
+go.opentelemetry.io/otel/trace v1.22.0 h1:Hg6pPujv0XG9QaVbGOBVHunyuLcCC3jN7WEhPx83XD0=
+go.opentelemetry.io/otel/trace v1.22.0/go.mod h1:RbbHXVqKES9QhzZq/fE5UnOSILqRt40a21sPw2He1xo=
go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
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.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
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.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8=
+go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
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 +1291,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.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA=
+golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs=
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 +1305,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-20240314144324-c7f7c6466f7f h1:3CW0unweImhOzd5FmYuRsD4Y4oQFKZIjAnKbjV4WIrw=
+golang.org/x/exp v0.0.0-20240314144324-c7f7c6466f7f/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 +1333,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 +1377,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 +1384,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 +1396,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.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs=
+golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
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 +1423,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.18.0 h1:09qnuIAgzdx1XplqJvW6CQqMCtGZykZWcXzPMPUusvI=
+golang.org/x/oauth2 v0.18.0/go.mod h1:Wf7knwG0MPoWIMMBgFlEaSUDaKskp0dCfrlJRJXbBi8=
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 +1439,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 +1458,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 +1466,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 +1497,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 +1513,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 +1532,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.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4=
+golang.org/x/sys v0.18.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.18.0 h1:FcHjZXDMxI8mM3nwhX9HlKop4C0YQvCVCdwYl2wOtE8=
+golang.org/x/term v0.18.0/go.mod h1:ILwASektA3OnRv7amZ1xhE/KTR+u50pbXfZ03+6Nx58=
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 +1559,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 +1586,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 +1621,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 +1628,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 +1688,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.162.0 h1:Vhs54HkaEpkMBdgGdOT2P6F0csGG/vxDS0hWHJzmmps=
+google.golang.org/api v0.162.0/go.mod h1:6SulDkfoBIg4NFmCuZ39XeeAgSHCPecfSUuDyYlAHs0=
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 +1697,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 +1739,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 +1807,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-20240213162025-012b6fc9bca9 h1:9+tzLLstTlPTRyJTh+ah5wIMsBW5c4tQwGTN3thOW9Y=
+google.golang.org/genproto v0.0.0-20240213162025-012b6fc9bca9/go.mod h1:mqHbVIp48Muh7Ywss/AD6I5kNVKZMmAa/QEW58Gxp2s=
+google.golang.org/genproto/googleapis/api v0.0.0-20240205150955-31a09d347014 h1:x9PwdEgd11LgK+orcck69WVRo7DezSO4VUMPI4xpc8A=
+google.golang.org/genproto/googleapis/api v0.0.0-20240205150955-31a09d347014/go.mod h1:rbHMSEDyoYX62nRVLOCc4Qt1HbsdytAYoVwgjiOhF3I=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240221002015-b0ce06bbee7c h1:NUsgEN92SQQqzfA+YtqYNqYmB3DMMYLlIwUZAQFVFbo=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240221002015-b0ce06bbee7c/go.mod h1:H4O17MA/PE9BsGx3w+a+W2VOLLD1Qf7oJneAoU6WktY=
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 +1854,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.62.1 h1:B4n+nfKzOICUXMgyrNd19h/I9oH0L1pizfk1d4zSgTk=
+google.golang.org/grpc v1.62.1/go.mod h1:IWTG0VlJLCh1SkC58F7np9ka9mx/WNkjl4PGJaiq+QE=
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 +1872,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.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
+google.golang.org/protobuf v1.33.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 +1908,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 +1920,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 +1932,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 +1950,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..4b3653096 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]
@@ -131,7 +129,7 @@ func TestScenarioInterchainAccounts(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)
}
},
)
@@ -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..da794e1e5 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())
@@ -155,13 +202,13 @@ func TestLocalhost_TokenTransfers(t *testing.T) {
func() {
err := r.StopRelayer(ctx, eRep)
if err != nil {
- panic(fmt.Errorf("an error occured while stopping the relayer: %s", err))
+ panic(fmt.Errorf("an error occurred while stopping the relayer: %s", err))
}
},
)
// 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())
@@ -353,12 +399,19 @@ func TestLocalhost_InterchainAccounts(t *testing.T) {
func() {
err := r.StopRelayer(ctx, eRep)
if err != nil {
- panic(fmt.Errorf("an error occured while stopping the relayer: %s", err))
+ panic(fmt.Errorf("an error occurred while stopping the relayer: %s", err))
}
},
)
+ // 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)
@@ -396,12 +449,12 @@ func TestLocalhost_InterchainAccounts(t *testing.T) {
icaAddr := parseInterchainAccountField(stdout)
require.NotEmpty(t, icaAddr)
- // asser the ICA balance, send some funds to the ICA, then re-assert balances
+ // assert 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..9b02a8b5c 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)
@@ -105,7 +118,7 @@ func TestRelayerMisbehaviourDetection(t *testing.T) {
func() {
err := r.StopRelayer(ctx, eRep)
if err != nil {
- panic(fmt.Errorf("an error occured while stopping the relayer: %s", err))
+ panic(fmt.Errorf("an error occurred while stopping the relayer: %s", 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..1a1636104 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]
@@ -107,7 +108,7 @@ func TestMultipleChannelsOneConnection(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)
}
},
)
@@ -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..0da923df7 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)
@@ -94,13 +95,13 @@ func TestScenarioPathFilterAllow(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)
}
},
)
// 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)
@@ -240,13 +241,13 @@ func TestScenarioPathFilterDeny(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)
}
},
)
// 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..a9c5d85eb 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,
},
@@ -106,14 +107,14 @@ func TestRelayerMultiplePathsSingleProcess(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)
}
},
)
// 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..f6d215d62 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",
},
})
@@ -93,7 +93,7 @@ func TestClientOverrideFlag(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)
}
},
)
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..92093d8b2 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)
@@ -482,6 +488,11 @@ func (ccp *CosmosChainProcessor) queryCycle(ctx context.Context, persistence *qu
newLatestQueriedBlock == int64(stuckPacket.EndHeight) {
i = persistence.latestHeight
ccp.log.Debug("Parsed stuck packet height, skipping to current")
+ newLatestQueriedBlock, err = ccp.latestHeightWithRetry(ctx)
+ if err != nil {
+ ccp.log.Error("Failed to query node height after max attempts. Consider checking endpoint and retyring for stuck packets")
+ return err
+ }
}
}
@@ -532,7 +543,12 @@ func (ccp *CosmosChainProcessor) CollectMetrics(ctx context.Context, persistence
// Wait a while before updating the balance
if time.Since(persistence.lastBalanceUpdate) > persistence.balanceUpdateWaitDuration {
- ccp.CurrentRelayerBalance(ctx)
+ err := ccp.CurrentRelayerBalance(ctx)
+ if err != nil {
+ ccp.log.Error(fmt.Sprintf("Failed to update wallet balance metric. Will retry in %v.", persistence.balanceUpdateWaitDuration),
+ zap.Error(err))
+ return
+ }
persistence.lastBalanceUpdate = time.Now()
}
}
@@ -541,15 +557,19 @@ func (ccp *CosmosChainProcessor) CurrentBlockHeight(ctx context.Context, persist
ccp.metrics.SetLatestHeight(ccp.chainProvider.ChainId(), persistence.latestHeight)
}
-func (ccp *CosmosChainProcessor) CurrentRelayerBalance(ctx context.Context) {
+func (ccp *CosmosChainProcessor) CurrentRelayerBalance(ctx context.Context) error {
// 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",
- zap.Error(err),
- )
+ return fmt.Errorf("failed to parse gas prices: %w", err)
}
ccp.parsedGasPrices = &gp
}
@@ -557,23 +577,20 @@ func (ccp *CosmosChainProcessor) CurrentRelayerBalance(ctx context.Context) {
// Get the balance for the chain provider's key
relayerWalletBalances, err := ccp.chainProvider.QueryBalance(ctx, ccp.chainProvider.Key())
if err != nil {
- ccp.log.Error(
- "Failed to query relayer balance",
- zap.Error(err),
- )
+ return fmt.Errorf("failed to query relayer balance: %w", err)
}
address, err := ccp.chainProvider.Address()
if err != nil {
- ccp.log.Error(
- "Failed to get relayer bech32 wallet addresss",
- zap.Error(err),
- )
+ return fmt.Errorf("failed to get relayer bech32 address: %w", 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)
}
+ return nil
}
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..3f2650b19 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
@@ -222,7 +226,7 @@ func CreateMnemonic() (string, error) {
}
// EncodeBech32AccAddr returns the string bech32 representation for the specified account address.
-// It returns an empty sting if the byte slice is 0-length.
+// It returns an empty string if the byte slice is 0-length.
// It returns an error if the bech32 conversion fails or the prefix is empty.
func (cc *CosmosProvider) EncodeBech32AccAddr(addr sdk.AccAddress) (string, error) {
return sdk.Bech32ifyAddressBytes(cc.PCfg.AccountPrefix, addr)
@@ -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 734a41f82..4a237e24d 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,17 +32,15 @@ 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"`
ChainName string `json:"-" yaml:"-"`
ChainID string `json:"chain-id" yaml:"chain-id"`
RPCAddr string `json:"rpc-addr" yaml:"rpc-addr"`
- JSONRPCAddr string `json:"json-rpc-addr" yaml:"json-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"`
@@ -60,23 +58,25 @@ 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.
- FeeGrants *FeeGrantConfiguration `json:"feegrants" yaml:"feegrants"`
-
- PrecompiledContractAddress string `json:"precompiled-contract-address" yaml:"precompiled-contract-address"`
+ // 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"`
+ PrecompiledContractAddress string `json:"precompiled-contract-address" yaml:"precompiled-contract-address"`
+ JSONRPCAddr string `json:"json-rpc-addr" yaml:"json-rpc-addr"`
}
// By default, TXs will be signed by the feegrantees 'ManagedGrantees' keys in a round robin fashion.
// 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
}
@@ -115,7 +115,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
@@ -127,7 +127,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
@@ -150,6 +150,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 {
@@ -228,7 +231,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
@@ -239,13 +242,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
@@ -276,7 +279,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
}
@@ -287,7 +297,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
}
@@ -297,18 +307,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
}
@@ -358,14 +362,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..23aa38093 100644
--- a/relayer/chains/cosmos/query.go
+++ b/relayer/chains/cosmos/query.go
@@ -6,32 +6,33 @@ import (
"encoding/hex"
"errors"
"fmt"
+ "math"
"strconv"
"strings"
"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 +45,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 +58,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 +84,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 +101,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 +126,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 +160,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 +174,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.
@@ -311,7 +316,11 @@ func (cc *CosmosProvider) QueryBalanceWithAddress(ctx context.Context, address s
return coins, nil
}
-func (cc *CosmosProvider) queryParamsSubspaceTime(ctx context.Context, subspace string, key string) (time.Duration, error) {
+func (cc *CosmosProvider) queryParamsSubspaceTime(
+ ctx context.Context,
+ subspace string,
+ key string,
+) (time.Duration, error) {
queryClient := proposal.NewQueryClient(cc)
params := proposal.QueryParamsRequest{Subspace: subspace, Key: key}
@@ -331,6 +340,14 @@ func (cc *CosmosProvider) queryParamsSubspaceTime(ctx context.Context, subspace
return 0, fmt.Errorf("failed to parse %s from %s param: %w", key, subspace, err)
}
+ if unbondingValue > math.MaxInt64 {
+ return 0, fmt.Errorf("value %d is too large to be converted to time.Duration", unbondingValue)
+ }
+
+ if unbondingValue <= 0 {
+ return 0, fmt.Errorf("value %d cannot be less than or equal to zero, unbonding period must be a positive value ", unbondingValue)
+ }
+
return time.Duration(unbondingValue), nil
}
@@ -343,7 +360,7 @@ func (cc *CosmosProvider) QueryUnbondingPeriod(ctx context.Context) (time.Durati
return consumerUnbondingPeriod, nil
}
- //Attempt Staking query.
+ // Attempt Staking query.
unbondingPeriod, stakingParamsErr := cc.queryParamsSubspaceTime(ctx, "staking", "UnbondingTime")
if stakingParamsErr == nil {
return unbondingPeriod, nil
@@ -375,7 +392,7 @@ func (cc *CosmosProvider) QueryTendermintProof(ctx context.Context, height int64
// ABCI queries at heights 1, 2 or less than or equal to 0 are not supported.
// Base app does not support queries for height less than or equal to 1.
// Therefore, a query at height 2 would be equivalent to a query at height 3.
- // A height of 0 will query with the lastest state.
+ // A height of 0 will query with the latest state.
if height != 0 && height <= 2 {
return nil, nil, clienttypes.Height{}, fmt.Errorf("proof queries at height <= 2 are not supported")
}
@@ -878,22 +895,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 +914,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 +935,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 +1033,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 +1061,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)
}
@@ -1212,6 +1228,7 @@ func (cc *CosmosProvider) QueryDenomTrace(ctx context.Context, denom string) (*t
if err != nil {
return nil, err
}
+
return transfers.DenomTrace, nil
}
@@ -1242,6 +1259,21 @@ func (cc *CosmosProvider) QueryDenomTraces(ctx context.Context, offset, limit ui
return transfers, nil
}
+func (cc *CosmosProvider) QueryDenomHash(ctx context.Context, trace string) (string, error) {
+ qc := transfertypes.NewQueryClient(cc)
+
+ req := &transfertypes.QueryDenomHashRequest{
+ Trace: trace,
+ }
+
+ resp, err := qc.DenomHash(ctx, req, nil)
+ if err != nil {
+ return "", err
+ }
+
+ return resp.Hash, nil
+}
+
func (cc *CosmosProvider) QueryStakingParams(ctx context.Context) (*stakingtypes.Params, error) {
res, err := stakingtypes.NewQueryClient(cc).Params(ctx, &stakingtypes.QueryParamsRequest{})
if err != nil {
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 91ec33f3f..9c5895cf8 100644
--- a/relayer/chains/cosmos/tx.go
+++ b/relayer/chains/cosmos/tx.go
@@ -19,13 +19,14 @@ import (
"sync/atomic"
"time"
- errorsmod "cosmossdk.io/errors"
+ 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"
@@ -34,23 +35,22 @@ 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"
authtx "github.com/cosmos/cosmos-sdk/x/auth/tx"
"github.com/cosmos/gogoproto/proto"
- 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"
"github.com/cosmos/relayer/v2/relayer/chains/cosmos/precompile/relayer"
strideicqtypes "github.com/cosmos/relayer/v2/relayer/chains/cosmos/stride"
ethermintcodecs "github.com/cosmos/relayer/v2/relayer/codecs/ethermint"
@@ -203,7 +203,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
}
@@ -212,11 +212,12 @@ func (cc *CosmosProvider) SendMessagesToMempool(
sequenceGuard.Mu.Lock()
defer sequenceGuard.Mu.Unlock()
- txf, txb, err := cc.getTxFactoryAndBuilder(ctx, msgs, memo, 0, txSignerKey, feegranterKey, sequenceGuard)
+ dynamicFee := cc.DynamicFee(ctx)
+ txf, txb, err := cc.getTxFactoryAndBuilder(ctx, msgs, memo, 0, txSignerKey, feegranterKeyOrAddr, sequenceGuard, dynamicFee)
if err != nil {
return err
}
- done := cc.SetSDKContext()
+
var txBytes []byte
var sequence uint64
var fees sdk.Coins
@@ -225,23 +226,35 @@ func (cc *CosmosProvider) SendMessagesToMempool(
} else {
txBytes, sequence, fees, err = cc.buildMessages(ctx, txf, txb, txSignerKey)
}
- done()
+
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)
}
return err
}
+
// we had a successful tx broadcast with this sequence, so update it to the next
cc.updateNextAccountSequence(sequenceGuard, sequence+1)
return nil
@@ -252,7 +265,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
@@ -305,7 +318,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
}
@@ -323,9 +338,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)
}
@@ -351,10 +366,10 @@ func (cc *CosmosProvider) SendMsgsWith(ctx context.Context, msgs []sdk.Msg, memo
err = func() error {
//done := cc.SetSDKContext()
- // ensure that we allways call done, even in case of an error or panic
+ // ensure that we always 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
@@ -411,6 +426,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
@@ -430,7 +446,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)
@@ -438,12 +454,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
@@ -467,7 +481,7 @@ func (cc *CosmosProvider) waitForTx(
cc.log.Error("Failed to wait for block inclusion", zap.Error(err))
if len(callbacks) > 0 {
for _, cb := range callbacks {
- //Call each callback in order since waitForTx is already invoked asyncronously
+ //Call each callback in order since waitForTx is already invoked asynchronously
cb(nil, err)
}
}
@@ -491,11 +505,11 @@ 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 {
- //Call each callback in order since waitForTx is already invoked asyncronously
+ //Call each callback in order since waitForTx is already invoked asynchronously
cb(nil, err)
}
}
@@ -505,7 +519,7 @@ func (cc *CosmosProvider) waitForTx(
if len(callbacks) > 0 {
for _, cb := range callbacks {
- //Call each callback in order since waitForTx is already invoked asyncronously
+ //Call each callback in order since waitForTx is already invoked asynchronously
cb(rlyResp, nil)
}
}
@@ -544,10 +558,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
}
@@ -592,14 +608,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 {
@@ -610,11 +626,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
@@ -627,7 +643,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 {
@@ -646,19 +662,20 @@ func (cc *CosmosProvider) getTxFactoryAndBuilder(
memo string,
gas uint64,
txSignerKey string,
- feegranterKey string,
+ feegranterKeyOrAddr string,
sequenceGuard *WalletState,
+ dynamicFee string,
) (*tx.Factory, client.TxBuilder, error) {
done := cc.SetSDKContext()
defer done()
cMsgs := CosmosMsgs(msgs...)
- txf, err := cc.PrepareFactory(cc.TxFactory(), txSignerKey)
-
+ txf, err := cc.PrepareFactory(cc.TxFactory(dynamicFee), txSignerKey)
if err != nil {
return nil, nil, err
}
+
cc.log.Info("memo", zap.String("origin", memo))
if len(cc.PCfg.PrecompiledContractAddress) == 0 && memo != "" {
txf = txf.WithMemo(memo)
@@ -671,11 +688,19 @@ func (cc *CosmosProvider) getTxFactoryAndBuilder(
txf = txf.WithSequence(sequence)
}
- //Cannot feegrant your own TX
- if txSignerKey != feegranterKey && feegranterKey != "" {
- granterAddr, err := cc.GetKeyAddressForKey(feegranterKey)
- if err != nil {
- return nil, nil, err
+ // 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, nil, err
+ }
+ } else {
+ granterAddr, err = cc.GetKeyAddressForKey(feegranterKeyOrAddr)
+ if err != nil {
+ return nil, nil, err
+ }
}
txf = txf.WithFeeGranter(granterAddr)
@@ -699,9 +724,29 @@ func (cc *CosmosProvider) getTxFactoryAndBuilder(
if err != nil {
return nil, nil, err
}
+
return &txf, txb, nil
}
+// handleAccountSequenceMismatchError will parse the error string, e.g.:
+// "account sequence mismatch, expected 10, got 9: incorrect account sequence"
+// and update the next account sequence with the expected value.
+func (cc *CosmosProvider) handleAccountSequenceMismatchError(sequenceGuard *WalletState, err error) {
+ if sequenceGuard == nil {
+ panic("sequence guard not configured")
+ }
+
+ matches := accountSeqRegex.FindStringSubmatch(err.Error())
+ if len(matches) == 0 {
+ return
+ }
+ nextSeq, err := strconv.ParseUint(matches[1], 10, 64)
+ if err != nil {
+ return
+ }
+ sequenceGuard.NextAccountSequence = nextSeq
+}
+
func convertAddress(addrString string) (*common.Address, error) {
cfg := sdk.GetConfig()
var addr []byte
@@ -723,7 +768,7 @@ func convertAddress(addrString string) (*common.Address, error) {
func convertCoins(prices string) (sdk.Coins, error) {
coins, err := sdk.ParseCoinsNormalized(prices)
if err != nil {
- return nil, errorsmod.Wrapf(err, "failed to parse coins")
+ return nil, sdkerrors.Wrapf(err, "failed to parse coins")
}
return coins, nil
}
@@ -734,7 +779,7 @@ func (cc *CosmosProvider) buildMessages(
txb client.TxBuilder,
txSignerKey string,
) ([]byte, uint64, sdk.Coins, error) {
- 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
}
tx := txb.GetTx()
@@ -762,8 +807,6 @@ func getChainConfig(chainID *big.Int) *params.ChainConfig {
arrowGlacierBlock := new(big.Int)
grayGlacierBlock := new(big.Int)
mergeNetsplitBlock := new(big.Int)
- shanghaiBlock := new(big.Int)
- cancunBlock := new(big.Int)
return ¶ms.ChainConfig{
ChainID: chainID,
@@ -783,8 +826,7 @@ func getChainConfig(chainID *big.Int) *params.ChainConfig {
ArrowGlacierBlock: arrowGlacierBlock,
GrayGlacierBlock: grayGlacierBlock,
MergeNetsplitBlock: mergeNetsplitBlock,
- ShanghaiBlock: shanghaiBlock,
- CancunBlock: cancunBlock,
+ ShanghaiTime: nil,
}
}
@@ -932,6 +974,18 @@ type inputAndSigners struct {
Signers []sdk.AccAddress
}
+type MsgWithSigners interface {
+ GetSigners() []sdk.AccAddress
+}
+
+func extractSigners(msg proto.Message) []sdk.AccAddress {
+ var signers []sdk.AccAddress
+ if i, ok := msg.(MsgWithSigners); ok {
+ signers = i.GetSigners()
+ }
+ return signers
+}
+
func extractMsgInputs(msgs []sdk.Msg) (method string, results []*inputAndSigners, err error) {
for _, c := range methodCombos {
if len(msgs) < len(c.Methods) {
@@ -953,7 +1007,8 @@ func extractMsgInputs(msgs []sdk.Msg) (method string, results []*inputAndSigners
}
method = c.NewMethodName
- results = append(results, &inputAndSigners{input, msgs[0].GetSigners()})
+ signers := extractSigners(msgs[0])
+ results = append(results, &inputAndSigners{input, signers})
msgs = msgs[len(c.Methods):]
break
}
@@ -964,15 +1019,15 @@ func extractMsgInputs(msgs []sdk.Msg) (method string, results []*inputAndSigners
var ok bool
method, ok = messageMap[t]
if !ok {
- return "", nil, errorsmod.Wrapf(sdkerrors.ErrUnknownRequest, "invalid message type %T", m)
+ return "", nil, sdkerrors.Wrapf(legacyerrors.ErrUnknownRequest, "invalid message type %T", m)
}
input, err := packData(method, m)
if err != nil {
return "", nil, err
}
-
- results = append(results, &inputAndSigners{input, m.GetSigners()})
+ signers := extractSigners(m)
+ results = append(results, &inputAndSigners{input, signers})
}
return
}
@@ -1002,13 +1057,14 @@ func (cc *CosmosProvider) buildEvmMessages(
return nil, 0, sdk.Coins{}, errors.New("unsupported extOption")
}
}
- txs := make([]sdk.Msg, 0, len(txb.GetTx().GetMsgs()))
+ msgs := txb.GetTx().GetMsgs()
+ txs := make([]sdk.Msg, 0, len(msgs))
fees := make(sdk.Coins, 0)
var txGasLimit uint64 = 0
contractAddress := common.HexToAddress(cc.PCfg.PrecompiledContractAddress)
blockNumber := new(big.Int)
- _, inputs, err := extractMsgInputs(txb.GetTx().GetMsgs())
+ _, inputs, err := extractMsgInputs(msgs)
if err != nil {
return nil, 0, sdk.Coins{}, err
}
@@ -1016,7 +1072,7 @@ func (cc *CosmosProvider) buildEvmMessages(
for i, is := range inputs {
signers := is.Signers
if len(signers) != 1 {
- return nil, 0, sdk.Coins{}, errorsmod.Wrapf(sdkerrors.ErrUnknownRequest, "invalid signers length %d", len(signers))
+ return nil, 0, sdk.Coins{}, sdkerrors.Wrapf(legacyerrors.ErrUnknownRequest, "invalid signers length %d", len(signers))
}
from, err := convertAddress(signers[0].String())
if err != nil {
@@ -1043,7 +1099,7 @@ func (cc *CosmosProvider) buildEvmMessages(
fees = fees.Add(sdk.NewCoin(gasPriceCoin.Denom, feeAmt))
}
txGasLimit += tx.GetGas()
- cc.log.Info("append", zap.String("hash", tx.Hash))
+ // cc.log.Info("append", zap.String("hash", tx.Hash))
txs = append(txs, tx)
}
@@ -1067,25 +1123,6 @@ func (cc *CosmosProvider) buildEvmMessages(
return txBytes, txf.Sequence(), fees, nil
}
-// handleAccountSequenceMismatchError will parse the error string, e.g.:
-// "account sequence mismatch, expected 10, got 9: incorrect account sequence"
-// and update the next account sequence with the expected value.
-func (cc *CosmosProvider) handleAccountSequenceMismatchError(sequenceGuard *WalletState, err error) {
- if sequenceGuard == nil {
- panic("sequence guard not configured")
- }
-
- matches := accountSeqRegex.FindStringSubmatch(err.Error())
- if len(matches) == 0 {
- return
- }
- nextSeq, err := strconv.ParseUint(matches[1], 10, 64)
- if err != nil {
- return
- }
- sequenceGuard.NextAccountSequence = nextSeq
-}
-
// MsgCreateClient creates an sdk.Msg to update the client on src with consensus state from dst
func (cc *CosmosProvider) MsgCreateClient(
clientState ibcexported.ClientState,
@@ -1428,7 +1465,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{
@@ -1437,7 +1474,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,
@@ -1706,6 +1743,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,
@@ -1958,7 +1996,8 @@ func (cc *CosmosProvider) NewClientState(
dstChainID string,
dstUpdateHeader provider.IBCHeader,
dstTrustingPeriod,
- dstUbdPeriod time.Duration,
+ dstUbdPeriod,
+ maxClockDrift time.Duration,
allowUpdateAfterExpiry,
allowUpdateAfterMisbehaviour bool,
) (ibcexported.ClientState, error) {
@@ -1970,7 +2009,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,
@@ -1983,7 +2022,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
@@ -1993,10 +2032,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)
}
}
@@ -2066,9 +2110,6 @@ func (cc *CosmosProvider) PrepareFactory(txf tx.Factory, signingKey string) (tx.
if cc.PCfg.MinGasAmount != 0 {
txf = txf.WithGas(cc.PCfg.MinGasAmount)
}
- if cc.PCfg.MaxGasAmount != 0 {
- txf = txf.WithGas(cc.PCfg.MaxGasAmount)
- }
if cc.PCfg.MaxGasAmount != 0 {
txf = txf.WithGas(cc.PCfg.MaxGasAmount)
@@ -2107,7 +2148,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")
}
@@ -2241,7 +2282,6 @@ func (cc *CosmosProvider) CalculateGas(ctx context.Context, txf tx.Factory, sign
}
return txtypes.SimulateResponse{}, gas, err
}
-
keyInfo, err := cc.Keybase.Key(signingKey)
if err != nil {
return txtypes.SimulateResponse{}, 0, err
@@ -2280,18 +2320,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())
}
@@ -2310,10 +2357,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
@@ -2333,11 +2381,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 a14292291..72e8262b7 100644
--- a/relayer/chains/cosmos/tx_test.go
+++ b/relayer/chains/cosmos/tx_test.go
@@ -2,30 +2,21 @@ package cosmos
import (
"fmt"
+ "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/provider"
etherminttypes "github.com/evmos/ethermint/types"
"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
@@ -51,6 +42,14 @@ func TestCosmosProvider_AdjustEstimatedGas(t *testing.T) {
expectedGas: 75000,
expectedErr: nil,
},
+ {
+ name: "gas used is infinite",
+ gasUsed: 10000,
+ gasAdjustment: math.Inf(1),
+ maxGasAmount: 0,
+ expectedGas: 0,
+ expectedErr: fmt.Errorf("infinite gas used"),
+ },
{
name: "gas used is non-zero with zero max gas amount as default",
gasUsed: 50000,
@@ -86,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{
@@ -120,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()
@@ -134,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 := (ðerminttypes.ExtensionOptionDynamicFeeTx{
MaxPriorityPrice: max,
@@ -146,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..ead607cc4 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"
)
@@ -153,7 +153,7 @@ func (mcp *MockChainProcessor) queryCycle(ctx context.Context, persistence *quer
// iterate through ibc messages and call specific handler for each
// will do things like mutate chainprocessor state and add relevant messages to foundMessages
- // this can be parralelized also
+ // this can be parallelized also
for _, m := range messages {
if handler, ok := messageHandlers[m.EventType]; ok {
handler(msgHandlerParams{
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/v1/cnidarium.pb.go b/relayer/chains/penumbra/cnidarium/v1/cnidarium.pb.go
new file mode 100644
index 000000000..c4218d741
--- /dev/null
+++ b/relayer/chains/penumbra/cnidarium/v1/cnidarium.pb.go
@@ -0,0 +1,2546 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: penumbra/cnidarium/v1/cnidarium.proto
+
+package cnidariumv1
+
+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 {
+ // 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_c16e20a97a348b2e, []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) 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_c16e20a97a348b2e, []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_c16e20a97a348b2e, []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 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_c16e20a97a348b2e, []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) 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_c16e20a97a348b2e, []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_c16e20a97a348b2e, []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_c16e20a97a348b2e, []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_c16e20a97a348b2e, []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_c16e20a97a348b2e, []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.v1.KeyValueRequest")
+ proto.RegisterType((*KeyValueResponse)(nil), "penumbra.cnidarium.v1.KeyValueResponse")
+ proto.RegisterType((*KeyValueResponse_Value)(nil), "penumbra.cnidarium.v1.KeyValueResponse.Value")
+ proto.RegisterType((*PrefixValueRequest)(nil), "penumbra.cnidarium.v1.PrefixValueRequest")
+ proto.RegisterType((*PrefixValueResponse)(nil), "penumbra.cnidarium.v1.PrefixValueResponse")
+ proto.RegisterType((*WatchRequest)(nil), "penumbra.cnidarium.v1.WatchRequest")
+ proto.RegisterType((*WatchResponse)(nil), "penumbra.cnidarium.v1.WatchResponse")
+ proto.RegisterType((*WatchResponse_KeyValue)(nil), "penumbra.cnidarium.v1.WatchResponse.KeyValue")
+ proto.RegisterType((*WatchResponse_NvKeyValue)(nil), "penumbra.cnidarium.v1.WatchResponse.NvKeyValue")
+}
+
+func init() {
+ proto.RegisterFile("penumbra/cnidarium/v1/cnidarium.proto", fileDescriptor_c16e20a97a348b2e)
+}
+
+var fileDescriptor_c16e20a97a348b2e = []byte{
+ // 629 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x54, 0xcd, 0x6e, 0xd3, 0x40,
+ 0x10, 0xce, 0x6e, 0xeb, 0xfe, 0x4c, 0x03, 0x54, 0x0b, 0x85, 0x10, 0x44, 0x14, 0x52, 0xa0, 0x05,
+ 0x81, 0x5d, 0x97, 0x53, 0x83, 0x10, 0x52, 0x2a, 0x01, 0x52, 0x49, 0x65, 0x02, 0x0a, 0x08, 0x2a,
+ 0x55, 0x8e, 0x33, 0x6d, 0xad, 0xc4, 0x76, 0x58, 0x3b, 0xab, 0xfa, 0x0d, 0x38, 0xf2, 0x0c, 0xdc,
+ 0xe0, 0xc6, 0x5b, 0x20, 0x4e, 0x3d, 0xc2, 0x0d, 0x25, 0x37, 0x9e, 0x02, 0xf9, 0x3f, 0x81, 0x50,
+ 0x22, 0x6e, 0xfe, 0x66, 0x67, 0xbe, 0xef, 0x9b, 0x9d, 0xf1, 0xc2, 0x8d, 0x1e, 0xda, 0x7d, 0xab,
+ 0xc5, 0x75, 0xc5, 0xb0, 0xcd, 0xb6, 0xce, 0xcd, 0xbe, 0xa5, 0x08, 0x35, 0x03, 0x72, 0x8f, 0x3b,
+ 0x9e, 0xc3, 0x56, 0x92, 0x34, 0x39, 0x3b, 0x11, 0x6a, 0x71, 0xcd, 0x6c, 0x19, 0x8a, 0xe1, 0x70,
+ 0x54, 0x0c, 0xc7, 0xb2, 0x4c, 0xcf, 0x42, 0xdb, 0x0b, 0xcb, 0x53, 0x14, 0xd5, 0x57, 0xb6, 0xe0,
+ 0xdc, 0x0e, 0xfa, 0x4d, 0xbd, 0xdb, 0xc7, 0x06, 0xbe, 0xed, 0xa3, 0xeb, 0xb1, 0x65, 0x98, 0xe9,
+ 0xa0, 0x5f, 0xa0, 0x65, 0xb2, 0xbe, 0xd8, 0x08, 0x3e, 0xd9, 0x05, 0x90, 0x7a, 0xdc, 0x71, 0x0e,
+ 0x0a, 0x33, 0x65, 0xb2, 0xbe, 0xd0, 0x88, 0x40, 0xe5, 0x33, 0x81, 0xe5, 0xac, 0xd6, 0xed, 0x39,
+ 0xb6, 0x8b, 0x6c, 0x1b, 0x24, 0x11, 0x04, 0x0a, 0xa4, 0x4c, 0xd6, 0x97, 0x36, 0xef, 0xca, 0x13,
+ 0xfd, 0xc9, 0xbf, 0xd7, 0xc9, 0x11, 0x8a, 0x6a, 0xd9, 0x56, 0xa2, 0x47, 0x43, 0x92, 0x55, 0xd9,
+ 0x6c, 0x19, 0x72, 0xd0, 0x8d, 0x3c, 0xe2, 0x5f, 0xa8, 0x72, 0x1d, 0x79, 0xa7, 0x8b, 0x5a, 0x90,
+ 0x1a, 0x9b, 0x2a, 0x5e, 0x05, 0x29, 0xa4, 0x0a, 0x3c, 0x67, 0x46, 0xf2, 0x31, 0x73, 0xe5, 0x0e,
+ 0x30, 0x8d, 0xe3, 0x81, 0x79, 0x3c, 0xd6, 0xf1, 0x45, 0x98, 0xeb, 0x85, 0xd1, 0xb8, 0xe9, 0x18,
+ 0x55, 0x1e, 0xc0, 0xf9, 0xb1, 0xec, 0xb8, 0xc7, 0xf8, 0x82, 0xc8, 0xd8, 0x05, 0x45, 0x62, 0x74,
+ 0x54, 0xac, 0x0e, 0xf9, 0x97, 0xba, 0x67, 0x1c, 0x25, 0x32, 0x57, 0x60, 0xb1, 0x83, 0xfe, 0x3e,
+ 0xc7, 0x43, 0x3c, 0x8e, 0xab, 0x17, 0x3a, 0xe8, 0x37, 0x02, 0xcc, 0xca, 0x90, 0xb7, 0xc5, 0x7e,
+ 0x76, 0x1e, 0x39, 0x01, 0x5b, 0xec, 0xc4, 0x19, 0x95, 0xef, 0x14, 0xce, 0xc4, 0x7c, 0xb1, 0x91,
+ 0x02, 0xcc, 0x0b, 0xe4, 0xae, 0xe9, 0xd8, 0x21, 0xdd, 0x6c, 0x23, 0x81, 0xec, 0x21, 0xd0, 0x8e,
+ 0x28, 0x48, 0xa7, 0xce, 0x60, 0x8c, 0x2b, 0x9d, 0xc8, 0x93, 0x5c, 0x83, 0x76, 0x04, 0x7b, 0x04,
+ 0x52, 0x60, 0x47, 0x14, 0xe6, 0x42, 0x0e, 0x65, 0x2a, 0x8e, 0x5d, 0x31, 0xc2, 0x32, 0x6b, 0x8b,
+ 0x1d, 0x51, 0x7c, 0x0a, 0x0b, 0x49, 0x6c, 0xda, 0x7b, 0x0b, 0xda, 0x6a, 0x63, 0x17, 0x3d, 0x6c,
+ 0xc7, 0x0b, 0x97, 0xc0, 0xe2, 0x2e, 0x40, 0xa6, 0x31, 0xca, 0x97, 0xff, 0x2f, 0xbe, 0xda, 0x3c,
+ 0x48, 0x68, 0x7b, 0xdc, 0xdf, 0xfc, 0x48, 0x21, 0xff, 0xac, 0x8f, 0xdc, 0x7f, 0x8e, 0x5c, 0x98,
+ 0x06, 0xb2, 0x37, 0x23, 0xbe, 0x6f, 0xfe, 0x73, 0x89, 0xc3, 0xf9, 0x16, 0xd7, 0xa6, 0x5c, 0x76,
+ 0x76, 0x00, 0x4b, 0x23, 0x7b, 0xc5, 0x6e, 0xfd, 0xa5, 0xee, 0xcf, 0x4d, 0x2d, 0xde, 0x9e, 0x26,
+ 0x35, 0x52, 0xd9, 0x20, 0xec, 0x05, 0x48, 0xe1, 0x80, 0xd8, 0xea, 0xe9, 0xe3, 0x8b, 0xb8, 0xaf,
+ 0x4f, 0x33, 0xe3, 0x0d, 0x52, 0x7b, 0x47, 0xbf, 0x0c, 0x4a, 0xe4, 0x64, 0x50, 0x22, 0x3f, 0x06,
+ 0x25, 0xf2, 0x7e, 0x58, 0xca, 0x9d, 0x0c, 0x4b, 0xb9, 0x6f, 0xc3, 0x52, 0x0e, 0x2e, 0x1b, 0x8e,
+ 0x35, 0x99, 0xa5, 0x76, 0x76, 0x3b, 0x41, 0x5a, 0xf0, 0xf0, 0x68, 0xe4, 0x75, 0xfd, 0xd0, 0xf4,
+ 0x8e, 0xfa, 0xad, 0xe0, 0x9f, 0x56, 0x0c, 0xc7, 0xb5, 0x1c, 0x57, 0xe1, 0xd8, 0xd5, 0x7d, 0xe4,
+ 0x8a, 0xd8, 0x4c, 0x3f, 0x8d, 0x23, 0xdd, 0xb4, 0x5d, 0x65, 0xe2, 0x6b, 0x78, 0x3f, 0x05, 0x42,
+ 0xfd, 0x40, 0x67, 0xb4, 0xed, 0x57, 0x9f, 0xe8, 0x8a, 0x96, 0xc8, 0xa7, 0x82, 0x72, 0x53, 0xfd,
+ 0x9a, 0xc5, 0xf7, 0xd2, 0xf8, 0x5e, 0x53, 0x1d, 0xd0, 0x6b, 0x13, 0xe3, 0x7b, 0x8f, 0xb5, 0x5a,
+ 0x1d, 0x3d, 0xbd, 0xad, 0x7b, 0xfa, 0x4f, 0x7a, 0x29, 0xc9, 0xa9, 0x56, 0xd3, 0xa4, 0x6a, 0xb5,
+ 0xa9, 0xb6, 0xe6, 0xc2, 0x47, 0xf4, 0xde, 0xaf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe6, 0x73, 0xfd,
+ 0xf7, 0xad, 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 {
+ // 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.v1.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.v1.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.v1.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.v1.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.v1.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/v1/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
+ }
+ 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
+ }
+ 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.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.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 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 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/v1/app.pb.go b/relayer/chains/penumbra/core/app/v1/app.pb.go
new file mode 100644
index 000000000..7637e923a
--- /dev/null
+++ b/relayer/chains/penumbra/core/app/v1/app.pb.go
@@ -0,0 +1,2886 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: penumbra/core/app/v1/app.proto
+
+package appv1
+
+import (
+ context "context"
+ fmt "fmt"
+ grpc1 "github.com/cosmos/gogoproto/grpc"
+ proto "github.com/cosmos/gogoproto/proto"
+ v12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/community_pool/v1"
+ v110 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/dex/v1"
+ v17 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/distributions/v1"
+ v16 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/fee/v1"
+ v18 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/funding/v1"
+ v13 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/governance/v1"
+ v14 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/ibc/v1"
+ v11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/sct/v1"
+ v19 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/shielded_pool/v1"
+ v15 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/stake/v1"
+ v1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/transaction/v1"
+ 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 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_cd5d94926a61eaaf, []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) GetBlockHeight() uint64 {
+ if m != nil {
+ return m.BlockHeight
+ }
+ return 0
+}
+
+// A transaction that appeared within a given block.
+type TransactionsByHeightResponse struct {
+ // The transactions.
+ Transactions []*v1.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_cd5d94926a61eaaf, []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() []*v1.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 {
+ // The chain identifier.
+ ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
+ // Sct module parameters.
+ SctParams *v11.SctParameters `protobuf:"bytes,2,opt,name=sct_params,json=sctParams,proto3" json:"sct_params,omitempty"`
+ // Community Pool module parameters.
+ CommunityPoolParams *v12.CommunityPoolParameters `protobuf:"bytes,3,opt,name=community_pool_params,json=communityPoolParams,proto3" json:"community_pool_params,omitempty"`
+ // Governance module parameters.
+ GovernanceParams *v13.GovernanceParameters `protobuf:"bytes,4,opt,name=governance_params,json=governanceParams,proto3" json:"governance_params,omitempty"`
+ // IBC module parameters.
+ IbcParams *v14.IbcParameters `protobuf:"bytes,5,opt,name=ibc_params,json=ibcParams,proto3" json:"ibc_params,omitempty"`
+ // Stake module parameters.
+ StakeParams *v15.StakeParameters `protobuf:"bytes,6,opt,name=stake_params,json=stakeParams,proto3" json:"stake_params,omitempty"`
+ // Fee module parameters.
+ FeeParams *v16.FeeParameters `protobuf:"bytes,7,opt,name=fee_params,json=feeParams,proto3" json:"fee_params,omitempty"`
+ // Distributions module parameters.
+ DistributionsParams *v17.DistributionsParameters `protobuf:"bytes,8,opt,name=distributions_params,json=distributionsParams,proto3" json:"distributions_params,omitempty"`
+ // Funding module parameters.
+ FundingParams *v18.FundingParameters `protobuf:"bytes,9,opt,name=funding_params,json=fundingParams,proto3" json:"funding_params,omitempty"`
+ // Shielded pool module parameters.
+ ShieldedPoolParams *v19.ShieldedPoolParameters `protobuf:"bytes,10,opt,name=shielded_pool_params,json=shieldedPoolParams,proto3" json:"shielded_pool_params,omitempty"`
+ // DEX module parameters.
+ DexParams *v110.DexParameters `protobuf:"bytes,11,opt,name=dex_params,json=dexParams,proto3" json:"dex_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_cd5d94926a61eaaf, []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) GetChainId() string {
+ if m != nil {
+ return m.ChainId
+ }
+ return ""
+}
+
+func (m *AppParameters) GetSctParams() *v11.SctParameters {
+ if m != nil {
+ return m.SctParams
+ }
+ return nil
+}
+
+func (m *AppParameters) GetCommunityPoolParams() *v12.CommunityPoolParameters {
+ if m != nil {
+ return m.CommunityPoolParams
+ }
+ return nil
+}
+
+func (m *AppParameters) GetGovernanceParams() *v13.GovernanceParameters {
+ if m != nil {
+ return m.GovernanceParams
+ }
+ return nil
+}
+
+func (m *AppParameters) GetIbcParams() *v14.IbcParameters {
+ if m != nil {
+ return m.IbcParams
+ }
+ return nil
+}
+
+func (m *AppParameters) GetStakeParams() *v15.StakeParameters {
+ if m != nil {
+ return m.StakeParams
+ }
+ return nil
+}
+
+func (m *AppParameters) GetFeeParams() *v16.FeeParameters {
+ if m != nil {
+ return m.FeeParams
+ }
+ return nil
+}
+
+func (m *AppParameters) GetDistributionsParams() *v17.DistributionsParameters {
+ if m != nil {
+ return m.DistributionsParams
+ }
+ return nil
+}
+
+func (m *AppParameters) GetFundingParams() *v18.FundingParameters {
+ if m != nil {
+ return m.FundingParams
+ }
+ return nil
+}
+
+func (m *AppParameters) GetShieldedPoolParams() *v19.ShieldedPoolParameters {
+ if m != nil {
+ return m.ShieldedPoolParams
+ }
+ return nil
+}
+
+func (m *AppParameters) GetDexParams() *v110.DexParameters {
+ if m != nil {
+ return m.DexParams
+ }
+ return nil
+}
+
+// Requests the global configuration data for the app.
+type AppParametersRequest struct {
+}
+
+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_cd5d94926a61eaaf, []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
+
+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_cd5d94926a61eaaf, []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_cd5d94926a61eaaf, []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 {
+ // The initial chain identifier.
+ ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
+ // Stake module genesis state.
+ StakeContent *v15.GenesisContent `protobuf:"bytes,2,opt,name=stake_content,json=stakeContent,proto3" json:"stake_content,omitempty"`
+ // Shielded pool module genesis state.
+ ShieldedPoolContent *v19.GenesisContent `protobuf:"bytes,3,opt,name=shielded_pool_content,json=shieldedPoolContent,proto3" json:"shielded_pool_content,omitempty"`
+ // Governance module genesis state.
+ GovernanceContent *v13.GenesisContent `protobuf:"bytes,4,opt,name=governance_content,json=governanceContent,proto3" json:"governance_content,omitempty"`
+ // IBC module genesis state.
+ IbcContent *v14.GenesisContent `protobuf:"bytes,5,opt,name=ibc_content,json=ibcContent,proto3" json:"ibc_content,omitempty"`
+ // Sct module genesis state.
+ SctContent *v11.GenesisContent `protobuf:"bytes,6,opt,name=sct_content,json=sctContent,proto3" json:"sct_content,omitempty"`
+ // Community Pool module genesis state.
+ CommunityPoolContent *v12.GenesisContent `protobuf:"bytes,7,opt,name=community_pool_content,json=communityPoolContent,proto3" json:"community_pool_content,omitempty"`
+ // Fee module genesis state.
+ FeeContent *v16.GenesisContent `protobuf:"bytes,8,opt,name=fee_content,json=feeContent,proto3" json:"fee_content,omitempty"`
+ // Distributions module genesis state.
+ DistributionsContent *v17.GenesisContent `protobuf:"bytes,9,opt,name=distributions_content,json=distributionsContent,proto3" json:"distributions_content,omitempty"`
+ // Funding module genesis state.
+ FundingContent *v18.GenesisContent `protobuf:"bytes,10,opt,name=funding_content,json=fundingContent,proto3" json:"funding_content,omitempty"`
+ // DEX component genesis state.
+ DexContent *v110.GenesisContent `protobuf:"bytes,11,opt,name=dex_content,json=dexContent,proto3" json:"dex_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_cd5d94926a61eaaf, []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) GetChainId() string {
+ if m != nil {
+ return m.ChainId
+ }
+ return ""
+}
+
+func (m *GenesisContent) GetStakeContent() *v15.GenesisContent {
+ if m != nil {
+ return m.StakeContent
+ }
+ return nil
+}
+
+func (m *GenesisContent) GetShieldedPoolContent() *v19.GenesisContent {
+ if m != nil {
+ return m.ShieldedPoolContent
+ }
+ return nil
+}
+
+func (m *GenesisContent) GetGovernanceContent() *v13.GenesisContent {
+ if m != nil {
+ return m.GovernanceContent
+ }
+ return nil
+}
+
+func (m *GenesisContent) GetIbcContent() *v14.GenesisContent {
+ if m != nil {
+ return m.IbcContent
+ }
+ return nil
+}
+
+func (m *GenesisContent) GetSctContent() *v11.GenesisContent {
+ if m != nil {
+ return m.SctContent
+ }
+ return nil
+}
+
+func (m *GenesisContent) GetCommunityPoolContent() *v12.GenesisContent {
+ if m != nil {
+ return m.CommunityPoolContent
+ }
+ return nil
+}
+
+func (m *GenesisContent) GetFeeContent() *v16.GenesisContent {
+ if m != nil {
+ return m.FeeContent
+ }
+ return nil
+}
+
+func (m *GenesisContent) GetDistributionsContent() *v17.GenesisContent {
+ if m != nil {
+ return m.DistributionsContent
+ }
+ return nil
+}
+
+func (m *GenesisContent) GetFundingContent() *v18.GenesisContent {
+ if m != nil {
+ return m.FundingContent
+ }
+ return nil
+}
+
+func (m *GenesisContent) GetDexContent() *v110.GenesisContent {
+ if m != nil {
+ return m.DexContent
+ }
+ return nil
+}
+
+func init() {
+ proto.RegisterType((*TransactionsByHeightRequest)(nil), "penumbra.core.app.v1.TransactionsByHeightRequest")
+ proto.RegisterType((*TransactionsByHeightResponse)(nil), "penumbra.core.app.v1.TransactionsByHeightResponse")
+ proto.RegisterType((*AppParameters)(nil), "penumbra.core.app.v1.AppParameters")
+ proto.RegisterType((*AppParametersRequest)(nil), "penumbra.core.app.v1.AppParametersRequest")
+ proto.RegisterType((*AppParametersResponse)(nil), "penumbra.core.app.v1.AppParametersResponse")
+ proto.RegisterType((*GenesisAppState)(nil), "penumbra.core.app.v1.GenesisAppState")
+ proto.RegisterType((*GenesisContent)(nil), "penumbra.core.app.v1.GenesisContent")
+}
+
+func init() { proto.RegisterFile("penumbra/core/app/v1/app.proto", fileDescriptor_cd5d94926a61eaaf) }
+
+var fileDescriptor_cd5d94926a61eaaf = []byte{
+ // 1136 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x57, 0xcf, 0x6e, 0x23, 0x35,
+ 0x1c, 0xce, 0x64, 0x4b, 0xdb, 0x38, 0x69, 0xcb, 0x4e, 0xd3, 0xa5, 0x14, 0x14, 0x95, 0xc0, 0xa1,
+ 0xfc, 0x9b, 0xec, 0x04, 0x81, 0x20, 0x8b, 0xd0, 0x26, 0x45, 0xdb, 0x2e, 0x62, 0xb5, 0x21, 0x5d,
+ 0x7a, 0x80, 0x48, 0xd1, 0xc4, 0xe3, 0x24, 0xa3, 0x26, 0x33, 0x66, 0xec, 0x8c, 0xd2, 0x03, 0xef,
+ 0xb0, 0xcf, 0xc0, 0x09, 0xf1, 0x24, 0x88, 0xd3, 0xde, 0xe0, 0x88, 0xd2, 0x1b, 0x2f, 0xb0, 0x57,
+ 0x64, 0x8f, 0x9d, 0xd8, 0xd3, 0xcc, 0x4e, 0xf6, 0x14, 0xfb, 0xf3, 0xef, 0xf7, 0x7d, 0xf6, 0xcf,
+ 0xf6, 0xe7, 0x09, 0xa8, 0x60, 0xe4, 0x4f, 0x27, 0xfd, 0xd0, 0xa9, 0xc1, 0x20, 0x44, 0x35, 0x07,
+ 0xe3, 0x5a, 0x64, 0xb3, 0x1f, 0x0b, 0x87, 0x01, 0x0d, 0xcc, 0xb2, 0x1c, 0xb7, 0xd8, 0xb8, 0xc5,
+ 0x06, 0x22, 0xfb, 0xe8, 0x1b, 0x3d, 0x0b, 0x06, 0x13, 0x1c, 0xf8, 0xc8, 0xa7, 0xac, 0x35, 0x99,
+ 0xfa, 0x1e, 0xbd, 0xee, 0xe1, 0x20, 0x18, 0x33, 0x2a, 0x1d, 0x89, 0x59, 0x8f, 0x4e, 0xd2, 0xf2,
+ 0x5d, 0x34, 0x63, 0x49, 0x2e, 0x9a, 0x89, 0xc8, 0xaf, 0x53, 0x23, 0x3d, 0x42, 0x43, 0xaf, 0x3f,
+ 0xa5, 0x5e, 0xe0, 0x13, 0x9e, 0xa3, 0x02, 0x59, 0x3a, 0x03, 0x84, 0x58, 0xce, 0x00, 0x21, 0x11,
+ 0x79, 0x3f, 0x35, 0x72, 0xea, 0xbb, 0x9e, 0x3f, 0xe4, 0xd1, 0x71, 0x53, 0x64, 0x7c, 0x91, 0x96,
+ 0x31, 0x0c, 0x22, 0x14, 0xfa, 0x8e, 0x0f, 0xb9, 0xc4, 0xb2, 0x97, 0x35, 0x27, 0xaf, 0x0f, 0x59,
+ 0x82, 0xd7, 0x87, 0x59, 0x91, 0x04, 0x52, 0x16, 0x49, 0x20, 0xcd, 0xaa, 0x12, 0x19, 0x79, 0x68,
+ 0xec, 0x22, 0x77, 0xb1, 0x1d, 0x1a, 0x20, 0xb2, 0x3f, 0x49, 0xcd, 0xa6, 0xce, 0x15, 0x5f, 0x04,
+ 0x6f, 0x88, 0x68, 0x4b, 0x8f, 0xa6, 0xa1, 0xe3, 0x13, 0x07, 0xb2, 0xaa, 0xb3, 0x48, 0xa5, 0x1b,
+ 0xc7, 0x57, 0x1f, 0x82, 0x77, 0x9e, 0x2d, 0x41, 0xd2, 0xba, 0x3e, 0x47, 0xde, 0x70, 0x44, 0x3b,
+ 0xe8, 0x97, 0x29, 0x22, 0xd4, 0x7c, 0x0f, 0x94, 0xfa, 0xe3, 0x00, 0x5e, 0xf5, 0x46, 0x1c, 0x3e,
+ 0xcc, 0x1f, 0x1b, 0x27, 0x1b, 0x9d, 0x22, 0xc7, 0xe2, 0xc8, 0xea, 0x73, 0x03, 0xbc, 0xbb, 0x9a,
+ 0x82, 0xe0, 0xc0, 0x27, 0xc8, 0x7c, 0x02, 0x4a, 0x8a, 0x2e, 0x39, 0x34, 0x8e, 0xef, 0x9c, 0x14,
+ 0xeb, 0x1f, 0x5a, 0xfa, 0xd9, 0x55, 0xa7, 0x16, 0xd9, 0x96, 0xc2, 0xd8, 0xd1, 0xd2, 0xd7, 0x99,
+ 0xd2, 0x7c, 0x0b, 0xec, 0x34, 0x31, 0x6e, 0x3b, 0xa1, 0x33, 0x41, 0x14, 0x85, 0xc4, 0x7c, 0x1b,
+ 0x6c, 0xc3, 0x91, 0xe3, 0xf9, 0x3d, 0xcf, 0x3d, 0x34, 0x8e, 0x8d, 0x93, 0x42, 0x67, 0x8b, 0xf7,
+ 0x1f, 0xbb, 0xe6, 0xf7, 0x00, 0x10, 0x48, 0x7b, 0x98, 0x05, 0x13, 0xce, 0x56, 0xac, 0x7f, 0x9a,
+ 0x98, 0xdc, 0xa2, 0xe8, 0x16, 0xdb, 0xd5, 0xc8, 0xb6, 0x2e, 0x20, 0x5d, 0xb2, 0x77, 0x0a, 0x44,
+ 0x74, 0x89, 0x19, 0x81, 0x03, 0xfd, 0x4e, 0x49, 0xe2, 0x3b, 0x9c, 0xb8, 0x95, 0x4a, 0x9c, 0xb8,
+ 0x89, 0x91, 0x6d, 0x9d, 0x4a, 0xa4, 0x1d, 0x04, 0x63, 0x45, 0x6d, 0x1f, 0xde, 0x1a, 0x20, 0xe6,
+ 0x08, 0xdc, 0x5d, 0x9e, 0x65, 0xa9, 0xb9, 0xc1, 0x35, 0x1f, 0xa4, 0x6a, 0x2a, 0xa7, 0x3f, 0xb2,
+ 0xad, 0xb3, 0x45, 0x4f, 0x11, 0x7b, 0x73, 0xa8, 0xa3, 0x84, 0xd5, 0xcb, 0xeb, 0x43, 0x29, 0xf1,
+ 0x46, 0x46, 0xbd, 0xd8, 0x7d, 0x89, 0x6c, 0xeb, 0x71, 0x1f, 0xaa, 0xf5, 0xf2, 0x44, 0x97, 0x98,
+ 0xcf, 0x40, 0x89, 0x1f, 0x5f, 0xc9, 0xb7, 0xc9, 0xf9, 0xec, 0xf4, 0xfa, 0xf3, 0xb3, 0xce, 0x76,
+ 0x80, 0x35, 0x14, 0xce, 0x22, 0x59, 0x00, 0x7c, 0x8e, 0x03, 0xb4, 0xe0, 0xdc, 0xca, 0x98, 0x23,
+ 0xf3, 0x99, 0xc8, 0xb6, 0x1e, 0x21, 0x95, 0xaf, 0x30, 0x40, 0x92, 0x8d, 0x82, 0xb2, 0x66, 0x5f,
+ 0x92, 0x77, 0x9b, 0xf3, 0x36, 0x53, 0x79, 0x75, 0xcf, 0x8b, 0x6c, 0xeb, 0x5b, 0x15, 0x50, 0x77,
+ 0xd4, 0xbd, 0x35, 0x40, 0xcc, 0x2e, 0xd8, 0x15, 0x96, 0x26, 0xf5, 0x0a, 0x5c, 0xef, 0xf3, 0xf4,
+ 0x75, 0x08, 0x07, 0x64, 0x6b, 0x89, 0x9b, 0x8a, 0xc6, 0xce, 0x40, 0x81, 0x88, 0x19, 0x82, 0xb2,
+ 0x66, 0x36, 0x52, 0x03, 0x70, 0x8d, 0x87, 0xe9, 0xf5, 0xd7, 0x1c, 0x8a, 0xed, 0x83, 0x00, 0x12,
+ 0x87, 0xd4, 0x24, 0x49, 0x9c, 0xef, 0x8a, 0x8b, 0x66, 0x52, 0xa9, 0x98, 0xb1, 0x2b, 0xec, 0x95,
+ 0x61, 0x35, 0x43, 0x33, 0x75, 0x57, 0x5c, 0xd1, 0x25, 0xd5, 0x7b, 0xa0, 0xac, 0xdd, 0x71, 0x61,
+ 0x59, 0x55, 0x08, 0x0e, 0x12, 0xb8, 0xf0, 0xa1, 0xef, 0xc0, 0xae, 0x83, 0x71, 0x2c, 0xcf, 0x47,
+ 0xb8, 0x13, 0x14, 0xeb, 0xef, 0x5b, 0xab, 0x5e, 0x51, 0x4b, 0x27, 0xd9, 0x71, 0xd4, 0x6e, 0xf5,
+ 0x77, 0x03, 0xec, 0x9d, 0x21, 0x1f, 0x11, 0x8f, 0x34, 0x31, 0xbe, 0xa0, 0x0e, 0x45, 0xe6, 0x53,
+ 0xb0, 0x37, 0x8c, 0xa1, 0x1e, 0x0c, 0x7c, 0x8a, 0x7c, 0x2a, 0x04, 0x3e, 0x58, 0x2d, 0x20, 0xf2,
+ 0x4f, 0xe3, 0xd8, 0xf3, 0x5c, 0x67, 0x77, 0xa8, 0x21, 0x66, 0x0d, 0x98, 0x0b, 0xc2, 0x11, 0x82,
+ 0x57, 0x38, 0xf0, 0xfc, 0xd8, 0xef, 0x4a, 0xe7, 0xb9, 0xce, 0x5d, 0x19, 0xbd, 0x18, 0x6a, 0xed,
+ 0x03, 0x09, 0xf6, 0xd8, 0x4a, 0x09, 0x9b, 0x56, 0xf5, 0xef, 0x2d, 0xb0, 0xab, 0x4b, 0xbd, 0xca,
+ 0x0d, 0x7f, 0x04, 0x3b, 0xf1, 0x7d, 0x94, 0x4b, 0x88, 0x0d, 0xf1, 0x7e, 0xf6, 0x85, 0xd4, 0x35,
+ 0x3a, 0xf1, 0xb5, 0x96, 0x8a, 0x63, 0x70, 0xa0, 0x1f, 0x37, 0x49, 0x1f, 0xdb, 0xe2, 0x97, 0xeb,
+ 0x9f, 0xb7, 0x84, 0xcc, 0xbe, 0x7a, 0xce, 0xa4, 0x9a, 0x0b, 0x4c, 0xc5, 0x0c, 0xa5, 0xd4, 0x46,
+ 0xc6, 0xf5, 0x49, 0xb8, 0xa1, 0xae, 0xa3, 0xb8, 0xab, 0x54, 0x79, 0x0a, 0x8a, 0xcc, 0x08, 0x25,
+ 0x7d, 0xec, 0x84, 0x56, 0x96, 0x13, 0x26, 0x78, 0x99, 0x97, 0x2a, 0x84, 0xec, 0x25, 0x92, 0x84,
+ 0x9b, 0x19, 0x84, 0xe2, 0x29, 0x4a, 0x12, 0x12, 0x48, 0x25, 0x61, 0x00, 0xee, 0x25, 0x1e, 0x23,
+ 0xc9, 0x1d, 0x5b, 0xe2, 0x57, 0xaf, 0xf1, 0x1a, 0x25, 0x64, 0xca, 0xda, 0x23, 0xa4, 0xac, 0x80,
+ 0xf9, 0xae, 0x54, 0xd9, 0xce, 0x58, 0x81, 0x30, 0xde, 0xe4, 0x0a, 0x06, 0x68, 0x51, 0xe3, 0x09,
+ 0x38, 0xd0, 0xad, 0x57, 0x52, 0x17, 0x32, 0xce, 0xcd, 0x2d, 0xef, 0x4d, 0xce, 0x5f, 0x0b, 0x90,
+ 0x72, 0x3f, 0x83, 0x3d, 0xe9, 0xb9, 0x52, 0x28, 0x36, 0xc4, 0xfa, 0x3a, 0xa6, 0x9b, 0x90, 0x90,
+ 0xf6, 0xad, 0x14, 0x87, 0xd9, 0x9f, 0x24, 0x2e, 0x66, 0x14, 0x47, 0xf8, 0x5f, 0xb2, 0x38, 0x2e,
+ 0x9a, 0x89, 0x76, 0xfd, 0xa5, 0x01, 0x4a, 0x3f, 0x4c, 0x51, 0x78, 0x7d, 0x81, 0xc2, 0xc8, 0x83,
+ 0xc8, 0x1c, 0x25, 0x3f, 0x7b, 0x3e, 0x5a, 0xc7, 0xda, 0x62, 0xdf, 0x3c, 0xfa, 0x78, 0xad, 0x58,
+ 0xe1, 0xa5, 0xbf, 0x82, 0xf2, 0xaa, 0x6f, 0x3e, 0xd3, 0x5e, 0x4d, 0xf2, 0x8a, 0x4f, 0xcc, 0xa3,
+ 0xfa, 0xeb, 0xa4, 0xc4, 0xf2, 0xad, 0x97, 0xc6, 0x9f, 0xf3, 0x8a, 0xf1, 0x62, 0x5e, 0x31, 0xfe,
+ 0x9d, 0x57, 0x8c, 0xe7, 0x37, 0x95, 0xdc, 0x8b, 0x9b, 0x4a, 0xee, 0x9f, 0x9b, 0x4a, 0x0e, 0x1c,
+ 0xc2, 0x60, 0xb2, 0x92, 0xb1, 0xb5, 0xcd, 0x96, 0xc2, 0x3e, 0x7a, 0xdb, 0xc6, 0x4f, 0x8f, 0x86,
+ 0x1e, 0x1d, 0x4d, 0xfb, 0xac, 0xdc, 0x35, 0x18, 0x90, 0x49, 0x40, 0x6a, 0x21, 0x1a, 0x3b, 0xd7,
+ 0x28, 0xac, 0x45, 0xf5, 0x45, 0x93, 0x9b, 0x22, 0xa9, 0xad, 0xfa, 0x13, 0xf6, 0xc0, 0xc1, 0x38,
+ 0xb2, 0x7f, 0xcb, 0xdf, 0x69, 0x9f, 0x36, 0xff, 0xc8, 0x97, 0xdb, 0x52, 0xf0, 0x94, 0x09, 0x36,
+ 0x31, 0xb6, 0x2e, 0xed, 0xbf, 0x96, 0x70, 0x97, 0xc1, 0xdd, 0x26, 0xc6, 0xdd, 0x4b, 0x7b, 0x9e,
+ 0x3f, 0x5e, 0x05, 0x77, 0xcf, 0xda, 0xad, 0x27, 0x88, 0x3a, 0xae, 0x43, 0x9d, 0xff, 0xf2, 0x6f,
+ 0xc9, 0x90, 0x46, 0x83, 0xc5, 0x34, 0x1a, 0x4d, 0x8c, 0x1b, 0x8d, 0x4b, 0xbb, 0xbf, 0xc9, 0x3f,
+ 0xdb, 0x3f, 0xfb, 0x3f, 0x00, 0x00, 0xff, 0xff, 0xf0, 0x81, 0x4b, 0xf1, 0x1a, 0x0e, 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.v1.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.v1.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.v1.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.v1.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.v1.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/v1/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
+ }
+ 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.DexParams != nil {
+ {
+ size, err := m.DexParams.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintApp(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x5a
+ }
+ if m.ShieldedPoolParams != nil {
+ {
+ size, err := m.ShieldedPoolParams.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintApp(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x52
+ }
+ if m.FundingParams != nil {
+ {
+ size, err := m.FundingParams.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintApp(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x4a
+ }
+ 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] = 0x42
+ }
+ 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] = 0x3a
+ }
+ 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] = 0x32
+ }
+ 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] = 0x2a
+ }
+ 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] = 0x22
+ }
+ 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] = 0x1a
+ }
+ if m.SctParams != nil {
+ {
+ size, err := m.SctParams.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintApp(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x12
+ }
+ 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 *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
+ 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.DexContent != nil {
+ {
+ size, err := m.DexContent.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintApp(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x5a
+ }
+ if m.FundingContent != nil {
+ {
+ size, err := m.FundingContent.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintApp(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x52
+ }
+ 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] = 0x4a
+ }
+ 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] = 0x42
+ }
+ 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] = 0x3a
+ }
+ if m.SctContent != nil {
+ {
+ size, err := m.SctContent.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintApp(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x32
+ }
+ 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] = 0x2a
+ }
+ 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] = 0x22
+ }
+ 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] = 0x1a
+ }
+ 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] = 0x12
+ }
+ 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 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
+ 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
+ l = len(m.ChainId)
+ if l > 0 {
+ n += 1 + l + sovApp(uint64(l))
+ }
+ if m.SctParams != nil {
+ l = m.SctParams.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))
+ }
+ if m.FundingParams != nil {
+ l = m.FundingParams.Size()
+ n += 1 + l + sovApp(uint64(l))
+ }
+ if m.ShieldedPoolParams != nil {
+ l = m.ShieldedPoolParams.Size()
+ n += 1 + l + sovApp(uint64(l))
+ }
+ if m.DexParams != nil {
+ l = m.DexParams.Size()
+ n += 1 + l + sovApp(uint64(l))
+ }
+ return n
+}
+
+func (m *AppParametersRequest) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = 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
+ l = len(m.ChainId)
+ if l > 0 {
+ n += 1 + l + sovApp(uint64(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.SctContent != nil {
+ l = m.SctContent.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))
+ }
+ if m.FundingContent != nil {
+ l = m.FundingContent.Size()
+ n += 1 + l + sovApp(uint64(l))
+ }
+ if m.DexContent != nil {
+ l = m.DexContent.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 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, &v1.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 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 != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SctParams", 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.SctParams == nil {
+ m.SctParams = &v11.SctParameters{}
+ }
+ if err := m.SctParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ 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 = &v12.CommunityPoolParameters{}
+ }
+ if err := m.CommunityPoolParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ 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 = &v13.GovernanceParameters{}
+ }
+ if err := m.GovernanceParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 5:
+ 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 = &v14.IbcParameters{}
+ }
+ if err := m.IbcParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 6:
+ 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 = &v15.StakeParameters{}
+ }
+ if err := m.StakeParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 7:
+ 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 = &v16.FeeParameters{}
+ }
+ if err := m.FeeParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 8:
+ 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 = &v17.DistributionsParameters{}
+ }
+ if err := m.DistributionsParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 9:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FundingParams", 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.FundingParams == nil {
+ m.FundingParams = &v18.FundingParameters{}
+ }
+ if err := m.FundingParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 10:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ShieldedPoolParams", 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.ShieldedPoolParams == nil {
+ m.ShieldedPoolParams = &v19.ShieldedPoolParameters{}
+ }
+ if err := m.ShieldedPoolParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 11:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DexParams", 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.DexParams == nil {
+ m.DexParams = &v110.DexParameters{}
+ }
+ if err := m.DexParams.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 {
+ 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 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 != 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 = &v15.GenesisContent{}
+ }
+ if err := m.StakeContent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ 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 = &v19.GenesisContent{}
+ }
+ if err := m.ShieldedPoolContent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ 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 = &v13.GenesisContent{}
+ }
+ if err := m.GovernanceContent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 5:
+ 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 = &v14.GenesisContent{}
+ }
+ if err := m.IbcContent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SctContent", 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.SctContent == nil {
+ m.SctContent = &v11.GenesisContent{}
+ }
+ if err := m.SctContent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 7:
+ 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 = &v12.GenesisContent{}
+ }
+ if err := m.CommunityPoolContent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 8:
+ 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 = &v16.GenesisContent{}
+ }
+ if err := m.FeeContent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 9:
+ 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 = &v17.GenesisContent{}
+ }
+ if err := m.DistributionsContent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 10:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FundingContent", 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.FundingContent == nil {
+ m.FundingContent = &v18.GenesisContent{}
+ }
+ if err := m.FundingContent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 11:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DexContent", 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.DexContent == nil {
+ m.DexContent = &v110.GenesisContent{}
+ }
+ if err := m.DexContent.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/v1/asset.pb.go b/relayer/chains/penumbra/core/asset/v1/asset.pb.go
new file mode 100644
index 000000000..9e13be113
--- /dev/null
+++ b/relayer/chains/penumbra/core/asset/v1/asset.pb.go
@@ -0,0 +1,3975 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: penumbra/core/asset/v1/asset.proto
+
+package assetv1
+
+import (
+ encoding_binary "encoding/binary"
+ fmt "fmt"
+ types "github.com/cosmos/cosmos-sdk/codec/types"
+ proto "github.com/cosmos/gogoproto/proto"
+ v1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/num/v1"
+ 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_c2e6e948c9ed8f1e, []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_c2e6e948c9ed8f1e, []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_c2e6e948c9ed8f1e, []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 ""
+}
+
+// Describes metadata about a given asset.
+type Metadata 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"`
+ // 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"`
+ Images []*AssetImage `protobuf:"bytes,1985,rep,name=images,proto3" json:"images,omitempty"`
+}
+
+func (m *Metadata) Reset() { *m = Metadata{} }
+func (m *Metadata) String() string { return proto.CompactTextString(m) }
+func (*Metadata) ProtoMessage() {}
+func (*Metadata) Descriptor() ([]byte, []int) {
+ return fileDescriptor_c2e6e948c9ed8f1e, []int{3}
+}
+func (m *Metadata) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *Metadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_Metadata.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *Metadata) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Metadata.Merge(m, src)
+}
+func (m *Metadata) XXX_Size() int {
+ return m.Size()
+}
+func (m *Metadata) XXX_DiscardUnknown() {
+ xxx_messageInfo_Metadata.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Metadata proto.InternalMessageInfo
+
+func (m *Metadata) GetDescription() string {
+ if m != nil {
+ return m.Description
+ }
+ return ""
+}
+
+func (m *Metadata) GetDenomUnits() []*DenomUnit {
+ if m != nil {
+ return m.DenomUnits
+ }
+ return nil
+}
+
+func (m *Metadata) GetBase() string {
+ if m != nil {
+ return m.Base
+ }
+ return ""
+}
+
+func (m *Metadata) GetDisplay() string {
+ if m != nil {
+ return m.Display
+ }
+ return ""
+}
+
+func (m *Metadata) GetName() string {
+ if m != nil {
+ return m.Name
+ }
+ return ""
+}
+
+func (m *Metadata) GetSymbol() string {
+ if m != nil {
+ return m.Symbol
+ }
+ return ""
+}
+
+func (m *Metadata) GetPenumbraAssetId() *AssetId {
+ if m != nil {
+ return m.PenumbraAssetId
+ }
+ return nil
+}
+
+func (m *Metadata) GetImages() []*AssetImage {
+ if m != nil {
+ return m.Images
+ }
+ 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_c2e6e948c9ed8f1e, []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 *v1.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_c2e6e948c9ed8f1e, []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() *v1.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.
+type ValueView struct {
+ // Types that are valid to be assigned to ValueView:
+ //
+ // *ValueView_KnownAssetId_
+ // *ValueView_UnknownAssetId_
+ 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_c2e6e948c9ed8f1e, []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_KnownAssetId_ struct {
+ KnownAssetId *ValueView_KnownAssetId `protobuf:"bytes,1,opt,name=known_asset_id,json=knownAssetId,proto3,oneof" json:"known_asset_id,omitempty"`
+}
+type ValueView_UnknownAssetId_ struct {
+ UnknownAssetId *ValueView_UnknownAssetId `protobuf:"bytes,2,opt,name=unknown_asset_id,json=unknownAssetId,proto3,oneof" json:"unknown_asset_id,omitempty"`
+}
+
+func (*ValueView_KnownAssetId_) isValueView_ValueView() {}
+func (*ValueView_UnknownAssetId_) isValueView_ValueView() {}
+
+func (m *ValueView) GetValueView() isValueView_ValueView {
+ if m != nil {
+ return m.ValueView
+ }
+ return nil
+}
+
+func (m *ValueView) GetKnownAssetId() *ValueView_KnownAssetId {
+ if x, ok := m.GetValueView().(*ValueView_KnownAssetId_); ok {
+ return x.KnownAssetId
+ }
+ return nil
+}
+
+func (m *ValueView) GetUnknownAssetId() *ValueView_UnknownAssetId {
+ if x, ok := m.GetValueView().(*ValueView_UnknownAssetId_); ok {
+ return x.UnknownAssetId
+ }
+ return nil
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*ValueView) XXX_OneofWrappers() []interface{} {
+ return []interface{}{
+ (*ValueView_KnownAssetId_)(nil),
+ (*ValueView_UnknownAssetId_)(nil),
+ }
+}
+
+// A value whose asset ID is known and has metadata.
+type ValueView_KnownAssetId struct {
+ // The amount of the value.
+ Amount *v1.Amount `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount,omitempty"`
+ // The asset metadata describing the asset of the value.
+ Metadata *Metadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"`
+ // Optionally, a list of equivalent values in other numeraires.
+ EquivalentValues []*EquivalentValue `protobuf:"bytes,3,rep,name=equivalent_values,json=equivalentValues,proto3" json:"equivalent_values,omitempty"`
+ // Optionally, extended, dynamically-typed metadata about the object this
+ // token represents.
+ //
+ // This is left flexible to allow future extensions. For instance, a view
+ // server could augment an LPNFT with a message describing the current state
+ // of the position and its reserves, allowing a frontend to render LPNFTs
+ // with their position information (trading pair, etc). However, because
+ // this is in an extension, a frontend that does not have special handling
+ // logic would fall back on the ordinary asset metadata.
+ ExtendedMetadata *types.Any `protobuf:"bytes,4,opt,name=extended_metadata,json=extendedMetadata,proto3" json:"extended_metadata,omitempty"`
+}
+
+func (m *ValueView_KnownAssetId) Reset() { *m = ValueView_KnownAssetId{} }
+func (m *ValueView_KnownAssetId) String() string { return proto.CompactTextString(m) }
+func (*ValueView_KnownAssetId) ProtoMessage() {}
+func (*ValueView_KnownAssetId) Descriptor() ([]byte, []int) {
+ return fileDescriptor_c2e6e948c9ed8f1e, []int{6, 0}
+}
+func (m *ValueView_KnownAssetId) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *ValueView_KnownAssetId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_ValueView_KnownAssetId.Marshal(b, 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_KnownAssetId) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ValueView_KnownAssetId.Merge(m, src)
+}
+func (m *ValueView_KnownAssetId) XXX_Size() int {
+ return m.Size()
+}
+func (m *ValueView_KnownAssetId) XXX_DiscardUnknown() {
+ xxx_messageInfo_ValueView_KnownAssetId.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ValueView_KnownAssetId proto.InternalMessageInfo
+
+func (m *ValueView_KnownAssetId) GetAmount() *v1.Amount {
+ if m != nil {
+ return m.Amount
+ }
+ return nil
+}
+
+func (m *ValueView_KnownAssetId) GetMetadata() *Metadata {
+ if m != nil {
+ return m.Metadata
+ }
+ return nil
+}
+
+func (m *ValueView_KnownAssetId) GetEquivalentValues() []*EquivalentValue {
+ if m != nil {
+ return m.EquivalentValues
+ }
+ return nil
+}
+
+func (m *ValueView_KnownAssetId) GetExtendedMetadata() *types.Any {
+ if m != nil {
+ return m.ExtendedMetadata
+ }
+ return nil
+}
+
+// A value whose asset ID is unknown, with no metadata.
+type ValueView_UnknownAssetId struct {
+ Amount *v1.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_UnknownAssetId) Reset() { *m = ValueView_UnknownAssetId{} }
+func (m *ValueView_UnknownAssetId) String() string { return proto.CompactTextString(m) }
+func (*ValueView_UnknownAssetId) ProtoMessage() {}
+func (*ValueView_UnknownAssetId) Descriptor() ([]byte, []int) {
+ return fileDescriptor_c2e6e948c9ed8f1e, []int{6, 1}
+}
+func (m *ValueView_UnknownAssetId) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *ValueView_UnknownAssetId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_ValueView_UnknownAssetId.Marshal(b, 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_UnknownAssetId) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ValueView_UnknownAssetId.Merge(m, src)
+}
+func (m *ValueView_UnknownAssetId) XXX_Size() int {
+ return m.Size()
+}
+func (m *ValueView_UnknownAssetId) XXX_DiscardUnknown() {
+ xxx_messageInfo_ValueView_UnknownAssetId.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ValueView_UnknownAssetId proto.InternalMessageInfo
+
+func (m *ValueView_UnknownAssetId) GetAmount() *v1.Amount {
+ if m != nil {
+ return m.Amount
+ }
+ return nil
+}
+
+func (m *ValueView_UnknownAssetId) GetAssetId() *AssetId {
+ if m != nil {
+ return m.AssetId
+ }
+ return nil
+}
+
+// An image related to an asset.
+type AssetImage struct {
+ // The URI of the image in PNG format.
+ Png string `protobuf:"bytes,1,opt,name=png,proto3" json:"png,omitempty"`
+ // The URI of the image in SVG format.
+ Svg string `protobuf:"bytes,2,opt,name=svg,proto3" json:"svg,omitempty"`
+ Theme *AssetImage_Theme `protobuf:"bytes,3,opt,name=theme,proto3" json:"theme,omitempty"`
+}
+
+func (m *AssetImage) Reset() { *m = AssetImage{} }
+func (m *AssetImage) String() string { return proto.CompactTextString(m) }
+func (*AssetImage) ProtoMessage() {}
+func (*AssetImage) Descriptor() ([]byte, []int) {
+ return fileDescriptor_c2e6e948c9ed8f1e, []int{7}
+}
+func (m *AssetImage) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *AssetImage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_AssetImage.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *AssetImage) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_AssetImage.Merge(m, src)
+}
+func (m *AssetImage) XXX_Size() int {
+ return m.Size()
+}
+func (m *AssetImage) XXX_DiscardUnknown() {
+ xxx_messageInfo_AssetImage.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AssetImage proto.InternalMessageInfo
+
+func (m *AssetImage) GetPng() string {
+ if m != nil {
+ return m.Png
+ }
+ return ""
+}
+
+func (m *AssetImage) GetSvg() string {
+ if m != nil {
+ return m.Svg
+ }
+ return ""
+}
+
+func (m *AssetImage) GetTheme() *AssetImage_Theme {
+ if m != nil {
+ return m.Theme
+ }
+ return nil
+}
+
+type AssetImage_Theme struct {
+ // Should be in hex format, `^#[0-9a-fA-F]{6}$`.
+ PrimaryColorHex string `protobuf:"bytes,1,opt,name=primary_color_hex,json=primaryColorHex,proto3" json:"primary_color_hex,omitempty"`
+ Circle bool `protobuf:"varint,2,opt,name=circle,proto3" json:"circle,omitempty"`
+ DarkMode bool `protobuf:"varint,3,opt,name=dark_mode,json=darkMode,proto3" json:"dark_mode,omitempty"`
+}
+
+func (m *AssetImage_Theme) Reset() { *m = AssetImage_Theme{} }
+func (m *AssetImage_Theme) String() string { return proto.CompactTextString(m) }
+func (*AssetImage_Theme) ProtoMessage() {}
+func (*AssetImage_Theme) Descriptor() ([]byte, []int) {
+ return fileDescriptor_c2e6e948c9ed8f1e, []int{7, 0}
+}
+func (m *AssetImage_Theme) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *AssetImage_Theme) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_AssetImage_Theme.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *AssetImage_Theme) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_AssetImage_Theme.Merge(m, src)
+}
+func (m *AssetImage_Theme) XXX_Size() int {
+ return m.Size()
+}
+func (m *AssetImage_Theme) XXX_DiscardUnknown() {
+ xxx_messageInfo_AssetImage_Theme.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AssetImage_Theme proto.InternalMessageInfo
+
+func (m *AssetImage_Theme) GetPrimaryColorHex() string {
+ if m != nil {
+ return m.PrimaryColorHex
+ }
+ return ""
+}
+
+func (m *AssetImage_Theme) GetCircle() bool {
+ if m != nil {
+ return m.Circle
+ }
+ return false
+}
+
+func (m *AssetImage_Theme) GetDarkMode() bool {
+ if m != nil {
+ return m.DarkMode
+ }
+ return false
+}
+
+// The estimated price of one asset in terms of a numeraire.
+//
+// This is used for generating "equivalent values" in ValueViews.
+type EstimatedPrice struct {
+ PricedAsset *AssetId `protobuf:"bytes,1,opt,name=priced_asset,json=pricedAsset,proto3" json:"priced_asset,omitempty"`
+ Numeraire *AssetId `protobuf:"bytes,2,opt,name=numeraire,proto3" json:"numeraire,omitempty"`
+ // Multiply units of the priced asset by this value to get the value in the numeraire.
+ //
+ // This is a floating-point number since the price is approximate.
+ NumerairePerUnit float64 `protobuf:"fixed64,3,opt,name=numeraire_per_unit,json=numerairePerUnit,proto3" json:"numeraire_per_unit,omitempty"`
+ // If set, gives some idea of when the price was estimated.
+ AsOfHeight uint64 `protobuf:"varint,4,opt,name=as_of_height,json=asOfHeight,proto3" json:"as_of_height,omitempty"`
+}
+
+func (m *EstimatedPrice) Reset() { *m = EstimatedPrice{} }
+func (m *EstimatedPrice) String() string { return proto.CompactTextString(m) }
+func (*EstimatedPrice) ProtoMessage() {}
+func (*EstimatedPrice) Descriptor() ([]byte, []int) {
+ return fileDescriptor_c2e6e948c9ed8f1e, []int{8}
+}
+func (m *EstimatedPrice) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *EstimatedPrice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_EstimatedPrice.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *EstimatedPrice) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EstimatedPrice.Merge(m, src)
+}
+func (m *EstimatedPrice) XXX_Size() int {
+ return m.Size()
+}
+func (m *EstimatedPrice) XXX_DiscardUnknown() {
+ xxx_messageInfo_EstimatedPrice.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EstimatedPrice proto.InternalMessageInfo
+
+func (m *EstimatedPrice) GetPricedAsset() *AssetId {
+ if m != nil {
+ return m.PricedAsset
+ }
+ return nil
+}
+
+func (m *EstimatedPrice) GetNumeraire() *AssetId {
+ if m != nil {
+ return m.Numeraire
+ }
+ return nil
+}
+
+func (m *EstimatedPrice) GetNumerairePerUnit() float64 {
+ if m != nil {
+ return m.NumerairePerUnit
+ }
+ return 0
+}
+
+func (m *EstimatedPrice) GetAsOfHeight() uint64 {
+ if m != nil {
+ return m.AsOfHeight
+ }
+ return 0
+}
+
+// An "equivalent" value to a given value, in terms of a numeraire.
+//
+// For instance, this can provide a USD-equivalent value relative to a
+// stablecoin, or an amount of the staking token, etc. A view server can
+// optionally include this information to assist a frontend in displaying
+// information about the value in a user-friendly way.
+type EquivalentValue struct {
+ // The equivalent amount of the parent Value in terms of the numeraire.
+ EquivalentAmount *v1.Amount `protobuf:"bytes,1,opt,name=equivalent_amount,json=equivalentAmount,proto3" json:"equivalent_amount,omitempty"`
+ // Metadata describing the numeraire.
+ Numeraire *Metadata `protobuf:"bytes,2,opt,name=numeraire,proto3" json:"numeraire,omitempty"`
+ // If set, gives some idea of when the price/equivalence was estimated.
+ AsOfHeight uint64 `protobuf:"varint,3,opt,name=as_of_height,json=asOfHeight,proto3" json:"as_of_height,omitempty"`
+}
+
+func (m *EquivalentValue) Reset() { *m = EquivalentValue{} }
+func (m *EquivalentValue) String() string { return proto.CompactTextString(m) }
+func (*EquivalentValue) ProtoMessage() {}
+func (*EquivalentValue) Descriptor() ([]byte, []int) {
+ return fileDescriptor_c2e6e948c9ed8f1e, []int{9}
+}
+func (m *EquivalentValue) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *EquivalentValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_EquivalentValue.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *EquivalentValue) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EquivalentValue.Merge(m, src)
+}
+func (m *EquivalentValue) XXX_Size() int {
+ return m.Size()
+}
+func (m *EquivalentValue) XXX_DiscardUnknown() {
+ xxx_messageInfo_EquivalentValue.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EquivalentValue proto.InternalMessageInfo
+
+func (m *EquivalentValue) GetEquivalentAmount() *v1.Amount {
+ if m != nil {
+ return m.EquivalentAmount
+ }
+ return nil
+}
+
+func (m *EquivalentValue) GetNumeraire() *Metadata {
+ if m != nil {
+ return m.Numeraire
+ }
+ return nil
+}
+
+func (m *EquivalentValue) GetAsOfHeight() uint64 {
+ if m != nil {
+ return m.AsOfHeight
+ }
+ return 0
+}
+
+func init() {
+ proto.RegisterType((*BalanceCommitment)(nil), "penumbra.core.asset.v1.BalanceCommitment")
+ proto.RegisterType((*AssetId)(nil), "penumbra.core.asset.v1.AssetId")
+ proto.RegisterType((*Denom)(nil), "penumbra.core.asset.v1.Denom")
+ proto.RegisterType((*Metadata)(nil), "penumbra.core.asset.v1.Metadata")
+ proto.RegisterType((*DenomUnit)(nil), "penumbra.core.asset.v1.DenomUnit")
+ proto.RegisterType((*Value)(nil), "penumbra.core.asset.v1.Value")
+ proto.RegisterType((*ValueView)(nil), "penumbra.core.asset.v1.ValueView")
+ proto.RegisterType((*ValueView_KnownAssetId)(nil), "penumbra.core.asset.v1.ValueView.KnownAssetId")
+ proto.RegisterType((*ValueView_UnknownAssetId)(nil), "penumbra.core.asset.v1.ValueView.UnknownAssetId")
+ proto.RegisterType((*AssetImage)(nil), "penumbra.core.asset.v1.AssetImage")
+ proto.RegisterType((*AssetImage_Theme)(nil), "penumbra.core.asset.v1.AssetImage.Theme")
+ proto.RegisterType((*EstimatedPrice)(nil), "penumbra.core.asset.v1.EstimatedPrice")
+ proto.RegisterType((*EquivalentValue)(nil), "penumbra.core.asset.v1.EquivalentValue")
+}
+
+func init() {
+ proto.RegisterFile("penumbra/core/asset/v1/asset.proto", fileDescriptor_c2e6e948c9ed8f1e)
+}
+
+var fileDescriptor_c2e6e948c9ed8f1e = []byte{
+ // 1048 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0x4f, 0x6f, 0xe3, 0x44,
+ 0x14, 0xaf, 0xf3, 0xa7, 0x75, 0x5e, 0x42, 0x9b, 0x8e, 0x56, 0x55, 0x36, 0x40, 0x36, 0x58, 0x48,
+ 0x14, 0x84, 0x1c, 0x92, 0xe5, 0x94, 0x85, 0x95, 0x9a, 0xb2, 0xa2, 0x2d, 0xac, 0x88, 0xac, 0x6d,
+ 0x90, 0x50, 0x25, 0x6b, 0x62, 0x4f, 0xe3, 0x51, 0x3d, 0x33, 0xc1, 0x63, 0xa7, 0xcd, 0x95, 0x0b,
+ 0x57, 0xee, 0xdc, 0x38, 0xf2, 0x21, 0x10, 0xdc, 0x10, 0xa7, 0x3d, 0x22, 0x4e, 0xa8, 0xbd, 0x71,
+ 0xe4, 0x03, 0x20, 0x34, 0x63, 0x3b, 0x6d, 0x4a, 0x4b, 0x17, 0x0e, 0x7b, 0x7b, 0x7f, 0x7e, 0xef,
+ 0xbd, 0xdf, 0x7b, 0x7e, 0x6f, 0x12, 0xb0, 0xa6, 0x84, 0x27, 0x6c, 0x1c, 0xe1, 0x8e, 0x27, 0x22,
+ 0xd2, 0xc1, 0x52, 0x92, 0xb8, 0x33, 0xeb, 0xa6, 0x82, 0x3d, 0x8d, 0x44, 0x2c, 0xd0, 0x56, 0x8e,
+ 0xb1, 0x15, 0xc6, 0x4e, 0x5d, 0xb3, 0x6e, 0xf3, 0xfe, 0x44, 0x88, 0x49, 0x48, 0x3a, 0x1a, 0x35,
+ 0x4e, 0x8e, 0x3b, 0x98, 0xcf, 0xd3, 0x90, 0x66, 0x6b, 0x39, 0x2d, 0x4f, 0x98, 0x4a, 0xca, 0x13,
+ 0x96, 0xfa, 0xad, 0xb7, 0x61, 0x73, 0x80, 0x43, 0xcc, 0x3d, 0xb2, 0x2b, 0x18, 0xa3, 0x31, 0x23,
+ 0x3c, 0x46, 0xf7, 0xa0, 0x4c, 0x39, 0x27, 0x51, 0xc3, 0x68, 0x1b, 0xdb, 0x35, 0x27, 0x55, 0xac,
+ 0x63, 0x58, 0xdb, 0x51, 0x15, 0xf7, 0xfd, 0x9b, 0x01, 0xe8, 0x01, 0x54, 0x71, 0x18, 0xbb, 0x63,
+ 0xe2, 0x05, 0x0f, 0x7b, 0xac, 0x51, 0x68, 0x1b, 0xdb, 0x15, 0x07, 0x70, 0x18, 0x0f, 0x52, 0x0b,
+ 0x7a, 0x13, 0xd6, 0x35, 0x00, 0x4b, 0xe2, 0xfa, 0x84, 0x0b, 0xd6, 0x28, 0x6a, 0x4c, 0x4d, 0x61,
+ 0xb0, 0x24, 0x1f, 0x29, 0x9b, 0xf5, 0x3a, 0x94, 0xb5, 0xa0, 0xaa, 0xa4, 0x28, 0x43, 0xa3, 0x52,
+ 0xc5, 0xfa, 0xab, 0x00, 0xe6, 0x53, 0x12, 0x63, 0x1f, 0xc7, 0x18, 0xb5, 0xa1, 0xea, 0x13, 0xe9,
+ 0x45, 0x74, 0x1a, 0x53, 0xc1, 0x33, 0xe0, 0x55, 0x13, 0x1a, 0x28, 0x04, 0x17, 0xcc, 0x4d, 0x38,
+ 0x8d, 0x65, 0xa3, 0xd0, 0x2e, 0x6e, 0x57, 0x7b, 0x6f, 0xd8, 0x37, 0x4f, 0xd2, 0xd6, 0x85, 0x0f,
+ 0x39, 0x8d, 0x1d, 0xf0, 0x73, 0x51, 0x22, 0x04, 0x25, 0xc5, 0x39, 0x63, 0xab, 0x65, 0xd4, 0x80,
+ 0x35, 0x9f, 0xca, 0x69, 0x88, 0xe7, 0x8d, 0x92, 0x36, 0xe7, 0xaa, 0x42, 0x73, 0xcc, 0x48, 0xa3,
+ 0x9c, 0xa2, 0x95, 0x8c, 0xb6, 0x60, 0x55, 0xce, 0xd9, 0x58, 0x84, 0x8d, 0x55, 0x6d, 0xcd, 0x34,
+ 0xf4, 0x29, 0x6c, 0xe6, 0x4c, 0x5c, 0x4d, 0xc2, 0xa5, 0x7e, 0xe3, 0xc7, 0x8d, 0xb6, 0xb1, 0x5d,
+ 0xed, 0x3d, 0xb8, 0x8d, 0x64, 0xf6, 0x15, 0x9c, 0x8d, 0xdc, 0x9f, 0x7f, 0x96, 0x47, 0xb0, 0x4a,
+ 0x19, 0x9e, 0x10, 0xd9, 0xf8, 0x69, 0x43, 0xf7, 0x69, 0xfd, 0x7b, 0x0a, 0x85, 0x75, 0xb2, 0x90,
+ 0x83, 0x92, 0xb9, 0x56, 0x37, 0x0f, 0x4a, 0xa6, 0x59, 0xaf, 0x38, 0xc5, 0x24, 0xa2, 0x4e, 0xf1,
+ 0xd0, 0xd9, 0x77, 0xcc, 0x24, 0xa2, 0x6e, 0x80, 0x65, 0xe0, 0xac, 0x1d, 0x3a, 0xfb, 0x7b, 0x58,
+ 0x06, 0xd6, 0xe7, 0x50, 0x59, 0x8c, 0xe9, 0xe6, 0x6f, 0x84, 0x9a, 0x60, 0x92, 0xb3, 0xa9, 0xe0,
+ 0x84, 0xc7, 0x7a, 0x0d, 0x5e, 0x71, 0x16, 0xba, 0x1a, 0x1c, 0x0e, 0x29, 0x96, 0x44, 0x36, 0x8a,
+ 0xed, 0xa2, 0x1a, 0x5c, 0xa6, 0x5a, 0x73, 0x28, 0x8f, 0x70, 0x98, 0x10, 0xf4, 0x3e, 0xac, 0x62,
+ 0x26, 0x12, 0x1e, 0xeb, 0xac, 0xd5, 0xde, 0x6b, 0xd7, 0xda, 0x50, 0xeb, 0xab, 0x9a, 0xd0, 0x18,
+ 0x27, 0xc3, 0xa2, 0x3e, 0x98, 0x8b, 0x11, 0x16, 0x5e, 0x6c, 0x82, 0x6b, 0x38, 0x15, 0xac, 0x3f,
+ 0x4b, 0x50, 0xd1, 0xb5, 0x47, 0x94, 0x9c, 0xa2, 0x11, 0xac, 0x9f, 0x70, 0x71, 0xca, 0x2f, 0x3f,
+ 0x49, 0xca, 0xc3, 0xbe, 0x2d, 0xdf, 0x22, 0xd4, 0xfe, 0x44, 0xc5, 0x65, 0xe9, 0xf7, 0x56, 0x9c,
+ 0xda, 0xc9, 0x15, 0x1d, 0x1d, 0x41, 0x3d, 0xe1, 0xd7, 0x32, 0xa7, 0x4c, 0xdf, 0xbb, 0x3b, 0xf3,
+ 0x21, 0x3f, 0x59, 0xce, 0xbd, 0x9e, 0x2c, 0x59, 0x9a, 0xdf, 0x16, 0xa0, 0x76, 0xb5, 0xfc, 0xff,
+ 0x1c, 0xe3, 0x07, 0x60, 0xb2, 0xec, 0xbc, 0x32, 0x72, 0xed, 0xdb, 0xc8, 0xe5, 0x67, 0xe8, 0x2c,
+ 0x22, 0xd0, 0x33, 0xd8, 0x24, 0x5f, 0x26, 0x74, 0x86, 0x43, 0xc2, 0x63, 0x77, 0xa6, 0xd8, 0xa7,
+ 0xdf, 0xb9, 0xda, 0x7b, 0xeb, 0xb6, 0x34, 0x4f, 0x16, 0x01, 0xba, 0x5b, 0xa7, 0x4e, 0x96, 0x0d,
+ 0x12, 0xed, 0xc0, 0x26, 0x39, 0x8b, 0x09, 0xf7, 0x89, 0xef, 0x2e, 0xc8, 0x95, 0x34, 0xb9, 0x7b,
+ 0x76, 0xfa, 0xf8, 0xd9, 0xf9, 0xe3, 0x67, 0xef, 0xf0, 0xb9, 0x53, 0xcf, 0xe1, 0x39, 0xc5, 0xe6,
+ 0x57, 0x06, 0xac, 0x2f, 0x8f, 0xf0, 0xe5, 0xaf, 0xd9, 0xa0, 0x06, 0xa0, 0x47, 0xe2, 0xce, 0x28,
+ 0x39, 0xb5, 0x7e, 0x33, 0x00, 0x2e, 0x0f, 0x11, 0xd5, 0xa1, 0x38, 0xe5, 0x93, 0xec, 0x90, 0x94,
+ 0xa8, 0x2c, 0x72, 0x36, 0xc9, 0x1e, 0x52, 0x25, 0xa2, 0xc7, 0x50, 0x8e, 0x03, 0xc2, 0xd2, 0xa7,
+ 0xa8, 0xda, 0xdb, 0xbe, 0xfb, 0xbe, 0xed, 0x67, 0x0a, 0xef, 0xa4, 0x61, 0xcd, 0x00, 0xca, 0x5a,
+ 0x47, 0xef, 0xc0, 0xe6, 0x34, 0xa2, 0x0c, 0x47, 0x73, 0xd7, 0x13, 0xa1, 0x88, 0xdc, 0x80, 0x9c,
+ 0x65, 0xa5, 0x37, 0x32, 0xc7, 0xae, 0xb2, 0xef, 0x91, 0x33, 0xf5, 0x78, 0x79, 0x34, 0xf2, 0x42,
+ 0xa2, 0x99, 0x98, 0x4e, 0xa6, 0xa1, 0x57, 0xa1, 0xe2, 0xe3, 0xe8, 0xc4, 0x65, 0xc2, 0x4f, 0x09,
+ 0x99, 0x8e, 0xa9, 0x0c, 0x4f, 0x85, 0x4f, 0xac, 0x0b, 0x03, 0xd6, 0x9f, 0xc8, 0x98, 0x32, 0x1c,
+ 0x13, 0x7f, 0x18, 0x51, 0x8f, 0xa0, 0x01, 0xd4, 0xa6, 0x4a, 0xf0, 0xd3, 0xed, 0xcf, 0xa6, 0x7e,
+ 0xe7, 0xf4, 0xaa, 0x69, 0x90, 0x56, 0xd1, 0x87, 0x50, 0xe1, 0x09, 0x23, 0x11, 0xa6, 0x11, 0x79,
+ 0xd1, 0xf1, 0x5f, 0x46, 0xa0, 0x77, 0x01, 0x2d, 0x14, 0x77, 0x4a, 0x22, 0xfd, 0xab, 0xa0, 0xb9,
+ 0x1b, 0x4e, 0x7d, 0xe1, 0x19, 0x92, 0x48, 0x3f, 0x6e, 0x6d, 0xa8, 0x61, 0xe9, 0x8a, 0x63, 0x37,
+ 0x20, 0x74, 0x12, 0xc4, 0x7a, 0xe3, 0x4a, 0x0e, 0x60, 0xf9, 0xd9, 0xf1, 0x9e, 0xb6, 0x58, 0x3f,
+ 0x18, 0xb0, 0x71, 0x6d, 0x7d, 0xd1, 0xfe, 0xd2, 0x09, 0xfc, 0x87, 0x0d, 0xbb, 0xb2, 0xf7, 0xa9,
+ 0x05, 0x3d, 0xfe, 0x67, 0xb7, 0x77, 0x1f, 0xe3, 0x95, 0x76, 0xaf, 0x37, 0x50, 0xbc, 0xde, 0xc0,
+ 0xe0, 0xeb, 0xc2, 0xcf, 0xe7, 0x2d, 0xe3, 0xf9, 0x79, 0xcb, 0xf8, 0xfd, 0xbc, 0x65, 0x7c, 0x73,
+ 0xd1, 0x5a, 0x79, 0x7e, 0xd1, 0x5a, 0xf9, 0xf5, 0xa2, 0xb5, 0x02, 0x4d, 0x4f, 0xb0, 0x5b, 0x8a,
+ 0x0d, 0xd2, 0xbd, 0x1d, 0xaa, 0x93, 0x1b, 0x1a, 0x5f, 0x1c, 0x4c, 0x68, 0x1c, 0x24, 0x63, 0xdb,
+ 0x13, 0xac, 0xe3, 0x09, 0xc9, 0x84, 0xec, 0x44, 0x24, 0xc4, 0x73, 0x12, 0x75, 0x66, 0xbd, 0x85,
+ 0xe8, 0x05, 0x98, 0x72, 0xd9, 0xb9, 0xf9, 0x7f, 0xce, 0x23, 0x2d, 0xcc, 0xba, 0xdf, 0x15, 0x8a,
+ 0xc3, 0xdd, 0x9d, 0xef, 0x0b, 0x5b, 0xc3, 0xbc, 0xf0, 0xae, 0x2a, 0xac, 0xcb, 0xd9, 0xa3, 0xee,
+ 0x2f, 0x97, 0x8e, 0x23, 0xe5, 0x38, 0xd2, 0x8e, 0xa3, 0x51, 0xf7, 0xbc, 0x60, 0xdd, 0xec, 0x38,
+ 0xfa, 0x78, 0x38, 0xc8, 0x47, 0xf3, 0x47, 0xe1, 0x7e, 0x0e, 0xea, 0xf7, 0x15, 0xaa, 0xdf, 0xd7,
+ 0xb0, 0x7e, 0x7f, 0xd4, 0x1d, 0xaf, 0xea, 0x07, 0xe4, 0xe1, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff,
+ 0xad, 0x5c, 0xe1, 0xd0, 0x89, 0x09, 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 *Metadata) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *Metadata) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Metadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.Images) > 0 {
+ for iNdEx := len(m.Images) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Images[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintAsset(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x7c
+ i--
+ dAtA[i] = 0x8a
+ }
+ }
+ 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.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_KnownAssetId_) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ValueView_KnownAssetId_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ if m.KnownAssetId != nil {
+ {
+ size, err := m.KnownAssetId.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_UnknownAssetId_) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ValueView_UnknownAssetId_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ if m.UnknownAssetId != nil {
+ {
+ size, err := m.UnknownAssetId.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_KnownAssetId) Marshal() (dAtA []byte, err error) {
+ size := 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_KnownAssetId) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ValueView_KnownAssetId) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.ExtendedMetadata != nil {
+ {
+ size, err := m.ExtendedMetadata.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintAsset(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x22
+ }
+ if len(m.EquivalentValues) > 0 {
+ for iNdEx := len(m.EquivalentValues) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.EquivalentValues[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintAsset(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x1a
+ }
+ }
+ if m.Metadata != nil {
+ {
+ size, err := m.Metadata.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_UnknownAssetId) Marshal() (dAtA []byte, err error) {
+ size := 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_UnknownAssetId) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ValueView_UnknownAssetId) 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 *AssetImage) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *AssetImage) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AssetImage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.Theme != nil {
+ {
+ size, err := m.Theme.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintAsset(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x1a
+ }
+ if len(m.Svg) > 0 {
+ i -= len(m.Svg)
+ copy(dAtA[i:], m.Svg)
+ i = encodeVarintAsset(dAtA, i, uint64(len(m.Svg)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(m.Png) > 0 {
+ i -= len(m.Png)
+ copy(dAtA[i:], m.Png)
+ i = encodeVarintAsset(dAtA, i, uint64(len(m.Png)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *AssetImage_Theme) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *AssetImage_Theme) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AssetImage_Theme) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.DarkMode {
+ i--
+ if m.DarkMode {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
+ }
+ i--
+ dAtA[i] = 0x18
+ }
+ if m.Circle {
+ i--
+ if m.Circle {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
+ }
+ i--
+ dAtA[i] = 0x10
+ }
+ if len(m.PrimaryColorHex) > 0 {
+ i -= len(m.PrimaryColorHex)
+ copy(dAtA[i:], m.PrimaryColorHex)
+ i = encodeVarintAsset(dAtA, i, uint64(len(m.PrimaryColorHex)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *EstimatedPrice) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *EstimatedPrice) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EstimatedPrice) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.AsOfHeight != 0 {
+ i = encodeVarintAsset(dAtA, i, uint64(m.AsOfHeight))
+ i--
+ dAtA[i] = 0x20
+ }
+ if m.NumerairePerUnit != 0 {
+ i -= 8
+ encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.NumerairePerUnit))))
+ i--
+ dAtA[i] = 0x19
+ }
+ if m.Numeraire != nil {
+ {
+ size, err := m.Numeraire.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintAsset(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x12
+ }
+ if m.PricedAsset != nil {
+ {
+ size, err := m.PricedAsset.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 *EquivalentValue) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *EquivalentValue) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EquivalentValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.AsOfHeight != 0 {
+ i = encodeVarintAsset(dAtA, i, uint64(m.AsOfHeight))
+ i--
+ dAtA[i] = 0x18
+ }
+ if m.Numeraire != nil {
+ {
+ size, err := m.Numeraire.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintAsset(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x12
+ }
+ if m.EquivalentAmount != nil {
+ {
+ size, err := m.EquivalentAmount.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 *Metadata) 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))
+ }
+ if m.PenumbraAssetId != nil {
+ l = m.PenumbraAssetId.Size()
+ n += 2 + l + sovAsset(uint64(l))
+ }
+ if len(m.Images) > 0 {
+ for _, e := range m.Images {
+ l = e.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_KnownAssetId_) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.KnownAssetId != nil {
+ l = m.KnownAssetId.Size()
+ n += 1 + l + sovAsset(uint64(l))
+ }
+ return n
+}
+func (m *ValueView_UnknownAssetId_) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.UnknownAssetId != nil {
+ l = m.UnknownAssetId.Size()
+ n += 1 + l + sovAsset(uint64(l))
+ }
+ return n
+}
+func (m *ValueView_KnownAssetId) 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.Metadata != nil {
+ l = m.Metadata.Size()
+ n += 1 + l + sovAsset(uint64(l))
+ }
+ if len(m.EquivalentValues) > 0 {
+ for _, e := range m.EquivalentValues {
+ l = e.Size()
+ n += 1 + l + sovAsset(uint64(l))
+ }
+ }
+ if m.ExtendedMetadata != nil {
+ l = m.ExtendedMetadata.Size()
+ n += 1 + l + sovAsset(uint64(l))
+ }
+ return n
+}
+
+func (m *ValueView_UnknownAssetId) 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 *AssetImage) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Png)
+ if l > 0 {
+ n += 1 + l + sovAsset(uint64(l))
+ }
+ l = len(m.Svg)
+ if l > 0 {
+ n += 1 + l + sovAsset(uint64(l))
+ }
+ if m.Theme != nil {
+ l = m.Theme.Size()
+ n += 1 + l + sovAsset(uint64(l))
+ }
+ return n
+}
+
+func (m *AssetImage_Theme) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.PrimaryColorHex)
+ if l > 0 {
+ n += 1 + l + sovAsset(uint64(l))
+ }
+ if m.Circle {
+ n += 2
+ }
+ if m.DarkMode {
+ n += 2
+ }
+ return n
+}
+
+func (m *EstimatedPrice) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.PricedAsset != nil {
+ l = m.PricedAsset.Size()
+ n += 1 + l + sovAsset(uint64(l))
+ }
+ if m.Numeraire != nil {
+ l = m.Numeraire.Size()
+ n += 1 + l + sovAsset(uint64(l))
+ }
+ if m.NumerairePerUnit != 0 {
+ n += 9
+ }
+ if m.AsOfHeight != 0 {
+ n += 1 + sovAsset(uint64(m.AsOfHeight))
+ }
+ return n
+}
+
+func (m *EquivalentValue) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.EquivalentAmount != nil {
+ l = m.EquivalentAmount.Size()
+ n += 1 + l + sovAsset(uint64(l))
+ }
+ if m.Numeraire != nil {
+ l = m.Numeraire.Size()
+ n += 1 + l + sovAsset(uint64(l))
+ }
+ if m.AsOfHeight != 0 {
+ n += 1 + sovAsset(uint64(m.AsOfHeight))
+ }
+ 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 *Metadata) Unmarshal(dAtA []byte) 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: Metadata: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Metadata: 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 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
+ case 1985:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Images", 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.Images = append(m.Images, &AssetImage{})
+ if err := m.Images[len(m.Images)-1].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 = &v1.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 KnownAssetId", 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_KnownAssetId{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ m.ValueView = &ValueView_KnownAssetId_{v}
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field UnknownAssetId", 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_UnknownAssetId{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ m.ValueView = &ValueView_UnknownAssetId_{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_KnownAssetId) Unmarshal(dAtA []byte) 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: KnownAssetId: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: KnownAssetId: 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 = &v1.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 Metadata", 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.Metadata == nil {
+ m.Metadata = &Metadata{}
+ }
+ if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field EquivalentValues", 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.EquivalentValues = append(m.EquivalentValues, &EquivalentValue{})
+ if err := m.EquivalentValues[len(m.EquivalentValues)-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 ExtendedMetadata", 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.ExtendedMetadata == nil {
+ m.ExtendedMetadata = &types.Any{}
+ }
+ if err := m.ExtendedMetadata.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_UnknownAssetId) Unmarshal(dAtA []byte) 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: UnknownAssetId: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: UnknownAssetId: 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 = &v1.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 *AssetImage) Unmarshal(dAtA []byte) 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: AssetImage: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: AssetImage: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Png", 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.Png = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Svg", 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.Svg = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Theme", 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.Theme == nil {
+ m.Theme = &AssetImage_Theme{}
+ }
+ if err := m.Theme.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 *AssetImage_Theme) Unmarshal(dAtA []byte) 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: Theme: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Theme: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PrimaryColorHex", 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.PrimaryColorHex = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Circle", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowAsset
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ v |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.Circle = bool(v != 0)
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DarkMode", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowAsset
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ v |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.DarkMode = bool(v != 0)
+ 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 *EstimatedPrice) Unmarshal(dAtA []byte) 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: EstimatedPrice: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EstimatedPrice: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PricedAsset", 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.PricedAsset == nil {
+ m.PricedAsset = &AssetId{}
+ }
+ if err := m.PricedAsset.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Numeraire", 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.Numeraire == nil {
+ m.Numeraire = &AssetId{}
+ }
+ if err := m.Numeraire.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 1 {
+ return fmt.Errorf("proto: wrong wireType = %d for field NumerairePerUnit", wireType)
+ }
+ var v uint64
+ if (iNdEx + 8) > l {
+ return io.ErrUnexpectedEOF
+ }
+ v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+ iNdEx += 8
+ m.NumerairePerUnit = float64(math.Float64frombits(v))
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field AsOfHeight", wireType)
+ }
+ m.AsOfHeight = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowAsset
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.AsOfHeight |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ 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 *EquivalentValue) Unmarshal(dAtA []byte) 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: EquivalentValue: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EquivalentValue: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field EquivalentAmount", 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.EquivalentAmount == nil {
+ m.EquivalentAmount = &v1.Amount{}
+ }
+ if err := m.EquivalentAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Numeraire", 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.Numeraire == nil {
+ m.Numeraire = &Metadata{}
+ }
+ if err := m.Numeraire.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field AsOfHeight", wireType)
+ }
+ m.AsOfHeight = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowAsset
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.AsOfHeight |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ 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/community_pool/v1/community_pool.pb.go b/relayer/chains/penumbra/core/component/community_pool/v1/community_pool.pb.go
new file mode 100644
index 000000000..0225252dd
--- /dev/null
+++ b/relayer/chains/penumbra/core/component/community_pool/v1/community_pool.pb.go
@@ -0,0 +1,988 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: penumbra/core/component/community_pool/v1/community_pool.proto
+
+package community_poolv1
+
+import (
+ context "context"
+ fmt "fmt"
+ grpc1 "github.com/cosmos/gogoproto/grpc"
+ proto "github.com/cosmos/gogoproto/proto"
+ v1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/asset/v1"
+ 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_1c6b5a43fb54145e, []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_1c6b5a43fb54145e, []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 {
+ // (Optional): The specific asset balances to retrieve, if excluded all will be returned.
+ AssetIds []*v1.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_1c6b5a43fb54145e, []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) GetAssetIds() []*v1.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 *v1.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_1c6b5a43fb54145e, []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() *v1.Value {
+ if m != nil {
+ return m.Balance
+ }
+ return nil
+}
+
+func init() {
+ proto.RegisterType((*CommunityPoolParameters)(nil), "penumbra.core.component.community_pool.v1.CommunityPoolParameters")
+ proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.community_pool.v1.GenesisContent")
+ proto.RegisterType((*CommunityPoolAssetBalancesRequest)(nil), "penumbra.core.component.community_pool.v1.CommunityPoolAssetBalancesRequest")
+ proto.RegisterType((*CommunityPoolAssetBalancesResponse)(nil), "penumbra.core.component.community_pool.v1.CommunityPoolAssetBalancesResponse")
+}
+
+func init() {
+ proto.RegisterFile("penumbra/core/component/community_pool/v1/community_pool.proto", fileDescriptor_1c6b5a43fb54145e)
+}
+
+var fileDescriptor_1c6b5a43fb54145e = []byte{
+ // 510 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0x41, 0x8a, 0xd4, 0x40,
+ 0x14, 0x86, 0xbb, 0x32, 0xa2, 0x63, 0x8d, 0xb8, 0x88, 0x88, 0x43, 0x83, 0x71, 0xcc, 0x42, 0x5a,
+ 0xd0, 0xc4, 0xb4, 0x82, 0xd0, 0x8a, 0x60, 0x82, 0x0c, 0x82, 0x03, 0x31, 0x03, 0xbd, 0x90, 0x48,
+ 0xa8, 0x24, 0x4f, 0x27, 0x90, 0x54, 0xc5, 0xaa, 0x4a, 0xa0, 0x6f, 0x30, 0x4b, 0xcf, 0xe0, 0xd2,
+ 0x2b, 0x78, 0x01, 0x11, 0x17, 0xb3, 0x74, 0x29, 0xdd, 0x3b, 0x4f, 0x21, 0x95, 0x4c, 0x7a, 0x4c,
+ 0x6b, 0x4b, 0x23, 0x6e, 0xc2, 0xa3, 0xf2, 0xfd, 0xff, 0x7b, 0xef, 0xa7, 0x12, 0xfc, 0xa4, 0x04,
+ 0x5a, 0x15, 0x31, 0x27, 0x76, 0xc2, 0x38, 0xd8, 0x09, 0x2b, 0x4a, 0x46, 0x81, 0x4a, 0x55, 0x15,
+ 0x15, 0xcd, 0xe4, 0x2c, 0x2a, 0x19, 0xcb, 0xed, 0xda, 0x59, 0x39, 0xb1, 0x4a, 0xce, 0x24, 0xd3,
+ 0x6f, 0x77, 0x7a, 0x4b, 0xe9, 0xad, 0xa5, 0xde, 0x5a, 0xa1, 0x6b, 0x67, 0x68, 0xf6, 0x5b, 0x11,
+ 0x21, 0x40, 0x2a, 0xdf, 0xa6, 0x68, 0xed, 0xcc, 0x02, 0x5f, 0xf3, 0x3a, 0xa1, 0xcf, 0x58, 0xee,
+ 0x13, 0x4e, 0x0a, 0x90, 0xc0, 0x85, 0x1e, 0xe0, 0x5b, 0x7d, 0xcf, 0x48, 0x94, 0x40, 0xd3, 0xa8,
+ 0xe4, 0xac, 0x64, 0x82, 0xe4, 0x22, 0x02, 0x4a, 0xe2, 0x1c, 0xd2, 0x5d, 0xb4, 0x87, 0x46, 0xdb,
+ 0x81, 0x99, 0xfc, 0x6a, 0x74, 0xa8, 0x58, 0xbf, 0x43, 0x9f, 0xb5, 0xa4, 0x79, 0x8c, 0xf0, 0xe5,
+ 0x7d, 0xa0, 0x20, 0x32, 0xe1, 0x31, 0x2a, 0x81, 0x4a, 0xbd, 0xc6, 0x57, 0x57, 0xda, 0x94, 0x6a,
+ 0x06, 0xd1, 0xb8, 0xee, 0x8c, 0x5d, 0x6b, 0xe3, 0x85, 0xad, 0x35, 0x9b, 0x04, 0x57, 0x92, 0xdf,
+ 0x5e, 0x08, 0x93, 0xe0, 0x9b, 0x3d, 0xfe, 0xa9, 0x4a, 0xc5, 0x25, 0x39, 0xa1, 0x09, 0x88, 0x00,
+ 0xde, 0x55, 0x20, 0xa4, 0xfe, 0x18, 0x5f, 0x6c, 0xd2, 0x8a, 0xb2, 0x54, 0xec, 0x6a, 0x7b, 0x5b,
+ 0xa3, 0x9d, 0xf1, 0x8d, 0x95, 0x81, 0xda, 0x34, 0x6b, 0xc7, 0x6a, 0x0c, 0x9e, 0xa7, 0xc1, 0x36,
+ 0x69, 0x0b, 0x61, 0xbe, 0xc6, 0xe6, 0xdf, 0x5a, 0x88, 0x92, 0x51, 0x01, 0xfa, 0x43, 0x7c, 0x21,
+ 0x6e, 0xcf, 0x4e, 0x57, 0xbe, 0xbe, 0xae, 0xc3, 0x94, 0xe4, 0x15, 0x04, 0x1d, 0x3d, 0xfe, 0x8a,
+ 0xf0, 0xa5, 0x97, 0x15, 0xf0, 0xd9, 0x21, 0xf0, 0x3a, 0x4b, 0x40, 0xff, 0x84, 0xf0, 0x70, 0x7d,
+ 0x43, 0xfd, 0xc5, 0xbf, 0x46, 0xf9, 0xa7, 0x68, 0x86, 0x07, 0xff, 0xc9, 0xad, 0x4d, 0xe1, 0x1e,
+ 0x72, 0x8f, 0xb7, 0x3e, 0xcf, 0x0d, 0x74, 0x32, 0x37, 0xd0, 0xf7, 0xb9, 0x81, 0xde, 0x2f, 0x8c,
+ 0xc1, 0xc9, 0xc2, 0x18, 0x7c, 0x5b, 0x18, 0x03, 0x7c, 0x37, 0x61, 0xc5, 0xe6, 0xed, 0x5c, 0xbd,
+ 0x7f, 0x11, 0xd4, 0x45, 0xf7, 0xd1, 0xab, 0x37, 0x6f, 0x33, 0x79, 0x54, 0xc5, 0x8a, 0xb7, 0x13,
+ 0x26, 0x0a, 0x26, 0x6c, 0x0e, 0x39, 0x99, 0x01, 0xb7, 0xeb, 0xf1, 0xb2, 0x4c, 0x8e, 0x48, 0x46,
+ 0x85, 0xbd, 0xf1, 0x57, 0xfa, 0xa8, 0x7f, 0x52, 0x3b, 0x1f, 0xb4, 0x73, 0xbe, 0xe7, 0x79, 0x1f,
+ 0xb5, 0x91, 0xdf, 0x0d, 0xec, 0xa9, 0x81, 0xbd, 0xe5, 0xc0, 0xbd, 0xe9, 0xac, 0xa9, 0xf3, 0xe5,
+ 0x0c, 0x0d, 0x15, 0x1a, 0x2e, 0xd1, 0xb0, 0x87, 0x86, 0x53, 0x67, 0xae, 0x3d, 0xd8, 0x14, 0x0d,
+ 0xf7, 0x7d, 0xf7, 0x00, 0x24, 0x49, 0x89, 0x24, 0x3f, 0xb4, 0x3b, 0x9d, 0x6c, 0x32, 0x51, 0x3a,
+ 0xf5, 0x3c, 0x15, 0x36, 0xe5, 0x99, 0x72, 0x32, 0x99, 0x3a, 0xf1, 0xf9, 0xe6, 0xe7, 0x70, 0xff,
+ 0x67, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0e, 0xcb, 0x4c, 0x16, 0xad, 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 {
+ 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.v1.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.v1.QueryService",
+ HandlerType: (*QueryServiceServer)(nil),
+ Methods: []grpc.MethodDesc{},
+ Streams: []grpc.StreamDesc{
+ {
+ StreamName: "CommunityPoolAssetBalances",
+ Handler: _QueryService_CommunityPoolAssetBalances_Handler,
+ ServerStreams: true,
+ },
+ },
+ Metadata: "penumbra/core/component/community_pool/v1/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
+ }
+ }
+ 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
+ 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 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, &v1.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 = &v1.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/v1/compact_block.pb.go b/relayer/chains/penumbra/core/component/compact_block/v1/compact_block.pb.go
new file mode 100644
index 000000000..d0c34ba7e
--- /dev/null
+++ b/relayer/chains/penumbra/core/component/compact_block/v1/compact_block.pb.go
@@ -0,0 +1,2814 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: penumbra/core/component/compact_block/v1/compact_block.proto
+
+package compact_blockv1
+
+import (
+ context "context"
+ fmt "fmt"
+ grpc1 "github.com/cosmos/gogoproto/grpc"
+ proto "github.com/cosmos/gogoproto/proto"
+ v13 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/dex/v1"
+ v14 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/fee/v1"
+ v1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/sct/v1"
+ v12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/shielded_pool/v1"
+ v11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/tct/v1"
+ 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 []*v1.Nullifier `protobuf:"bytes,3,rep,name=nullifiers,proto3" json:"nullifiers,omitempty"`
+ // The block root of this block.
+ BlockRoot *v11.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 *v11.MerkleRoot `protobuf:"bytes,5,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,6,opt,name=proposal_started,json=proposalStarted,proto3" json:"proposal_started,omitempty"`
+ // Latest Fuzzy Message Detection parameters.
+ FmdParameters *v12.FmdParameters `protobuf:"bytes,7,opt,name=fmd_parameters,json=fmdParameters,proto3" json:"fmd_parameters,omitempty"`
+ // Price data for swaps executed in this block.
+ SwapOutputs []*v13.BatchSwapOutputData `protobuf:"bytes,8,rep,name=swap_outputs,json=swapOutputs,proto3" json:"swap_outputs,omitempty"`
+ // Indicates updated app parameters.
+ AppParametersUpdated bool `protobuf:"varint,9,opt,name=app_parameters_updated,json=appParametersUpdated,proto3" json:"app_parameters_updated,omitempty"`
+ // Updated gas prices, if they have changed.
+ GasPrices *v14.GasPrices `protobuf:"bytes,10,opt,name=gas_prices,json=gasPrices,proto3" json:"gas_prices,omitempty"`
+ // The epoch index
+ EpochIndex uint64 `protobuf:"varint,11,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,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_5be1c543aaa156af, []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() []*v1.Nullifier {
+ if m != nil {
+ return m.Nullifiers
+ }
+ return nil
+}
+
+func (m *CompactBlock) GetBlockRoot() *v11.MerkleRoot {
+ if m != nil {
+ return m.BlockRoot
+ }
+ return nil
+}
+
+func (m *CompactBlock) GetEpochRoot() *v11.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() *v12.FmdParameters {
+ if m != nil {
+ return m.FmdParameters
+ }
+ return nil
+}
+
+func (m *CompactBlock) GetSwapOutputs() []*v13.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() *v14.GasPrices {
+ if m != nil {
+ return m.GasPrices
+ }
+ return nil
+}
+
+func (m *CompactBlock) GetEpochIndex() uint64 {
+ if m != nil {
+ return m.EpochIndex
+ }
+ return 0
+}
+
+// An encrypted payload, corresponding to a single commitment in the state commitment tree.
+type StatePayload struct {
+ // The source of the payload, if known.
+ Source *v1.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_5be1c543aaa156af, []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() *v1.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 *v11.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_5be1c543aaa156af, []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() *v11.StateCommitment {
+ if m != nil {
+ return m.Commitment
+ }
+ return nil
+}
+
+type StatePayload_Note struct {
+ Note *v12.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_5be1c543aaa156af, []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() *v12.NotePayload {
+ if m != nil {
+ return m.Note
+ }
+ return nil
+}
+
+type StatePayload_Swap struct {
+ Swap *v13.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_5be1c543aaa156af, []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() *v13.SwapPayload {
+ if m != nil {
+ return m.Swap
+ }
+ return nil
+}
+
+// Requests a range of compact block data.
+type CompactBlockRangeRequest struct {
+ // 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_5be1c543aaa156af, []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) 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_5be1c543aaa156af, []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
+}
+
+type CompactBlockRequest struct {
+ Height uint64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
+}
+
+func (m *CompactBlockRequest) Reset() { *m = CompactBlockRequest{} }
+func (m *CompactBlockRequest) String() string { return proto.CompactTextString(m) }
+func (*CompactBlockRequest) ProtoMessage() {}
+func (*CompactBlockRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_5be1c543aaa156af, []int{4}
+}
+func (m *CompactBlockRequest) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *CompactBlockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_CompactBlockRequest.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *CompactBlockRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_CompactBlockRequest.Merge(m, src)
+}
+func (m *CompactBlockRequest) XXX_Size() int {
+ return m.Size()
+}
+func (m *CompactBlockRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_CompactBlockRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CompactBlockRequest proto.InternalMessageInfo
+
+func (m *CompactBlockRequest) GetHeight() uint64 {
+ if m != nil {
+ return m.Height
+ }
+ return 0
+}
+
+type CompactBlockResponse struct {
+ CompactBlock *CompactBlock `protobuf:"bytes,1,opt,name=compact_block,json=compactBlock,proto3" json:"compact_block,omitempty"`
+}
+
+func (m *CompactBlockResponse) Reset() { *m = CompactBlockResponse{} }
+func (m *CompactBlockResponse) String() string { return proto.CompactTextString(m) }
+func (*CompactBlockResponse) ProtoMessage() {}
+func (*CompactBlockResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_5be1c543aaa156af, []int{5}
+}
+func (m *CompactBlockResponse) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *CompactBlockResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_CompactBlockResponse.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *CompactBlockResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_CompactBlockResponse.Merge(m, src)
+}
+func (m *CompactBlockResponse) XXX_Size() int {
+ return m.Size()
+}
+func (m *CompactBlockResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_CompactBlockResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CompactBlockResponse proto.InternalMessageInfo
+
+func (m *CompactBlockResponse) GetCompactBlock() *CompactBlock {
+ if m != nil {
+ return m.CompactBlock
+ }
+ return nil
+}
+
+func init() {
+ proto.RegisterType((*CompactBlock)(nil), "penumbra.core.component.compact_block.v1.CompactBlock")
+ proto.RegisterType((*StatePayload)(nil), "penumbra.core.component.compact_block.v1.StatePayload")
+ proto.RegisterType((*StatePayload_RolledUp)(nil), "penumbra.core.component.compact_block.v1.StatePayload.RolledUp")
+ proto.RegisterType((*StatePayload_Note)(nil), "penumbra.core.component.compact_block.v1.StatePayload.Note")
+ proto.RegisterType((*StatePayload_Swap)(nil), "penumbra.core.component.compact_block.v1.StatePayload.Swap")
+ proto.RegisterType((*CompactBlockRangeRequest)(nil), "penumbra.core.component.compact_block.v1.CompactBlockRangeRequest")
+ proto.RegisterType((*CompactBlockRangeResponse)(nil), "penumbra.core.component.compact_block.v1.CompactBlockRangeResponse")
+ proto.RegisterType((*CompactBlockRequest)(nil), "penumbra.core.component.compact_block.v1.CompactBlockRequest")
+ proto.RegisterType((*CompactBlockResponse)(nil), "penumbra.core.component.compact_block.v1.CompactBlockResponse")
+}
+
+func init() {
+ proto.RegisterFile("penumbra/core/component/compact_block/v1/compact_block.proto", fileDescriptor_5be1c543aaa156af)
+}
+
+var fileDescriptor_5be1c543aaa156af = []byte{
+ // 999 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x96, 0x4d, 0x8f, 0xdb, 0x44,
+ 0x18, 0xc7, 0xd7, 0xd9, 0x74, 0xd9, 0x4c, 0xb2, 0x2d, 0x0c, 0x55, 0x65, 0x56, 0x22, 0x2c, 0xb9,
+ 0x34, 0x55, 0xc1, 0xa9, 0x53, 0x5e, 0xa4, 0x2d, 0x50, 0x35, 0x41, 0x6c, 0xf6, 0xd0, 0x92, 0x75,
+ 0xd4, 0x3d, 0x40, 0xa8, 0x35, 0x6b, 0x3f, 0x49, 0xac, 0xb5, 0x3d, 0x83, 0x67, 0xec, 0xee, 0x8a,
+ 0x0b, 0x5f, 0x00, 0x89, 0x4f, 0xc0, 0x81, 0x23, 0x5f, 0x82, 0x2b, 0xe2, 0xd4, 0x23, 0xe2, 0x54,
+ 0xed, 0xde, 0xf8, 0x14, 0x68, 0xc6, 0x76, 0x62, 0x03, 0xd1, 0x86, 0x20, 0x71, 0x89, 0x66, 0x1e,
+ 0x3f, 0xff, 0xdf, 0x3c, 0x2f, 0x33, 0x93, 0x41, 0x1f, 0x31, 0x08, 0xe3, 0xe0, 0x24, 0x22, 0x1d,
+ 0x87, 0x46, 0xd0, 0x71, 0x68, 0xc0, 0x68, 0x08, 0xa1, 0x50, 0x23, 0xe2, 0x08, 0xfb, 0xc4, 0xa7,
+ 0xce, 0x69, 0x27, 0x31, 0xcb, 0x06, 0x83, 0x45, 0x54, 0x50, 0xdc, 0xce, 0xd5, 0x86, 0x54, 0x1b,
+ 0x73, 0xb5, 0x51, 0x76, 0x4e, 0xcc, 0xdd, 0xf6, 0xb2, 0x75, 0x5c, 0x38, 0x93, 0x74, 0x17, 0xce,
+ 0x52, 0xe6, 0x72, 0xcf, 0x09, 0x80, 0xf4, 0x9c, 0x00, 0x5c, 0xe5, 0xc9, 0x1d, 0x21, 0x3d, 0xb9,
+ 0x23, 0x32, 0xcf, 0xa5, 0x59, 0xf2, 0x99, 0x07, 0xbe, 0x0b, 0xae, 0xcd, 0x28, 0xf5, 0x95, 0xa6,
+ 0x68, 0xc8, 0xd4, 0x7b, 0x0b, 0x75, 0x74, 0xce, 0x04, 0xed, 0x88, 0x94, 0x2f, 0x72, 0x7e, 0xeb,
+ 0xf7, 0x6b, 0xa8, 0xd1, 0x4f, 0x53, 0xee, 0xc9, 0x8c, 0xf1, 0x2d, 0xb4, 0x35, 0x03, 0x6f, 0x3a,
+ 0x13, 0xba, 0xb6, 0xa7, 0xb5, 0xab, 0x56, 0x36, 0xc3, 0x5f, 0xa1, 0xeb, 0x5c, 0x10, 0x01, 0x36,
+ 0x23, 0xe7, 0x3e, 0x25, 0x2e, 0xd7, 0x2b, 0x7b, 0x9b, 0xed, 0x7a, 0xf7, 0x03, 0x63, 0xd5, 0x4a,
+ 0x1a, 0x23, 0xa9, 0x1f, 0xa6, 0x72, 0x6b, 0x87, 0x17, 0x66, 0x1c, 0x1f, 0x22, 0x14, 0xc6, 0xbe,
+ 0xef, 0x4d, 0x3c, 0x88, 0xb8, 0xbe, 0xa9, 0xd0, 0x77, 0x96, 0xa2, 0x65, 0x7d, 0x12, 0xd3, 0x78,
+ 0x92, 0x2b, 0xac, 0x82, 0x18, 0x3f, 0x42, 0x48, 0x2d, 0x69, 0x47, 0x94, 0x0a, 0xbd, 0xba, 0xa7,
+ 0xb5, 0xeb, 0xdd, 0x56, 0x01, 0xa5, 0x2a, 0x61, 0x88, 0x14, 0xf1, 0x18, 0xa2, 0x53, 0x1f, 0x2c,
+ 0x4a, 0x85, 0x55, 0x53, 0x2a, 0x39, 0x94, 0x08, 0x60, 0xd4, 0x99, 0xa5, 0x88, 0x6b, 0xab, 0x23,
+ 0x94, 0x4a, 0x21, 0xee, 0xa0, 0x57, 0x59, 0x44, 0x19, 0xe5, 0xc4, 0xb7, 0xb9, 0x20, 0x91, 0x00,
+ 0x57, 0xdf, 0xda, 0xd3, 0xda, 0xdb, 0xd6, 0x8d, 0xdc, 0x3e, 0x4a, 0xcd, 0xf8, 0x19, 0xba, 0x3e,
+ 0x09, 0x5c, 0x9b, 0x91, 0x88, 0x04, 0x20, 0x64, 0xfe, 0xaf, 0xa8, 0x15, 0x3f, 0x5c, 0x9e, 0x7f,
+ 0xa9, 0xd7, 0x89, 0x69, 0x7c, 0x16, 0xb8, 0xc3, 0xb9, 0xdc, 0xda, 0x99, 0x14, 0xa7, 0xf8, 0x18,
+ 0x35, 0xf8, 0x73, 0xc2, 0x6c, 0x1a, 0x0b, 0x16, 0x0b, 0xae, 0x6f, 0xab, 0xea, 0xde, 0x5f, 0x4a,
+ 0x97, 0x3b, 0x3a, 0x31, 0x8d, 0x1e, 0x11, 0xce, 0x6c, 0xf4, 0x9c, 0xb0, 0xcf, 0x95, 0xee, 0x53,
+ 0x22, 0x88, 0x55, 0xe7, 0xf3, 0x39, 0xc7, 0xef, 0xa1, 0x5b, 0x84, 0xb1, 0x42, 0xdc, 0x76, 0xcc,
+ 0x5c, 0x22, 0x13, 0xad, 0xa9, 0x44, 0x6f, 0x12, 0xc6, 0x16, 0x61, 0x3c, 0x4d, 0xbf, 0xe1, 0x01,
+ 0x42, 0x53, 0xc2, 0x6d, 0x16, 0x79, 0x0e, 0x70, 0x1d, 0xa9, 0x4c, 0x97, 0x77, 0x5a, 0x9e, 0x99,
+ 0xc4, 0x34, 0x0e, 0x08, 0x1f, 0x2a, 0x81, 0x55, 0x9b, 0xe6, 0x43, 0xfc, 0x16, 0xaa, 0xa7, 0x5d,
+ 0xf2, 0x42, 0x17, 0xce, 0xf4, 0xba, 0xda, 0xaf, 0x69, 0xe3, 0x0e, 0xa5, 0xa5, 0xf5, 0xb2, 0x8a,
+ 0x1a, 0xc5, 0x4d, 0x87, 0x07, 0x68, 0x8b, 0xd3, 0x38, 0x72, 0x40, 0x6d, 0xee, 0x7a, 0xf7, 0xde,
+ 0x55, 0x3b, 0xac, 0x4f, 0x83, 0xc0, 0x13, 0x01, 0x84, 0x62, 0xa4, 0x74, 0x56, 0xa6, 0xc7, 0xcf,
+ 0x50, 0x2d, 0xa2, 0xbe, 0x0f, 0xae, 0x1d, 0x33, 0xbd, 0xa2, 0x60, 0x0f, 0xd7, 0x3b, 0x09, 0x86,
+ 0xa5, 0x38, 0x4f, 0xd9, 0x60, 0xc3, 0xda, 0x8e, 0xb2, 0x31, 0x3e, 0x42, 0xd5, 0x90, 0x0a, 0xd0,
+ 0x37, 0x15, 0xfa, 0xc1, 0x9a, 0xe8, 0x27, 0x54, 0xc0, 0x60, 0xc3, 0x52, 0x28, 0x89, 0x94, 0xdd,
+ 0xcb, 0x4e, 0xc4, 0xba, 0x48, 0xb9, 0x21, 0x24, 0x52, 0xa2, 0x76, 0x47, 0x68, 0x3b, 0x8f, 0x1e,
+ 0x1f, 0x20, 0xe4, 0xcc, 0xab, 0x95, 0xd5, 0xf7, 0xf6, 0xb2, 0x33, 0xa3, 0x90, 0x8b, 0xe2, 0x5a,
+ 0x05, 0xe9, 0xee, 0x11, 0xaa, 0xca, 0xb8, 0xf1, 0x61, 0x56, 0x82, 0xb4, 0xba, 0xef, 0xaf, 0x7e,
+ 0x18, 0xa4, 0x3a, 0xbf, 0x66, 0x14, 0x62, 0xf7, 0x00, 0x55, 0x65, 0xdc, 0xf8, 0x61, 0x56, 0x82,
+ 0x14, 0x79, 0xf7, 0xaa, 0x13, 0x20, 0x35, 0x73, 0x90, 0x14, 0xf6, 0x6e, 0xa0, 0x9d, 0xd2, 0x2d,
+ 0xd8, 0xfa, 0x06, 0xe9, 0xc5, 0xeb, 0xd3, 0x22, 0xe1, 0x14, 0x2c, 0xf8, 0x3a, 0x06, 0x2e, 0xf0,
+ 0xdb, 0xa8, 0xa1, 0x4e, 0xbe, 0x9d, 0x5d, 0xa8, 0x15, 0xb5, 0x41, 0xeb, 0xca, 0x36, 0x48, 0x6f,
+ 0xd5, 0x37, 0x11, 0x82, 0xd0, 0xcd, 0x1d, 0x36, 0x95, 0x43, 0x0d, 0x42, 0x77, 0xf1, 0xf9, 0x14,
+ 0x80, 0xd9, 0xc4, 0xf7, 0x12, 0x50, 0x8d, 0xdb, 0xb6, 0x6a, 0xd2, 0xf2, 0x48, 0x1a, 0x5a, 0x67,
+ 0xe8, 0x8d, 0x7f, 0x58, 0x9c, 0x33, 0x1a, 0x72, 0xc0, 0x5f, 0xa2, 0x9d, 0x52, 0x27, 0xb3, 0x96,
+ 0xfc, 0x8b, 0xfb, 0xba, 0xc4, 0x6e, 0x38, 0x85, 0x59, 0xeb, 0x5d, 0xf4, 0x7a, 0xe9, 0x6b, 0x96,
+ 0xf1, 0x92, 0x3f, 0x8f, 0x16, 0x47, 0x37, 0xcb, 0xee, 0xff, 0x43, 0x8c, 0xdd, 0x9f, 0x2b, 0xa8,
+ 0x71, 0x14, 0x43, 0x74, 0x3e, 0x82, 0x28, 0xf1, 0x1c, 0xc0, 0x3f, 0x68, 0xe8, 0xb5, 0xbf, 0xd5,
+ 0x0b, 0xf7, 0xd6, 0x5c, 0xac, 0xd0, 0xe9, 0xdd, 0xfe, 0x7f, 0x62, 0xa4, 0xc5, 0xb8, 0xa7, 0xe1,
+ 0xef, 0xb4, 0xbf, 0xfc, 0x19, 0x7f, 0xbc, 0x26, 0x37, 0x0b, 0xeb, 0x93, 0x75, 0xe5, 0x69, 0x44,
+ 0xbd, 0x6f, 0x37, 0x7f, 0xb9, 0x68, 0x6a, 0x2f, 0x2e, 0x9a, 0xda, 0xcb, 0x8b, 0xa6, 0xf6, 0xfd,
+ 0x65, 0x73, 0xe3, 0xc5, 0x65, 0x73, 0xe3, 0xb7, 0xcb, 0xe6, 0x06, 0x7a, 0xc7, 0xa1, 0xc1, 0xca,
+ 0xf4, 0x5e, 0xa9, 0xec, 0x43, 0xf9, 0xf0, 0x18, 0x6a, 0x5f, 0xb8, 0x53, 0x4f, 0xcc, 0xe2, 0x13,
+ 0xe9, 0xdd, 0x71, 0x28, 0x0f, 0x28, 0xef, 0x44, 0xe0, 0x93, 0x73, 0x88, 0x3a, 0x49, 0x77, 0x3e,
+ 0x74, 0x66, 0xc4, 0x0b, 0x79, 0x67, 0xd5, 0xc7, 0xde, 0x83, 0x92, 0x21, 0x31, 0x7f, 0xac, 0x54,
+ 0x87, 0xfd, 0x7e, 0xff, 0xa7, 0xca, 0xed, 0x61, 0x1e, 0x6c, 0x5f, 0x06, 0xdb, 0x9f, 0x07, 0x5b,
+ 0x0c, 0xcd, 0x38, 0x36, 0x7f, 0x5d, 0x78, 0x8e, 0xa5, 0xe7, 0x78, 0xee, 0x39, 0x2e, 0x7a, 0x8e,
+ 0x8f, 0xcd, 0x8b, 0xca, 0xfd, 0x15, 0x3d, 0xc7, 0x07, 0xc3, 0xde, 0x63, 0x10, 0xc4, 0x25, 0x82,
+ 0xfc, 0x51, 0xb9, 0x9b, 0xab, 0xf6, 0xf7, 0xa5, 0x4c, 0xfe, 0x66, 0xba, 0x74, 0x98, 0x0b, 0xf7,
+ 0xf7, 0x8f, 0xcd, 0x93, 0x2d, 0xf5, 0x4c, 0xbb, 0xff, 0x67, 0x00, 0x00, 0x00, 0xff, 0xff, 0xbe,
+ 0xa3, 0xa4, 0x6d, 0xee, 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 compact blocks, optionally keeping the stream alive for push notifications.
+ CompactBlockRange(ctx context.Context, in *CompactBlockRangeRequest, opts ...grpc.CallOption) (QueryService_CompactBlockRangeClient, error)
+ // Returns a single compact block at a specific height.
+ //
+ // Clients requesting multiple compact blocks should generally use the streaming RPC.
+ CompactBlock(ctx context.Context, in *CompactBlockRequest, opts ...grpc.CallOption) (*CompactBlockResponse, 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.v1.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
+}
+
+func (c *queryServiceClient) CompactBlock(ctx context.Context, in *CompactBlockRequest, opts ...grpc.CallOption) (*CompactBlockResponse, error) {
+ out := new(CompactBlockResponse)
+ err := c.cc.Invoke(ctx, "/penumbra.core.component.compact_block.v1.QueryService/CompactBlock", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+// QueryServiceServer is the server API for QueryService service.
+type QueryServiceServer interface {
+ // Returns a stream of compact blocks, optionally keeping the stream alive for push notifications.
+ CompactBlockRange(*CompactBlockRangeRequest, QueryService_CompactBlockRangeServer) error
+ // Returns a single compact block at a specific height.
+ //
+ // Clients requesting multiple compact blocks should generally use the streaming RPC.
+ CompactBlock(context.Context, *CompactBlockRequest) (*CompactBlockResponse, 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 (*UnimplementedQueryServiceServer) CompactBlock(ctx context.Context, req *CompactBlockRequest) (*CompactBlockResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method CompactBlock 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)
+}
+
+func _QueryService_CompactBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(CompactBlockRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(QueryServiceServer).CompactBlock(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/penumbra.core.component.compact_block.v1.QueryService/CompactBlock",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(QueryServiceServer).CompactBlock(ctx, req.(*CompactBlockRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+var _QueryService_serviceDesc = grpc.ServiceDesc{
+ ServiceName: "penumbra.core.component.compact_block.v1.QueryService",
+ HandlerType: (*QueryServiceServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "CompactBlock",
+ Handler: _QueryService_CompactBlock_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{
+ {
+ StreamName: "CompactBlockRange",
+ Handler: _QueryService_CompactBlockRange_Handler,
+ ServerStreams: true,
+ },
+ },
+ Metadata: "penumbra/core/component/compact_block/v1/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.EpochIndex != 0 {
+ i = encodeVarintCompactBlock(dAtA, i, uint64(m.EpochIndex))
+ i--
+ dAtA[i] = 0x58
+ }
+ 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] = 0x52
+ }
+ if m.AppParametersUpdated {
+ i--
+ if m.AppParametersUpdated {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
+ }
+ i--
+ dAtA[i] = 0x48
+ }
+ 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] = 0x42
+ }
+ }
+ 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] = 0x3a
+ }
+ if m.ProposalStarted {
+ i--
+ if m.ProposalStarted {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
+ }
+ i--
+ dAtA[i] = 0x30
+ }
+ 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] = 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
+ }
+ 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 (m *CompactBlockRequest) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *CompactBlockRequest) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CompactBlockRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.Height != 0 {
+ i = encodeVarintCompactBlock(dAtA, i, uint64(m.Height))
+ i--
+ dAtA[i] = 0x8
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *CompactBlockResponse) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *CompactBlockResponse) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CompactBlockResponse) 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 m.EpochRoot != nil {
+ l = m.EpochRoot.Size()
+ n += 1 + l + sovCompactBlock(uint64(l))
+ }
+ if m.ProposalStarted {
+ n += 2
+ }
+ if m.FmdParameters != nil {
+ l = m.FmdParameters.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.EpochIndex != 0 {
+ n += 1 + sovCompactBlock(uint64(m.EpochIndex))
+ }
+ 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
+ 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 (m *CompactBlockRequest) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.Height != 0 {
+ n += 1 + sovCompactBlock(uint64(m.Height))
+ }
+ return n
+}
+
+func (m *CompactBlockResponse) 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, &v1.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 = &v11.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 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 = &v11.MerkleRoot{}
+ }
+ if err := m.EpochRoot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 6:
+ 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 7:
+ 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 = &v12.FmdParameters{}
+ }
+ if err := m.FmdParameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 8:
+ 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, &v13.BatchSwapOutputData{})
+ if err := m.SwapOutputs[len(m.SwapOutputs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 9:
+ 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 10:
+ 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 = &v14.GasPrices{}
+ }
+ if err := m.GasPrices.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 11:
+ 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 ErrIntOverflowCompactBlock
+ }
+ 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 := 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 = &v1.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 = &v11.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 = &v12.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 = &v13.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 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 (m *CompactBlockRequest) Unmarshal(dAtA []byte) 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: CompactBlockRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: CompactBlockRequest: 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
+ }
+ }
+ 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 *CompactBlockResponse) Unmarshal(dAtA []byte) 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: CompactBlockResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: CompactBlockResponse: 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/dex/v1/dex.pb.go b/relayer/chains/penumbra/core/component/dex/v1/dex.pb.go
new file mode 100644
index 000000000..d0e1a90e3
--- /dev/null
+++ b/relayer/chains/penumbra/core/component/dex/v1/dex.pb.go
@@ -0,0 +1,20087 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: penumbra/core/component/dex/v1/dex.proto
+
+package dexv1
+
+import (
+ context "context"
+ encoding_binary "encoding/binary"
+ fmt "fmt"
+ grpc1 "github.com/cosmos/gogoproto/grpc"
+ proto "github.com/cosmos/gogoproto/proto"
+ v14 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/asset/v1"
+ v11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/fee/v1"
+ v1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/sct/v1"
+ v17 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/shielded_pool/v1"
+ v15 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/keys/v1"
+ v13 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/num/v1"
+ v16 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/txhash/v1"
+ v12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/tct/v1"
+ 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.
+ //
+ // Positions can be withdrawn from multiple times, incrementing a sequence
+ // number each time.
+ PositionState_POSITION_STATE_ENUM_WITHDRAWN PositionState_PositionStateEnum = 3
+ // Deprecated.
+ PositionState_POSITION_STATE_ENUM_CLAIMED PositionState_PositionStateEnum = 4 // Deprecated: Do not use.
+)
+
+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_ec17dcdac15b4004, []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_ec17dcdac15b4004, []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_ec17dcdac15b4004, []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_ec17dcdac15b4004, []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_ec17dcdac15b4004, []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 *v1.Nullifier `protobuf:"bytes,1,opt,name=nullifier,proto3" json:"nullifier,omitempty"`
+ // The fee allows `SwapClaim` without an additional `Spend`.
+ Fee *v11.Fee `protobuf:"bytes,2,opt,name=fee,proto3" json:"fee,omitempty"`
+ // Note output for asset 1.
+ Output_1Commitment *v12.StateCommitment `protobuf:"bytes,3,opt,name=output_1_commitment,json=output1Commitment,proto3" json:"output_1_commitment,omitempty"`
+ // Note output for asset 2.
+ Output_2Commitment *v12.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_ec17dcdac15b4004, []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() *v1.Nullifier {
+ if m != nil {
+ return m.Nullifier
+ }
+ return nil
+}
+
+func (m *SwapClaimBody) GetFee() *v11.Fee {
+ if m != nil {
+ return m.Fee
+ }
+ return nil
+}
+
+func (m *SwapClaimBody) GetOutput_1Commitment() *v12.StateCommitment {
+ if m != nil {
+ return m.Output_1Commitment
+ }
+ return nil
+}
+
+func (m *SwapClaimBody) GetOutput_2Commitment() *v12.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 *v13.Amount `protobuf:"bytes,2,opt,name=delta_1_i,json=delta1I,proto3" json:"delta_1_i,omitempty"`
+ // The amount for asset 2.
+ Delta_2I *v13.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 *v14.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_ec17dcdac15b4004, []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() *v13.Amount {
+ if m != nil {
+ return m.Delta_1I
+ }
+ return nil
+}
+
+func (m *SwapBody) GetDelta_2I() *v13.Amount {
+ if m != nil {
+ return m.Delta_2I
+ }
+ return nil
+}
+
+func (m *SwapBody) GetFeeCommitment() *v14.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 *v12.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_ec17dcdac15b4004, []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() *v12.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 *v13.Amount `protobuf:"bytes,2,opt,name=delta_1_i,json=delta1I,proto3" json:"delta_1_i,omitempty"`
+ // Input amount of asset 2
+ Delta_2I *v13.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 *v11.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 *v15.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_ec17dcdac15b4004, []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() *v13.Amount {
+ if m != nil {
+ return m.Delta_1I
+ }
+ return nil
+}
+
+func (m *SwapPlaintext) GetDelta_2I() *v13.Amount {
+ if m != nil {
+ return m.Delta_2I
+ }
+ return nil
+}
+
+func (m *SwapPlaintext) GetClaimFee() *v11.Fee {
+ if m != nil {
+ return m.ClaimFee
+ }
+ return nil
+}
+
+func (m *SwapPlaintext) GetClaimAddress() *v15.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_ec17dcdac15b4004, []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_ec17dcdac15b4004, []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_ec17dcdac15b4004, []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 {
+ // The underlying Swap action being viewed.
+ Swap *Swap `protobuf:"bytes,1,opt,name=swap,proto3" json:"swap,omitempty"`
+ // The plaintext of the encrypted swap.
+ SwapPlaintext *SwapPlaintext `protobuf:"bytes,3,opt,name=swap_plaintext,json=swapPlaintext,proto3" json:"swap_plaintext,omitempty"`
+ // Optionally, a transaction hash for the transaction that claimed this
+ // swap.
+ //
+ // Presence of this field signals that the swap outputs have been claimed
+ // and that the claim transaction is known to the view server. Absence of
+ // this field does not indicate anything about the state of the swap.
+ //
+ // This field allows frontends to more easily crossreference the sequence of
+ // Swap/SwapClaim actions.
+ ClaimTx *v16.TransactionId `protobuf:"bytes,4,opt,name=claim_tx,json=claimTx,proto3" json:"claim_tx,omitempty"`
+ // Optionally, if the swap has been confirmed, the batch price it received.
+ //
+ // As soon as the swap is detected, the view server can in principle record
+ // the relevant BSOD and provide it as part of the view. This allows providing
+ // info about the execution of the swap.
+ BatchSwapOutputData *BatchSwapOutputData `protobuf:"bytes,20,opt,name=batch_swap_output_data,json=batchSwapOutputData,proto3" json:"batch_swap_output_data,omitempty"`
+ // Optionally, if the swap has been confirmed, the output note of asset 1.
+ //
+ // This is the note that will be minted by the SwapClaim action.
+ Output_1 *v17.NoteView `protobuf:"bytes,30,opt,name=output_1,json=output1,proto3" json:"output_1,omitempty"`
+ // Optionally, if the swap has been confirmed, the output note of asset 2.
+ //
+ // This is the note that will be minted by the SwapClaim action.
+ Output_2 *v17.NoteView `protobuf:"bytes,31,opt,name=output_2,json=output2,proto3" json:"output_2,omitempty"`
+ // Optionally, metadata about asset 1 in the `swap`'s trading pair.
+ Asset_1Metadata *v14.Metadata `protobuf:"bytes,40,opt,name=asset_1_metadata,json=asset1Metadata,proto3" json:"asset_1_metadata,omitempty"`
+ // Optionally, metadata about asset 2 in the `swap`'s trading pair.
+ Asset_2Metadata *v14.Metadata `protobuf:"bytes,41,opt,name=asset_2_metadata,json=asset2Metadata,proto3" json:"asset_2_metadata,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_ec17dcdac15b4004, []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
+}
+
+func (m *SwapView_Visible) GetClaimTx() *v16.TransactionId {
+ if m != nil {
+ return m.ClaimTx
+ }
+ return nil
+}
+
+func (m *SwapView_Visible) GetBatchSwapOutputData() *BatchSwapOutputData {
+ if m != nil {
+ return m.BatchSwapOutputData
+ }
+ return nil
+}
+
+func (m *SwapView_Visible) GetOutput_1() *v17.NoteView {
+ if m != nil {
+ return m.Output_1
+ }
+ return nil
+}
+
+func (m *SwapView_Visible) GetOutput_2() *v17.NoteView {
+ if m != nil {
+ return m.Output_2
+ }
+ return nil
+}
+
+func (m *SwapView_Visible) GetAsset_1Metadata() *v14.Metadata {
+ if m != nil {
+ return m.Asset_1Metadata
+ }
+ return nil
+}
+
+func (m *SwapView_Visible) GetAsset_2Metadata() *v14.Metadata {
+ if m != nil {
+ return m.Asset_2Metadata
+ }
+ 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_ec17dcdac15b4004, []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_ec17dcdac15b4004, []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 *v17.NoteView `protobuf:"bytes,2,opt,name=output_1,json=output1,proto3" json:"output_1,omitempty"`
+ Output_2 *v17.NoteView `protobuf:"bytes,3,opt,name=output_2,json=output2,proto3" json:"output_2,omitempty"`
+ // Optionally, a transaction hash for the transaction that created the swap
+ // this action claims.
+ //
+ // This field allows frontends to more easily crossreference the sequence of
+ // Swap/SwapClaim actions.
+ SwapTx *v16.TransactionId `protobuf:"bytes,4,opt,name=swap_tx,json=swapTx,proto3" json:"swap_tx,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_ec17dcdac15b4004, []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() *v17.NoteView {
+ if m != nil {
+ return m.Output_1
+ }
+ return nil
+}
+
+func (m *SwapClaimView_Visible) GetOutput_2() *v17.NoteView {
+ if m != nil {
+ return m.Output_2
+ }
+ return nil
+}
+
+func (m *SwapClaimView_Visible) GetSwapTx() *v16.TransactionId {
+ if m != nil {
+ return m.SwapTx
+ }
+ 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_ec17dcdac15b4004, []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 *v14.AssetId `protobuf:"bytes,1,opt,name=asset_1,json=asset1,proto3" json:"asset_1,omitempty"`
+ // The second asset of the pair.
+ Asset_2 *v14.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_ec17dcdac15b4004, []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() *v14.AssetId {
+ if m != nil {
+ return m.Asset_1
+ }
+ return nil
+}
+
+func (m *TradingPair) GetAsset_2() *v14.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 *v14.AssetId `protobuf:"bytes,1,opt,name=start,proto3" json:"start,omitempty"`
+ // The end asset of the pair.
+ End *v14.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_ec17dcdac15b4004, []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() *v14.AssetId {
+ if m != nil {
+ return m.Start
+ }
+ return nil
+}
+
+func (m *DirectedTradingPair) GetEnd() *v14.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 *v13.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 *v13.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 *v13.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 *v13.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 *v13.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 *v13.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_ec17dcdac15b4004, []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() *v13.Amount {
+ if m != nil {
+ return m.Delta_1
+ }
+ return nil
+}
+
+func (m *BatchSwapOutputData) GetDelta_2() *v13.Amount {
+ if m != nil {
+ return m.Delta_2
+ }
+ return nil
+}
+
+func (m *BatchSwapOutputData) GetLambda_1() *v13.Amount {
+ if m != nil {
+ return m.Lambda_1
+ }
+ return nil
+}
+
+func (m *BatchSwapOutputData) GetLambda_2() *v13.Amount {
+ if m != nil {
+ return m.Lambda_2
+ }
+ return nil
+}
+
+func (m *BatchSwapOutputData) GetUnfilled_1() *v13.Amount {
+ if m != nil {
+ return m.Unfilled_1
+ }
+ return nil
+}
+
+func (m *BatchSwapOutputData) GetUnfilled_2() *v13.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_ec17dcdac15b4004, []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 *v13.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 *v13.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_ec17dcdac15b4004, []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() *v13.Amount {
+ if m != nil {
+ return m.P
+ }
+ return nil
+}
+
+func (m *BareTradingFunction) GetQ() *v13.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 *v13.Amount `protobuf:"bytes,1,opt,name=r1,proto3" json:"r1,omitempty"`
+ R2 *v13.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_ec17dcdac15b4004, []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() *v13.Amount {
+ if m != nil {
+ return m.R1
+ }
+ return nil
+}
+
+func (m *Reserves) GetR2() *v13.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_ec17dcdac15b4004, []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_ec17dcdac15b4004, []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.v1.PositionState_PositionStateEnum" json:"state,omitempty"`
+ // Only meaningful if `state` is `POSITION_STATE_ENUM_WITHDRAWN`.
+ //
+ // The sequence number allows multiple withdrawals from the same position.
+ Sequence uint64 `protobuf:"varint,2,opt,name=sequence,proto3" json:"sequence,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_ec17dcdac15b4004, []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
+}
+
+func (m *PositionState) GetSequence() uint64 {
+ if m != nil {
+ return m.Sequence
+ }
+ return 0
+}
+
+// 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_ec17dcdac15b4004, []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_ec17dcdac15b4004, []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_ec17dcdac15b4004, []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 *v14.BalanceCommitment `protobuf:"bytes,2,opt,name=reserves_commitment,json=reservesCommitment,proto3" json:"reserves_commitment,omitempty"`
+ // The sequence number of the withdrawal.
+ //
+ // This allows multiple withdrawals from the same position, rather than a single reward claim.
+ Sequence uint64 `protobuf:"varint,3,opt,name=sequence,proto3" json:"sequence,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_ec17dcdac15b4004, []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() *v14.BalanceCommitment {
+ if m != nil {
+ return m.ReservesCommitment
+ }
+ return nil
+}
+
+func (m *PositionWithdraw) GetSequence() uint64 {
+ if m != nil {
+ return m.Sequence
+ }
+ return 0
+}
+
+// Deprecated.
+type PositionRewardClaim struct {
+ PositionId *PositionId `protobuf:"bytes,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"`
+ RewardsCommitment *v14.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_ec17dcdac15b4004, []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() *v14.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 *v14.Value `protobuf:"bytes,2,opt,name=input,proto3" json:"input,omitempty"`
+ // The total output amount for this execution.
+ Output *v14.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_ec17dcdac15b4004, []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() *v14.Value {
+ if m != nil {
+ return m.Input
+ }
+ return nil
+}
+
+func (m *SwapExecution) GetOutput() *v14.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 []*v14.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_ec17dcdac15b4004, []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() []*v14.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"`
+ // The sequence number of the withdrawal.
+ Sequence uint64 `protobuf:"varint,4,opt,name=sequence,proto3" json:"sequence,omitempty"`
+ // Any accumulated rewards assigned to this position.
+ Rewards []*v14.Value `protobuf:"bytes,5,rep,name=rewards,proto3" json:"rewards,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_ec17dcdac15b4004, []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
+}
+
+func (m *PositionWithdrawPlan) GetSequence() uint64 {
+ if m != nil {
+ return m.Sequence
+ }
+ return 0
+}
+
+func (m *PositionWithdrawPlan) GetRewards() []*v14.Value {
+ if m != nil {
+ return m.Rewards
+ }
+ return nil
+}
+
+// Deprecated.
+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_ec17dcdac15b4004, []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 {
+ 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_ec17dcdac15b4004, []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) 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_ec17dcdac15b4004, []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 {
+ 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_ec17dcdac15b4004, []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) 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_ec17dcdac15b4004, []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 {
+ 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_ec17dcdac15b4004, []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) 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_ec17dcdac15b4004, []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 {
+ // 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_ec17dcdac15b4004, []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) 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_ec17dcdac15b4004, []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 {
+ // 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_ec17dcdac15b4004, []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) 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_ec17dcdac15b4004, []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 {
+ // 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_ec17dcdac15b4004, []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) 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_ec17dcdac15b4004, []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 {
+ 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_ec17dcdac15b4004, []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) 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_ec17dcdac15b4004, []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 {
+ 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_ec17dcdac15b4004, []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) 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_ec17dcdac15b4004, []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 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_ec17dcdac15b4004, []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) 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_ec17dcdac15b4004, []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 {
+ 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_ec17dcdac15b4004, []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) 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_ec17dcdac15b4004, []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 *v14.Value `protobuf:"bytes,1,opt,name=input,proto3" json:"input,omitempty"`
+ Output *v14.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_ec17dcdac15b4004, []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() *v14.Value {
+ if m != nil {
+ return m.Input
+ }
+ return nil
+}
+
+func (m *SimulateTradeRequest) GetOutput() *v14.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_ec17dcdac15b4004, []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_ec17dcdac15b4004, []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_ec17dcdac15b4004, []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"`
+ // Estimated input amount that will not be swapped due to liquidity
+ Unfilled *v14.Value `protobuf:"bytes,2,opt,name=unfilled,proto3" json:"unfilled,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_ec17dcdac15b4004, []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
+}
+
+func (m *SimulateTradeResponse) GetUnfilled() *v14.Value {
+ if m != nil {
+ return m.Unfilled
+ }
+ 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 *v13.Amount `protobuf:"bytes,2,opt,name=delta_1_i,json=delta1I,proto3" json:"delta_1_i,omitempty"`
+ // The amount for asset 2.
+ Delta_2I *v13.Amount `protobuf:"bytes,3,opt,name=delta_2_i,json=delta2I,proto3" json:"delta_2_i,omitempty"`
+ // The swap commitment.
+ SwapCommitment *v12.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_ec17dcdac15b4004, []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() *v13.Amount {
+ if m != nil {
+ return m.Delta_1I
+ }
+ return nil
+}
+
+func (m *EventSwap) GetDelta_2I() *v13.Amount {
+ if m != nil {
+ return m.Delta_2I
+ }
+ return nil
+}
+
+func (m *EventSwap) GetSwapCommitment() *v12.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 *v12.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 *v12.StateCommitment `protobuf:"bytes,3,opt,name=output_2_commitment,json=output2Commitment,proto3" json:"output_2_commitment,omitempty"`
+ // The nullifier for the swap commitment.
+ Nullifier *v1.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_ec17dcdac15b4004, []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() *v12.StateCommitment {
+ if m != nil {
+ return m.Output_1Commitment
+ }
+ return nil
+}
+
+func (m *EventSwapClaim) GetOutput_2Commitment() *v12.StateCommitment {
+ if m != nil {
+ return m.Output_2Commitment
+ }
+ return nil
+}
+
+func (m *EventSwapClaim) GetNullifier() *v1.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 *v13.Amount `protobuf:"bytes,3,opt,name=reserves_1,json=reserves1,proto3" json:"reserves_1,omitempty"`
+ // The amount for asset 2.
+ Reserves_2 *v13.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_ec17dcdac15b4004, []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() *v13.Amount {
+ if m != nil {
+ return m.Reserves_1
+ }
+ return nil
+}
+
+func (m *EventPositionOpen) GetReserves_2() *v13.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_ec17dcdac15b4004, []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 *v13.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 *v13.Amount `protobuf:"bytes,4,opt,name=reserves_2,json=reserves2,proto3" json:"reserves_2,omitempty"`
+ // The sequence number of the withdrawal.
+ Sequence uint64 `protobuf:"varint,5,opt,name=sequence,proto3" json:"sequence,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_ec17dcdac15b4004, []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() *v13.Amount {
+ if m != nil {
+ return m.Reserves_1
+ }
+ return nil
+}
+
+func (m *EventPositionWithdraw) GetReserves_2() *v13.Amount {
+ if m != nil {
+ return m.Reserves_2
+ }
+ return nil
+}
+
+func (m *EventPositionWithdraw) GetSequence() uint64 {
+ if m != nil {
+ return m.Sequence
+ }
+ return 0
+}
+
+type EventPositionExecution struct {
+ // The ID of the position executed against.
+ PositionId *PositionId `protobuf:"bytes,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"`
+ // The trading pair of the position executed against.
+ TradingPair *TradingPair `protobuf:"bytes,2,opt,name=trading_pair,json=tradingPair,proto3" json:"trading_pair,omitempty"`
+ // The reserves of asset 1 of the position after execution.
+ Reserves_1 *v13.Amount `protobuf:"bytes,3,opt,name=reserves_1,json=reserves1,proto3" json:"reserves_1,omitempty"`
+ // The reserves of asset 2 of the position after execution.
+ Reserves_2 *v13.Amount `protobuf:"bytes,4,opt,name=reserves_2,json=reserves2,proto3" json:"reserves_2,omitempty"`
+ // The reserves of asset 1 of the position before execution.
+ PrevReserves_1 *v13.Amount `protobuf:"bytes,5,opt,name=prev_reserves_1,json=prevReserves1,proto3" json:"prev_reserves_1,omitempty"`
+ // The reserves of asset 2 of the position before execution.
+ PrevReserves_2 *v13.Amount `protobuf:"bytes,6,opt,name=prev_reserves_2,json=prevReserves2,proto3" json:"prev_reserves_2,omitempty"`
+ // Context: the end-to-end route that was being traversed during execution.
+ Context *DirectedTradingPair `protobuf:"bytes,7,opt,name=context,proto3" json:"context,omitempty"`
+}
+
+func (m *EventPositionExecution) Reset() { *m = EventPositionExecution{} }
+func (m *EventPositionExecution) String() string { return proto.CompactTextString(m) }
+func (*EventPositionExecution) ProtoMessage() {}
+func (*EventPositionExecution) Descriptor() ([]byte, []int) {
+ return fileDescriptor_ec17dcdac15b4004, []int{56}
+}
+func (m *EventPositionExecution) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *EventPositionExecution) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_EventPositionExecution.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *EventPositionExecution) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EventPositionExecution.Merge(m, src)
+}
+func (m *EventPositionExecution) XXX_Size() int {
+ return m.Size()
+}
+func (m *EventPositionExecution) XXX_DiscardUnknown() {
+ xxx_messageInfo_EventPositionExecution.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EventPositionExecution proto.InternalMessageInfo
+
+func (m *EventPositionExecution) GetPositionId() *PositionId {
+ if m != nil {
+ return m.PositionId
+ }
+ return nil
+}
+
+func (m *EventPositionExecution) GetTradingPair() *TradingPair {
+ if m != nil {
+ return m.TradingPair
+ }
+ return nil
+}
+
+func (m *EventPositionExecution) GetReserves_1() *v13.Amount {
+ if m != nil {
+ return m.Reserves_1
+ }
+ return nil
+}
+
+func (m *EventPositionExecution) GetReserves_2() *v13.Amount {
+ if m != nil {
+ return m.Reserves_2
+ }
+ return nil
+}
+
+func (m *EventPositionExecution) GetPrevReserves_1() *v13.Amount {
+ if m != nil {
+ return m.PrevReserves_1
+ }
+ return nil
+}
+
+func (m *EventPositionExecution) GetPrevReserves_2() *v13.Amount {
+ if m != nil {
+ return m.PrevReserves_2
+ }
+ return nil
+}
+
+func (m *EventPositionExecution) GetContext() *DirectedTradingPair {
+ if m != nil {
+ return m.Context
+ }
+ return nil
+}
+
+type EventBatchSwap struct {
+ // The BatchSwapOutputData containing the results of the batch swap.
+ BatchSwapOutputData *BatchSwapOutputData `protobuf:"bytes,1,opt,name=batch_swap_output_data,json=batchSwapOutputData,proto3" json:"batch_swap_output_data,omitempty"`
+ // The record of execution for the batch swap in the 1 -> 2 direction.
+ SwapExecution_1For_2 *SwapExecution `protobuf:"bytes,2,opt,name=swap_execution_1_for_2,json=swapExecution1For2,proto3" json:"swap_execution_1_for_2,omitempty"`
+ // The record of execution for the batch swap in the 2 -> 1 direction.
+ SwapExecution_2For_1 *SwapExecution `protobuf:"bytes,3,opt,name=swap_execution_2_for_1,json=swapExecution2For1,proto3" json:"swap_execution_2_for_1,omitempty"`
+}
+
+func (m *EventBatchSwap) Reset() { *m = EventBatchSwap{} }
+func (m *EventBatchSwap) String() string { return proto.CompactTextString(m) }
+func (*EventBatchSwap) ProtoMessage() {}
+func (*EventBatchSwap) Descriptor() ([]byte, []int) {
+ return fileDescriptor_ec17dcdac15b4004, []int{57}
+}
+func (m *EventBatchSwap) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *EventBatchSwap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_EventBatchSwap.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *EventBatchSwap) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EventBatchSwap.Merge(m, src)
+}
+func (m *EventBatchSwap) XXX_Size() int {
+ return m.Size()
+}
+func (m *EventBatchSwap) XXX_DiscardUnknown() {
+ xxx_messageInfo_EventBatchSwap.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EventBatchSwap proto.InternalMessageInfo
+
+func (m *EventBatchSwap) GetBatchSwapOutputData() *BatchSwapOutputData {
+ if m != nil {
+ return m.BatchSwapOutputData
+ }
+ return nil
+}
+
+func (m *EventBatchSwap) GetSwapExecution_1For_2() *SwapExecution {
+ if m != nil {
+ return m.SwapExecution_1For_2
+ }
+ return nil
+}
+
+func (m *EventBatchSwap) GetSwapExecution_2For_1() *SwapExecution {
+ if m != nil {
+ return m.SwapExecution_2For_1
+ }
+ return nil
+}
+
+type EventArbExecution struct {
+ // The height at which the arb execution occurred.
+ Height uint64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
+ // The record of execution for the arb execution.
+ SwapExecution *SwapExecution `protobuf:"bytes,2,opt,name=swap_execution,json=swapExecution,proto3" json:"swap_execution,omitempty"`
+}
+
+func (m *EventArbExecution) Reset() { *m = EventArbExecution{} }
+func (m *EventArbExecution) String() string { return proto.CompactTextString(m) }
+func (*EventArbExecution) ProtoMessage() {}
+func (*EventArbExecution) Descriptor() ([]byte, []int) {
+ return fileDescriptor_ec17dcdac15b4004, []int{58}
+}
+func (m *EventArbExecution) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *EventArbExecution) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_EventArbExecution.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *EventArbExecution) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EventArbExecution.Merge(m, src)
+}
+func (m *EventArbExecution) XXX_Size() int {
+ return m.Size()
+}
+func (m *EventArbExecution) XXX_DiscardUnknown() {
+ xxx_messageInfo_EventArbExecution.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EventArbExecution proto.InternalMessageInfo
+
+func (m *EventArbExecution) GetHeight() uint64 {
+ if m != nil {
+ return m.Height
+ }
+ return 0
+}
+
+func (m *EventArbExecution) GetSwapExecution() *SwapExecution {
+ if m != nil {
+ return m.SwapExecution
+ }
+ return nil
+}
+
+// Indicates that value was added to the DEX.
+type EventValueCircuitBreakerCredit struct {
+ // The asset ID being deposited into the DEX.
+ AssetId *v14.AssetId `protobuf:"bytes,1,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"`
+ // The previous balance of the asset in the DEX.
+ PreviousBalance *v13.Amount `protobuf:"bytes,2,opt,name=previous_balance,json=previousBalance,proto3" json:"previous_balance,omitempty"`
+ // The new balance of the asset in the DEX.
+ NewBalance *v13.Amount `protobuf:"bytes,3,opt,name=new_balance,json=newBalance,proto3" json:"new_balance,omitempty"`
+}
+
+func (m *EventValueCircuitBreakerCredit) Reset() { *m = EventValueCircuitBreakerCredit{} }
+func (m *EventValueCircuitBreakerCredit) String() string { return proto.CompactTextString(m) }
+func (*EventValueCircuitBreakerCredit) ProtoMessage() {}
+func (*EventValueCircuitBreakerCredit) Descriptor() ([]byte, []int) {
+ return fileDescriptor_ec17dcdac15b4004, []int{59}
+}
+func (m *EventValueCircuitBreakerCredit) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *EventValueCircuitBreakerCredit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_EventValueCircuitBreakerCredit.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *EventValueCircuitBreakerCredit) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EventValueCircuitBreakerCredit.Merge(m, src)
+}
+func (m *EventValueCircuitBreakerCredit) XXX_Size() int {
+ return m.Size()
+}
+func (m *EventValueCircuitBreakerCredit) XXX_DiscardUnknown() {
+ xxx_messageInfo_EventValueCircuitBreakerCredit.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EventValueCircuitBreakerCredit proto.InternalMessageInfo
+
+func (m *EventValueCircuitBreakerCredit) GetAssetId() *v14.AssetId {
+ if m != nil {
+ return m.AssetId
+ }
+ return nil
+}
+
+func (m *EventValueCircuitBreakerCredit) GetPreviousBalance() *v13.Amount {
+ if m != nil {
+ return m.PreviousBalance
+ }
+ return nil
+}
+
+func (m *EventValueCircuitBreakerCredit) GetNewBalance() *v13.Amount {
+ if m != nil {
+ return m.NewBalance
+ }
+ return nil
+}
+
+// Indicates that value is leaving the DEX.
+type EventValueCircuitBreakerDebit struct {
+ // The asset ID being deposited into the DEX.
+ AssetId *v14.AssetId `protobuf:"bytes,1,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"`
+ // The previous balance of the asset in the DEX.
+ PreviousBalance *v13.Amount `protobuf:"bytes,2,opt,name=previous_balance,json=previousBalance,proto3" json:"previous_balance,omitempty"`
+ // The new balance of the asset in the DEX.
+ NewBalance *v13.Amount `protobuf:"bytes,3,opt,name=new_balance,json=newBalance,proto3" json:"new_balance,omitempty"`
+}
+
+func (m *EventValueCircuitBreakerDebit) Reset() { *m = EventValueCircuitBreakerDebit{} }
+func (m *EventValueCircuitBreakerDebit) String() string { return proto.CompactTextString(m) }
+func (*EventValueCircuitBreakerDebit) ProtoMessage() {}
+func (*EventValueCircuitBreakerDebit) Descriptor() ([]byte, []int) {
+ return fileDescriptor_ec17dcdac15b4004, []int{60}
+}
+func (m *EventValueCircuitBreakerDebit) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *EventValueCircuitBreakerDebit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_EventValueCircuitBreakerDebit.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *EventValueCircuitBreakerDebit) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EventValueCircuitBreakerDebit.Merge(m, src)
+}
+func (m *EventValueCircuitBreakerDebit) XXX_Size() int {
+ return m.Size()
+}
+func (m *EventValueCircuitBreakerDebit) XXX_DiscardUnknown() {
+ xxx_messageInfo_EventValueCircuitBreakerDebit.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EventValueCircuitBreakerDebit proto.InternalMessageInfo
+
+func (m *EventValueCircuitBreakerDebit) GetAssetId() *v14.AssetId {
+ if m != nil {
+ return m.AssetId
+ }
+ return nil
+}
+
+func (m *EventValueCircuitBreakerDebit) GetPreviousBalance() *v13.Amount {
+ if m != nil {
+ return m.PreviousBalance
+ }
+ return nil
+}
+
+func (m *EventValueCircuitBreakerDebit) GetNewBalance() *v13.Amount {
+ if m != nil {
+ return m.NewBalance
+ }
+ return nil
+}
+
+type DexParameters struct {
+ // Whether or not the DEX is enabled.
+ IsEnabled bool `protobuf:"varint,1,opt,name=is_enabled,json=isEnabled,proto3" json:"is_enabled,omitempty"`
+ // The list of fixed candidates for routing.
+ FixedCandidates []*v14.AssetId `protobuf:"bytes,2,rep,name=fixed_candidates,json=fixedCandidates,proto3" json:"fixed_candidates,omitempty"`
+ // The number of hops to traverse while routing from A to B.
+ MaxHops uint32 `protobuf:"varint,3,opt,name=max_hops,json=maxHops,proto3" json:"max_hops,omitempty"`
+}
+
+func (m *DexParameters) Reset() { *m = DexParameters{} }
+func (m *DexParameters) String() string { return proto.CompactTextString(m) }
+func (*DexParameters) ProtoMessage() {}
+func (*DexParameters) Descriptor() ([]byte, []int) {
+ return fileDescriptor_ec17dcdac15b4004, []int{61}
+}
+func (m *DexParameters) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *DexParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_DexParameters.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *DexParameters) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_DexParameters.Merge(m, src)
+}
+func (m *DexParameters) XXX_Size() int {
+ return m.Size()
+}
+func (m *DexParameters) XXX_DiscardUnknown() {
+ xxx_messageInfo_DexParameters.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DexParameters proto.InternalMessageInfo
+
+func (m *DexParameters) GetIsEnabled() bool {
+ if m != nil {
+ return m.IsEnabled
+ }
+ return false
+}
+
+func (m *DexParameters) GetFixedCandidates() []*v14.AssetId {
+ if m != nil {
+ return m.FixedCandidates
+ }
+ return nil
+}
+
+func (m *DexParameters) GetMaxHops() uint32 {
+ if m != nil {
+ return m.MaxHops
+ }
+ return 0
+}
+
+type GenesisContent struct {
+ // The initial parameters for the DEX.
+ DexParams *DexParameters `protobuf:"bytes,1,opt,name=dex_params,json=dexParams,proto3" json:"dex_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_ec17dcdac15b4004, []int{62}
+}
+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) GetDexParams() *DexParameters {
+ if m != nil {
+ return m.DexParams
+ }
+ return nil
+}
+
+func init() {
+ proto.RegisterEnum("penumbra.core.component.dex.v1.PositionState_PositionStateEnum", PositionState_PositionStateEnum_name, PositionState_PositionStateEnum_value)
+ proto.RegisterType((*ZKSwapProof)(nil), "penumbra.core.component.dex.v1.ZKSwapProof")
+ proto.RegisterType((*ZKSwapClaimProof)(nil), "penumbra.core.component.dex.v1.ZKSwapClaimProof")
+ proto.RegisterType((*Swap)(nil), "penumbra.core.component.dex.v1.Swap")
+ proto.RegisterType((*SwapClaim)(nil), "penumbra.core.component.dex.v1.SwapClaim")
+ proto.RegisterType((*SwapClaimBody)(nil), "penumbra.core.component.dex.v1.SwapClaimBody")
+ proto.RegisterType((*SwapBody)(nil), "penumbra.core.component.dex.v1.SwapBody")
+ proto.RegisterType((*SwapPayload)(nil), "penumbra.core.component.dex.v1.SwapPayload")
+ proto.RegisterType((*SwapPlaintext)(nil), "penumbra.core.component.dex.v1.SwapPlaintext")
+ proto.RegisterType((*SwapPlan)(nil), "penumbra.core.component.dex.v1.SwapPlan")
+ proto.RegisterType((*SwapClaimPlan)(nil), "penumbra.core.component.dex.v1.SwapClaimPlan")
+ proto.RegisterType((*SwapView)(nil), "penumbra.core.component.dex.v1.SwapView")
+ proto.RegisterType((*SwapView_Visible)(nil), "penumbra.core.component.dex.v1.SwapView.Visible")
+ proto.RegisterType((*SwapView_Opaque)(nil), "penumbra.core.component.dex.v1.SwapView.Opaque")
+ proto.RegisterType((*SwapClaimView)(nil), "penumbra.core.component.dex.v1.SwapClaimView")
+ proto.RegisterType((*SwapClaimView_Visible)(nil), "penumbra.core.component.dex.v1.SwapClaimView.Visible")
+ proto.RegisterType((*SwapClaimView_Opaque)(nil), "penumbra.core.component.dex.v1.SwapClaimView.Opaque")
+ proto.RegisterType((*TradingPair)(nil), "penumbra.core.component.dex.v1.TradingPair")
+ proto.RegisterType((*DirectedTradingPair)(nil), "penumbra.core.component.dex.v1.DirectedTradingPair")
+ proto.RegisterType((*BatchSwapOutputData)(nil), "penumbra.core.component.dex.v1.BatchSwapOutputData")
+ proto.RegisterType((*TradingFunction)(nil), "penumbra.core.component.dex.v1.TradingFunction")
+ proto.RegisterType((*BareTradingFunction)(nil), "penumbra.core.component.dex.v1.BareTradingFunction")
+ proto.RegisterType((*Reserves)(nil), "penumbra.core.component.dex.v1.Reserves")
+ proto.RegisterType((*Position)(nil), "penumbra.core.component.dex.v1.Position")
+ proto.RegisterType((*PositionId)(nil), "penumbra.core.component.dex.v1.PositionId")
+ proto.RegisterType((*PositionState)(nil), "penumbra.core.component.dex.v1.PositionState")
+ proto.RegisterType((*LpNft)(nil), "penumbra.core.component.dex.v1.LpNft")
+ proto.RegisterType((*PositionOpen)(nil), "penumbra.core.component.dex.v1.PositionOpen")
+ proto.RegisterType((*PositionClose)(nil), "penumbra.core.component.dex.v1.PositionClose")
+ proto.RegisterType((*PositionWithdraw)(nil), "penumbra.core.component.dex.v1.PositionWithdraw")
+ proto.RegisterType((*PositionRewardClaim)(nil), "penumbra.core.component.dex.v1.PositionRewardClaim")
+ proto.RegisterType((*SwapExecution)(nil), "penumbra.core.component.dex.v1.SwapExecution")
+ proto.RegisterType((*SwapExecution_Trace)(nil), "penumbra.core.component.dex.v1.SwapExecution.Trace")
+ proto.RegisterType((*PositionWithdrawPlan)(nil), "penumbra.core.component.dex.v1.PositionWithdrawPlan")
+ proto.RegisterType((*PositionRewardClaimPlan)(nil), "penumbra.core.component.dex.v1.PositionRewardClaimPlan")
+ proto.RegisterType((*BatchSwapOutputDataRequest)(nil), "penumbra.core.component.dex.v1.BatchSwapOutputDataRequest")
+ proto.RegisterType((*BatchSwapOutputDataResponse)(nil), "penumbra.core.component.dex.v1.BatchSwapOutputDataResponse")
+ proto.RegisterType((*SwapExecutionRequest)(nil), "penumbra.core.component.dex.v1.SwapExecutionRequest")
+ proto.RegisterType((*SwapExecutionResponse)(nil), "penumbra.core.component.dex.v1.SwapExecutionResponse")
+ proto.RegisterType((*ArbExecutionRequest)(nil), "penumbra.core.component.dex.v1.ArbExecutionRequest")
+ proto.RegisterType((*ArbExecutionResponse)(nil), "penumbra.core.component.dex.v1.ArbExecutionResponse")
+ proto.RegisterType((*SwapExecutionsRequest)(nil), "penumbra.core.component.dex.v1.SwapExecutionsRequest")
+ proto.RegisterType((*SwapExecutionsResponse)(nil), "penumbra.core.component.dex.v1.SwapExecutionsResponse")
+ proto.RegisterType((*ArbExecutionsRequest)(nil), "penumbra.core.component.dex.v1.ArbExecutionsRequest")
+ proto.RegisterType((*ArbExecutionsResponse)(nil), "penumbra.core.component.dex.v1.ArbExecutionsResponse")
+ proto.RegisterType((*LiquidityPositionsRequest)(nil), "penumbra.core.component.dex.v1.LiquidityPositionsRequest")
+ proto.RegisterType((*LiquidityPositionsResponse)(nil), "penumbra.core.component.dex.v1.LiquidityPositionsResponse")
+ proto.RegisterType((*LiquidityPositionByIdRequest)(nil), "penumbra.core.component.dex.v1.LiquidityPositionByIdRequest")
+ proto.RegisterType((*LiquidityPositionByIdResponse)(nil), "penumbra.core.component.dex.v1.LiquidityPositionByIdResponse")
+ proto.RegisterType((*LiquidityPositionsByIdRequest)(nil), "penumbra.core.component.dex.v1.LiquidityPositionsByIdRequest")
+ proto.RegisterType((*LiquidityPositionsByIdResponse)(nil), "penumbra.core.component.dex.v1.LiquidityPositionsByIdResponse")
+ proto.RegisterType((*LiquidityPositionsByPriceRequest)(nil), "penumbra.core.component.dex.v1.LiquidityPositionsByPriceRequest")
+ proto.RegisterType((*LiquidityPositionsByPriceResponse)(nil), "penumbra.core.component.dex.v1.LiquidityPositionsByPriceResponse")
+ proto.RegisterType((*SpreadRequest)(nil), "penumbra.core.component.dex.v1.SpreadRequest")
+ proto.RegisterType((*SpreadResponse)(nil), "penumbra.core.component.dex.v1.SpreadResponse")
+ proto.RegisterType((*SimulateTradeRequest)(nil), "penumbra.core.component.dex.v1.SimulateTradeRequest")
+ proto.RegisterType((*SimulateTradeRequest_Routing)(nil), "penumbra.core.component.dex.v1.SimulateTradeRequest.Routing")
+ proto.RegisterType((*SimulateTradeRequest_Routing_SingleHop)(nil), "penumbra.core.component.dex.v1.SimulateTradeRequest.Routing.SingleHop")
+ proto.RegisterType((*SimulateTradeRequest_Routing_Default)(nil), "penumbra.core.component.dex.v1.SimulateTradeRequest.Routing.Default")
+ proto.RegisterType((*SimulateTradeResponse)(nil), "penumbra.core.component.dex.v1.SimulateTradeResponse")
+ proto.RegisterType((*EventSwap)(nil), "penumbra.core.component.dex.v1.EventSwap")
+ proto.RegisterType((*EventSwapClaim)(nil), "penumbra.core.component.dex.v1.EventSwapClaim")
+ proto.RegisterType((*EventPositionOpen)(nil), "penumbra.core.component.dex.v1.EventPositionOpen")
+ proto.RegisterType((*EventPositionClose)(nil), "penumbra.core.component.dex.v1.EventPositionClose")
+ proto.RegisterType((*EventPositionWithdraw)(nil), "penumbra.core.component.dex.v1.EventPositionWithdraw")
+ proto.RegisterType((*EventPositionExecution)(nil), "penumbra.core.component.dex.v1.EventPositionExecution")
+ proto.RegisterType((*EventBatchSwap)(nil), "penumbra.core.component.dex.v1.EventBatchSwap")
+ proto.RegisterType((*EventArbExecution)(nil), "penumbra.core.component.dex.v1.EventArbExecution")
+ proto.RegisterType((*EventValueCircuitBreakerCredit)(nil), "penumbra.core.component.dex.v1.EventValueCircuitBreakerCredit")
+ proto.RegisterType((*EventValueCircuitBreakerDebit)(nil), "penumbra.core.component.dex.v1.EventValueCircuitBreakerDebit")
+ proto.RegisterType((*DexParameters)(nil), "penumbra.core.component.dex.v1.DexParameters")
+ proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.dex.v1.GenesisContent")
+}
+
+func init() {
+ proto.RegisterFile("penumbra/core/component/dex/v1/dex.proto", fileDescriptor_ec17dcdac15b4004)
+}
+
+var fileDescriptor_ec17dcdac15b4004 = []byte{
+ // 3392 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5b, 0x6f, 0x6c, 0xdb, 0xd6,
+ 0xb5, 0x37, 0x29, 0xd9, 0x92, 0x8e, 0x6c, 0xc7, 0xb9, 0x4e, 0xf2, 0x5c, 0xb5, 0x71, 0x12, 0xa6,
+ 0x7d, 0x2f, 0xed, 0x7b, 0x95, 0x2b, 0xa6, 0x79, 0x6d, 0x9d, 0xf4, 0xa5, 0xb6, 0x24, 0xc7, 0x6e,
+ 0x13, 0x5b, 0xa5, 0x5d, 0xa7, 0x08, 0xf2, 0xca, 0x47, 0x89, 0x57, 0x31, 0x51, 0x89, 0x64, 0x48,
+ 0x4a, 0x96, 0x81, 0xf7, 0x07, 0x05, 0xde, 0x3a, 0x60, 0xc3, 0x86, 0x6e, 0xd8, 0x30, 0xf4, 0xe3,
+ 0x0a, 0xec, 0xcb, 0xbe, 0x6d, 0xc0, 0xbe, 0x6d, 0x58, 0xbf, 0x6c, 0x18, 0x3a, 0x60, 0x28, 0xf6,
+ 0x61, 0x1d, 0x30, 0x60, 0x18, 0x92, 0x01, 0x03, 0x06, 0x0c, 0x18, 0xb0, 0x0f, 0xfb, 0xb2, 0x0f,
+ 0xc3, 0xbd, 0xbc, 0xa4, 0x48, 0x99, 0xb2, 0x28, 0x59, 0x41, 0x81, 0x60, 0x5f, 0x12, 0xf1, 0xf2,
+ 0x9c, 0xdf, 0x3d, 0xe7, 0xdc, 0x73, 0xce, 0x3d, 0xf7, 0xf0, 0x1a, 0x2e, 0x99, 0x58, 0x6f, 0x35,
+ 0xab, 0x96, 0xb2, 0x54, 0x33, 0x2c, 0xbc, 0x54, 0x33, 0x9a, 0xa6, 0xa1, 0x63, 0xdd, 0x59, 0x52,
+ 0x71, 0x67, 0xa9, 0x5d, 0x20, 0xff, 0xe5, 0x4d, 0xcb, 0x70, 0x0c, 0xb4, 0xe8, 0x51, 0xe6, 0x09,
+ 0x65, 0xde, 0xa7, 0xcc, 0x13, 0x92, 0x76, 0x21, 0x27, 0x84, 0x91, 0x14, 0xdb, 0xc6, 0x0e, 0x41,
+ 0xa0, 0x3f, 0x5c, 0x8c, 0x5c, 0xdf, 0xd9, 0xea, 0x18, 0x13, 0xda, 0x3a, 0xc6, 0x83, 0x28, 0xed,
+ 0x1a, 0x45, 0xb5, 0x6b, 0x1e, 0xe6, 0xb5, 0xbe, 0x94, 0x7b, 0x1a, 0x6e, 0xa8, 0x58, 0x95, 0x4d,
+ 0xc3, 0x68, 0x50, 0x9e, 0xe0, 0x00, 0xe3, 0x3e, 0x1f, 0xe6, 0x7e, 0x17, 0x1f, 0xd8, 0x84, 0x94,
+ 0xfc, 0xcf, 0x28, 0x16, 0xc3, 0x14, 0x7a, 0xab, 0x49, 0x08, 0xf4, 0x56, 0x93, 0xbd, 0x7f, 0x3a,
+ 0xfc, 0xde, 0xe9, 0xec, 0x29, 0xf6, 0x1e, 0x21, 0x71, 0x7f, 0x1d, 0x9e, 0xc7, 0x3a, 0x30, 0x1d,
+ 0x63, 0xc9, 0x71, 0xf5, 0x70, 0x3c, 0x3d, 0x84, 0x8b, 0x90, 0xbd, 0xf3, 0xc6, 0xf6, 0xbe, 0x62,
+ 0x56, 0x2c, 0xc3, 0xa8, 0xa3, 0x53, 0x30, 0xa9, 0xe9, 0x3a, 0xb6, 0x16, 0xb8, 0xf3, 0xdc, 0xa5,
+ 0x69, 0xc9, 0x7d, 0x10, 0x2e, 0xc1, 0x9c, 0x4b, 0x54, 0x6c, 0x28, 0x5a, 0xf3, 0x28, 0xca, 0x2f,
+ 0x72, 0x90, 0x24, 0x84, 0x68, 0x05, 0x26, 0x4d, 0x42, 0x47, 0x5f, 0x67, 0xc5, 0x7f, 0xcd, 0x1f,
+ 0xbd, 0x8e, 0xf9, 0x80, 0x10, 0x92, 0xcb, 0x89, 0xae, 0x41, 0xb2, 0x6a, 0xa8, 0x07, 0x0b, 0x49,
+ 0x8a, 0x70, 0x69, 0x10, 0x02, 0xe1, 0x5f, 0x35, 0xd4, 0x03, 0x89, 0x72, 0x09, 0x3f, 0xe2, 0x20,
+ 0xe3, 0x8b, 0x8c, 0xd6, 0xc2, 0xe2, 0xbc, 0x10, 0x4f, 0x9c, 0xae, 0xba, 0x9e, 0x4c, 0x2b, 0x4c,
+ 0x26, 0x9e, 0xc2, 0x3c, 0x1f, 0x47, 0x26, 0x0a, 0xd2, 0x15, 0x0c, 0x3d, 0x03, 0xb3, 0xd8, 0x34,
+ 0x6a, 0x7b, 0xb2, 0xda, 0xb2, 0x14, 0x47, 0x33, 0xf4, 0x85, 0xd4, 0x79, 0xee, 0x52, 0x52, 0x9a,
+ 0xa1, 0xa3, 0x25, 0x36, 0x28, 0x7c, 0x2b, 0x01, 0x33, 0x21, 0x76, 0x74, 0x03, 0x32, 0x7a, 0xab,
+ 0xd1, 0xd0, 0xea, 0x1a, 0xb3, 0x7a, 0x56, 0x7c, 0xb6, 0xaf, 0x00, 0xc4, 0x53, 0xdb, 0x85, 0xfc,
+ 0xa6, 0xc7, 0x20, 0x75, 0x79, 0xd1, 0x15, 0x48, 0xd4, 0x31, 0x66, 0x3a, 0x5c, 0xec, 0x0b, 0x41,
+ 0xc2, 0xa2, 0x5d, 0xc8, 0xaf, 0x61, 0x2c, 0x11, 0x7a, 0x74, 0x1b, 0xe6, 0x8d, 0x96, 0x63, 0xb6,
+ 0x1c, 0xb9, 0x20, 0xd7, 0x8c, 0x66, 0x53, 0x73, 0x9a, 0x58, 0x77, 0x16, 0x12, 0x14, 0xe6, 0x5f,
+ 0x02, 0x30, 0xd4, 0xd5, 0xf2, 0x8e, 0x2b, 0xc1, 0xb6, 0xa3, 0x38, 0xb8, 0xe8, 0x93, 0x4b, 0x27,
+ 0x5d, 0x8c, 0x42, 0x77, 0x28, 0x00, 0x2c, 0x06, 0x81, 0x93, 0x23, 0x01, 0x8b, 0x01, 0xe0, 0x1d,
+ 0xc8, 0x32, 0x60, 0x55, 0x71, 0x94, 0x85, 0x29, 0x0a, 0x78, 0x79, 0xd0, 0xa2, 0xad, 0x2a, 0x4e,
+ 0x6d, 0x8f, 0x98, 0x7e, 0x8b, 0xf2, 0x96, 0x14, 0x47, 0x91, 0xc0, 0xf0, 0x7f, 0x0b, 0x7f, 0xe0,
+ 0x21, 0xed, 0x39, 0x1b, 0xda, 0x84, 0x69, 0xc7, 0x52, 0x54, 0x4d, 0xbf, 0x27, 0x9b, 0x8a, 0x66,
+ 0xc5, 0x75, 0xf7, 0x1d, 0x97, 0xa7, 0xa2, 0x68, 0x96, 0x94, 0x75, 0xba, 0x0f, 0xe8, 0x65, 0xc8,
+ 0xa8, 0xb8, 0xe1, 0x28, 0x72, 0x41, 0xd6, 0xd8, 0x0a, 0x3d, 0xd5, 0x03, 0x46, 0x92, 0x40, 0xbb,
+ 0x90, 0x5f, 0x69, 0x1a, 0x2d, 0xdd, 0x91, 0x52, 0x94, 0xbc, 0xb0, 0xd1, 0xe5, 0x14, 0x65, 0x8d,
+ 0x2d, 0x4a, 0x1c, 0x4e, 0x71, 0x03, 0x55, 0x60, 0xb6, 0x8e, 0xf1, 0x61, 0xd3, 0xf7, 0x7a, 0x97,
+ 0x9b, 0x53, 0xa9, 0x85, 0x1a, 0x8a, 0x5e, 0x0b, 0x1a, 0x7f, 0xa6, 0x8e, 0x03, 0x8f, 0xa8, 0x0c,
+ 0x29, 0x53, 0x39, 0x68, 0x18, 0x8a, 0xba, 0x30, 0x19, 0xcf, 0x20, 0x34, 0xfa, 0x5d, 0x16, 0xc9,
+ 0xe3, 0x15, 0xfe, 0x07, 0xb2, 0x81, 0x71, 0x74, 0x03, 0x20, 0x20, 0x23, 0x37, 0x9c, 0x7b, 0x04,
+ 0x58, 0x69, 0x08, 0xea, 0x94, 0x1c, 0xab, 0xb2, 0xbd, 0xaf, 0x98, 0xd4, 0xd2, 0xd3, 0xd2, 0x8c,
+ 0x3f, 0x4a, 0xa6, 0x15, 0xfe, 0xcc, 0xbb, 0x21, 0x58, 0x69, 0x28, 0x9a, 0xee, 0xe0, 0x8e, 0xf3,
+ 0x58, 0xac, 0xf6, 0x6b, 0x90, 0xa9, 0x91, 0x9c, 0x22, 0x93, 0x1c, 0x90, 0x8c, 0x9f, 0x03, 0xd2,
+ 0x94, 0x6b, 0x0d, 0x63, 0x54, 0x84, 0x19, 0x17, 0x41, 0x51, 0x55, 0x0b, 0xdb, 0x36, 0x5b, 0xe3,
+ 0xc5, 0x1e, 0x14, 0xba, 0x9b, 0x11, 0x01, 0x5c, 0x2a, 0x69, 0x9a, 0x32, 0xb1, 0x27, 0xb2, 0x7f,
+ 0x58, 0x36, 0xc6, 0x2a, 0x8d, 0xca, 0x69, 0xc9, 0x7d, 0x10, 0x3e, 0xe3, 0xdc, 0xd8, 0xaa, 0x34,
+ 0x14, 0x1d, 0xed, 0xc0, 0x2c, 0x59, 0x1c, 0xd9, 0xf4, 0xec, 0xcf, 0xec, 0x1d, 0x2b, 0xed, 0xfa,
+ 0x8b, 0x26, 0xcd, 0xd8, 0xa1, 0x35, 0xbc, 0x00, 0xd3, 0xc4, 0xdb, 0xab, 0x0d, 0x4d, 0x27, 0xeb,
+ 0xc0, 0x96, 0x3e, 0x5b, 0xc7, 0x78, 0x95, 0x0d, 0xa1, 0x4b, 0x30, 0x47, 0xd3, 0xbd, 0x4f, 0x24,
+ 0x5b, 0xd4, 0xc6, 0xd3, 0xd2, 0x2c, 0x1d, 0xf7, 0x08, 0xa5, 0x08, 0x4a, 0x9b, 0xda, 0xb4, 0x97,
+ 0x72, 0x5b, 0xf8, 0x25, 0x1f, 0xc8, 0xe7, 0x8f, 0x50, 0xbd, 0x1c, 0xa4, 0x4d, 0xc3, 0xd6, 0xe8,
+ 0xc6, 0xc2, 0xd3, 0x8d, 0xc5, 0x7f, 0xee, 0xcd, 0x87, 0x89, 0xb1, 0xe4, 0xc3, 0x88, 0x0d, 0x2d,
+ 0x19, 0xb1, 0xa1, 0x45, 0x1a, 0x75, 0x32, 0xb6, 0x51, 0xa7, 0x22, 0x8d, 0xfa, 0x97, 0x29, 0xd7,
+ 0x5d, 0x76, 0x35, 0xbc, 0x8f, 0x6e, 0x42, 0xaa, 0xad, 0xd9, 0x5a, 0xb5, 0x81, 0xe3, 0xee, 0xf2,
+ 0x1e, 0x6b, 0x7e, 0xd7, 0xe5, 0x5b, 0x9f, 0x90, 0x3c, 0x08, 0xb4, 0x01, 0x53, 0x86, 0xa9, 0xdc,
+ 0x6f, 0x79, 0xfb, 0xe4, 0x52, 0x6c, 0xb0, 0x2d, 0xca, 0xb6, 0x3e, 0x21, 0x31, 0x80, 0xdc, 0xdf,
+ 0x92, 0x90, 0x62, 0x33, 0xa0, 0x97, 0x21, 0x49, 0x13, 0x8e, 0x2b, 0xe1, 0xd3, 0x71, 0x40, 0x25,
+ 0xca, 0x11, 0xe1, 0x2e, 0x89, 0x31, 0xb8, 0xcb, 0x0a, 0xb8, 0x71, 0x2d, 0x3b, 0x1d, 0x96, 0x0c,
+ 0xfe, 0xb9, 0x07, 0x8f, 0x15, 0x94, 0x6e, 0x1a, 0xd3, 0x6d, 0xa5, 0x46, 0x56, 0x73, 0x43, 0x95,
+ 0x52, 0x94, 0x6f, 0xa7, 0x83, 0xf6, 0xe0, 0x4c, 0x95, 0xb8, 0x08, 0xcd, 0xa4, 0x72, 0xd0, 0xc1,
+ 0x4e, 0x8d, 0xee, 0x60, 0xf3, 0xd5, 0xc3, 0x83, 0xe8, 0x16, 0xa4, 0xbd, 0x0a, 0x64, 0x61, 0x91,
+ 0x62, 0x8b, 0xfd, 0x0b, 0xa0, 0x50, 0xd9, 0x4d, 0x4a, 0x21, 0xc3, 0xc1, 0x64, 0x7d, 0xa4, 0x14,
+ 0xab, 0x40, 0x02, 0x70, 0xe2, 0xc2, 0xb9, 0xe3, 0xc2, 0x89, 0xe8, 0x75, 0x98, 0xa3, 0x3b, 0xa4,
+ 0x5c, 0x90, 0x9b, 0xd8, 0x51, 0xa8, 0x05, 0x2e, 0x51, 0xd8, 0xf3, 0xfd, 0x36, 0xd2, 0x5b, 0x8c,
+ 0x4e, 0x9a, 0xa5, 0x43, 0x05, 0xef, 0xb9, 0x8b, 0x25, 0x76, 0xb1, 0x9e, 0x1d, 0x0a, 0x4b, 0xf4,
+ 0x9e, 0x73, 0xab, 0x30, 0xe5, 0xba, 0xe4, 0xe8, 0xce, 0xb7, 0x9a, 0x85, 0x0c, 0x5d, 0xdd, 0xb6,
+ 0x86, 0xf7, 0x85, 0x5f, 0x24, 0x03, 0xa9, 0x8c, 0x86, 0xde, 0x9b, 0xbd, 0xa1, 0x77, 0x25, 0x76,
+ 0x65, 0xdc, 0x2f, 0xfe, 0x36, 0x7b, 0xe2, 0xef, 0xc5, 0xe1, 0x10, 0x0f, 0x05, 0xe1, 0xf7, 0xf9,
+ 0x6e, 0x10, 0xae, 0x03, 0x50, 0x6d, 0xa8, 0x07, 0x0f, 0x2c, 0xa5, 0x7b, 0xf1, 0x25, 0x6a, 0x0a,
+ 0xf7, 0x5c, 0x11, 0xf4, 0x48, 0x7e, 0xbc, 0x1e, 0x99, 0x38, 0xbe, 0x47, 0x5e, 0x87, 0x14, 0xd5,
+ 0x73, 0xe8, 0xd8, 0x9e, 0x22, 0x6c, 0x3b, 0x9d, 0x9c, 0xe4, 0xbb, 0xce, 0xd8, 0x4c, 0xb6, 0x7a,
+ 0x12, 0x4e, 0x74, 0x91, 0x5c, 0x87, 0x7a, 0x8f, 0x83, 0xec, 0x4e, 0xa8, 0x2c, 0x4a, 0xb1, 0x48,
+ 0x62, 0x33, 0x9d, 0xeb, 0xe7, 0xf4, 0x2b, 0xe4, 0x07, 0x11, 0xd8, 0x8d, 0x9f, 0x2e, 0xa7, 0xc8,
+ 0x96, 0x23, 0x26, 0xa7, 0x28, 0xfc, 0x1f, 0xcc, 0x97, 0x34, 0x0b, 0xd7, 0x1c, 0xac, 0x06, 0x45,
+ 0xb9, 0x02, 0x93, 0xb6, 0xa3, 0x58, 0x4e, 0x5c, 0x41, 0x5c, 0x6a, 0x54, 0x80, 0x04, 0xd6, 0xd5,
+ 0xb8, 0x32, 0x10, 0x5a, 0xe1, 0xcb, 0x49, 0x98, 0x8f, 0xc8, 0x84, 0xe8, 0x0a, 0xa4, 0x58, 0x8d,
+ 0xc8, 0x64, 0x38, 0xba, 0xce, 0x9b, 0x72, 0x2b, 0xc4, 0x2e, 0x9b, 0x18, 0xab, 0xb0, 0x74, 0xd9,
+ 0x44, 0xf4, 0x12, 0xa4, 0x1b, 0x4a, 0xb3, 0xaa, 0x92, 0xe9, 0x62, 0x95, 0x95, 0x2e, 0x75, 0x21,
+ 0xc0, 0x28, 0x32, 0x67, 0x8b, 0xc5, 0x28, 0xa2, 0xab, 0x00, 0x2d, 0xbd, 0xae, 0x35, 0x1a, 0x58,
+ 0x95, 0x0b, 0xac, 0x94, 0x3c, 0x9a, 0x35, 0xe3, 0xd1, 0x17, 0x42, 0xcc, 0x22, 0x3b, 0xe0, 0xc5,
+ 0x64, 0x16, 0xd1, 0x19, 0x98, 0xda, 0xc3, 0xda, 0xbd, 0x3d, 0x87, 0x9d, 0xc0, 0xd9, 0xd3, 0xa1,
+ 0x2a, 0x3f, 0x7d, 0xcc, 0x2a, 0x5f, 0x84, 0xd3, 0x6e, 0x81, 0x44, 0x7d, 0x83, 0xc0, 0xb2, 0x69,
+ 0x33, 0x74, 0xda, 0x79, 0xfa, 0x72, 0x9b, 0xbd, 0x5b, 0xa7, 0xaf, 0x84, 0xef, 0x70, 0x70, 0x82,
+ 0x01, 0xae, 0xb5, 0x74, 0x1a, 0x97, 0xe8, 0x4d, 0xc8, 0xf8, 0x93, 0x32, 0x5f, 0x88, 0xb1, 0xb7,
+ 0x5a, 0xb8, 0x07, 0x47, 0xea, 0xa2, 0xa0, 0xeb, 0x90, 0xa4, 0x2a, 0xf2, 0xc3, 0xab, 0x48, 0x19,
+ 0x49, 0xd8, 0x44, 0x4c, 0x81, 0xe6, 0xdc, 0x16, 0x03, 0x11, 0x72, 0xc6, 0xed, 0x1e, 0x3c, 0x07,
+ 0x9c, 0x19, 0xcb, 0x13, 0x39, 0x93, 0xd0, 0xde, 0x8f, 0xe5, 0x7d, 0xdc, 0x7d, 0xa1, 0x0e, 0x69,
+ 0x09, 0xdb, 0xd8, 0x6a, 0x63, 0x1b, 0xfd, 0x1b, 0xf0, 0x56, 0xbc, 0x28, 0xe1, 0xad, 0x02, 0xa5,
+ 0x8e, 0x17, 0x1c, 0xbc, 0x25, 0x0a, 0x5f, 0xe7, 0x21, 0x5d, 0xf1, 0x0a, 0xe9, 0x15, 0x48, 0x98,
+ 0x7b, 0x1a, 0x9b, 0x69, 0x29, 0xa6, 0xd5, 0x7c, 0xfb, 0x13, 0x5e, 0x72, 0xfe, 0xd1, 0x0d, 0xbd,
+ 0x86, 0xd9, 0xf9, 0xc3, 0x7d, 0x40, 0x45, 0x9a, 0x6e, 0x1c, 0x1c, 0xb7, 0xb6, 0xf3, 0x24, 0xa2,
+ 0xa7, 0x5d, 0xc9, 0xe5, 0x45, 0x25, 0x48, 0x5b, 0xcc, 0x24, 0x71, 0x9b, 0x67, 0x9e, 0x09, 0x25,
+ 0x9f, 0x13, 0x09, 0xe4, 0x94, 0x67, 0xd8, 0x58, 0x36, 0x74, 0x99, 0x44, 0x0c, 0x0d, 0xcd, 0xb4,
+ 0x94, 0xa5, 0x83, 0x5b, 0xfa, 0x9a, 0xd6, 0x68, 0x08, 0x45, 0x00, 0x4f, 0x82, 0x0d, 0x35, 0xba,
+ 0x25, 0x88, 0xce, 0x41, 0x56, 0x69, 0x38, 0x72, 0x15, 0xd7, 0xf6, 0x2e, 0x8b, 0x4d, 0xaa, 0x6e,
+ 0x46, 0x02, 0xa5, 0xe1, 0xac, 0xba, 0x23, 0xc2, 0x4f, 0x78, 0x98, 0x09, 0xe9, 0x81, 0xde, 0xf2,
+ 0xac, 0x40, 0x80, 0x66, 0xc5, 0xeb, 0x43, 0x59, 0x21, 0xfc, 0x54, 0xd6, 0x5b, 0x4d, 0xcf, 0x2e,
+ 0x39, 0x48, 0xdb, 0xf8, 0x7e, 0x0b, 0x7b, 0x56, 0x4f, 0x4a, 0xfe, 0xb3, 0xf0, 0x31, 0x07, 0x27,
+ 0x0f, 0x31, 0xa2, 0x8b, 0x70, 0xae, 0xb2, 0xb5, 0xbd, 0xb1, 0xb3, 0xb1, 0xb5, 0x29, 0x6f, 0xef,
+ 0xac, 0xec, 0x94, 0xe5, 0xf2, 0xe6, 0x5b, 0xb7, 0xe4, 0xb7, 0x36, 0xb7, 0x2b, 0xe5, 0xe2, 0xc6,
+ 0xda, 0x46, 0xb9, 0x34, 0x37, 0x81, 0x16, 0x21, 0x17, 0x45, 0xb4, 0x55, 0x29, 0x6f, 0x96, 0x4b,
+ 0x73, 0x5c, 0xbf, 0xf7, 0xc5, 0x9b, 0x5b, 0xdb, 0xe5, 0xd2, 0x1c, 0x8f, 0x2e, 0xc0, 0xd9, 0xa8,
+ 0xf7, 0xb7, 0x37, 0x76, 0xd6, 0x4b, 0xd2, 0xca, 0xed, 0xcd, 0xb9, 0x04, 0xba, 0x08, 0x4f, 0x46,
+ 0x43, 0xac, 0x6c, 0xdc, 0x2a, 0x97, 0xe6, 0x92, 0x39, 0x3e, 0xcd, 0x09, 0x1f, 0x72, 0x30, 0x79,
+ 0xd3, 0xdc, 0xac, 0x3b, 0xe8, 0x0d, 0xc8, 0x7a, 0x67, 0x3e, 0x59, 0x53, 0x99, 0x9b, 0x3e, 0x17,
+ 0xd7, 0x8a, 0x1b, 0xaa, 0x04, 0x66, 0x77, 0x55, 0x7d, 0x97, 0xe4, 0x47, 0x77, 0x49, 0x61, 0x07,
+ 0xa6, 0xbd, 0xf1, 0x2d, 0x13, 0xeb, 0xc4, 0x45, 0xfd, 0x53, 0x2a, 0x17, 0xcf, 0x45, 0x3d, 0xfe,
+ 0xee, 0x79, 0x56, 0xb8, 0xdb, 0x75, 0x9c, 0x22, 0xf1, 0xca, 0xb1, 0x2a, 0x2e, 0x7c, 0xc6, 0xc1,
+ 0x9c, 0xf7, 0xea, 0xb6, 0xe6, 0xec, 0xa9, 0x96, 0xb2, 0x3f, 0x5e, 0xd3, 0xde, 0x81, 0x79, 0x2f,
+ 0xdc, 0x82, 0xdd, 0x37, 0x7e, 0xd8, 0xee, 0x1b, 0xf2, 0x50, 0x02, 0x2d, 0xb8, 0xa0, 0xb3, 0x27,
+ 0x7a, 0x9c, 0xfd, 0x87, 0x1c, 0xcc, 0xfb, 0xe6, 0xc4, 0xfb, 0x8a, 0xa5, 0xba, 0xd5, 0xec, 0x58,
+ 0x95, 0x7b, 0x1b, 0x90, 0x45, 0xb1, 0x8f, 0xa7, 0xdb, 0x49, 0x06, 0xd2, 0x1d, 0x12, 0xde, 0x67,
+ 0xad, 0x94, 0x72, 0x07, 0xd7, 0x5a, 0x34, 0x1f, 0xbf, 0x01, 0x53, 0x8e, 0xa5, 0xd4, 0xb0, 0xbd,
+ 0xc0, 0x9d, 0x4f, 0xc4, 0xd9, 0x16, 0x43, 0xec, 0x24, 0x41, 0xd7, 0xb0, 0xc4, 0x20, 0xd0, 0x65,
+ 0x92, 0xc6, 0xcc, 0x96, 0x27, 0xeb, 0xd9, 0x7e, 0xb2, 0xee, 0x2a, 0x8d, 0x16, 0x96, 0x5c, 0x5a,
+ 0x74, 0x05, 0xa6, 0xdc, 0xaa, 0x9b, 0x65, 0xee, 0x01, 0x5c, 0x8c, 0x38, 0x77, 0x0d, 0x26, 0xe9,
+ 0xe4, 0x64, 0xd2, 0x36, 0x79, 0xc3, 0x14, 0x18, 0x34, 0x29, 0xa5, 0x15, 0x7e, 0xcc, 0xc3, 0xa9,
+ 0x5e, 0x0f, 0xa5, 0xad, 0xa5, 0xe0, 0x0e, 0xc0, 0x8d, 0xbc, 0x03, 0xf4, 0xb8, 0x03, 0x7f, 0x2c,
+ 0x77, 0xf0, 0x2a, 0x8d, 0xc4, 0x88, 0x95, 0x46, 0xc8, 0xa1, 0x93, 0x61, 0x87, 0x46, 0x2f, 0x41,
+ 0x8a, 0xb9, 0xc9, 0xc2, 0x64, 0x1c, 0xfb, 0x79, 0xd4, 0x82, 0x0c, 0xff, 0x14, 0x11, 0x08, 0xe3,
+ 0xb3, 0xa1, 0xf0, 0xff, 0x1c, 0xe4, 0xa2, 0xfa, 0x1b, 0x44, 0x72, 0xdb, 0x09, 0x94, 0xa0, 0xfc,
+ 0x91, 0x25, 0x68, 0xe2, 0x78, 0x25, 0xa8, 0x50, 0x87, 0x27, 0x23, 0xa5, 0xb0, 0x4d, 0x43, 0xb7,
+ 0x31, 0xba, 0x01, 0x49, 0xda, 0x62, 0xe0, 0x46, 0x6f, 0xd8, 0x50, 0x00, 0xe1, 0x7d, 0x0e, 0x4e,
+ 0x85, 0x62, 0x6b, 0x90, 0xa2, 0xbb, 0x91, 0x8a, 0x0e, 0x94, 0x20, 0xe2, 0xa8, 0x16, 0x56, 0xb8,
+ 0x09, 0xa7, 0x7b, 0xe4, 0x60, 0xaa, 0x7a, 0x6d, 0x34, 0xec, 0xbd, 0x19, 0xa6, 0xeb, 0xda, 0x85,
+ 0xa3, 0x6d, 0x34, 0xff, 0x51, 0x78, 0x1e, 0xe6, 0x57, 0xac, 0x6a, 0x5c, 0xad, 0x89, 0x57, 0x9c,
+ 0x0a, 0xd3, 0x3f, 0x4a, 0xe9, 0xfa, 0x8a, 0xf1, 0x3d, 0xae, 0xc7, 0x4a, 0xb6, 0x27, 0xf8, 0x05,
+ 0x98, 0xa6, 0x87, 0x15, 0x39, 0xc4, 0x97, 0xa5, 0x63, 0xee, 0x09, 0x05, 0x9d, 0x05, 0xc0, 0xba,
+ 0xea, 0x11, 0xb8, 0x5b, 0x4c, 0x06, 0xeb, 0xea, 0x7a, 0xf4, 0xc2, 0x26, 0xc7, 0xb4, 0xb0, 0xbf,
+ 0xe5, 0xe0, 0x4c, 0xaf, 0xcc, 0x9f, 0x87, 0xf1, 0x1e, 0x99, 0xe7, 0xbe, 0x1d, 0x76, 0x8d, 0xf1,
+ 0x2d, 0x89, 0xf0, 0x05, 0x0e, 0x4e, 0xf7, 0x40, 0x7f, 0x2e, 0x6e, 0xb7, 0x0a, 0x4f, 0xdc, 0xd4,
+ 0xee, 0xb7, 0x34, 0x55, 0x73, 0x0e, 0xbc, 0xec, 0xeb, 0xab, 0xf9, 0x0c, 0xcc, 0x6a, 0x7a, 0xad,
+ 0xd1, 0x52, 0xb1, 0x4c, 0x4f, 0x1a, 0x2a, 0xf5, 0x9c, 0xb4, 0x34, 0xc3, 0x46, 0x69, 0xa1, 0xa7,
+ 0x0a, 0x77, 0x20, 0x17, 0x85, 0xc1, 0xf4, 0xb9, 0x16, 0xca, 0x67, 0xf1, 0x4b, 0x4b, 0x37, 0x89,
+ 0xbd, 0x0b, 0x4f, 0x1d, 0xc2, 0x5e, 0x3d, 0xd8, 0x50, 0x3d, 0x11, 0xc7, 0xb9, 0x2f, 0x0a, 0xff,
+ 0x09, 0x67, 0xfb, 0x4c, 0x36, 0x16, 0x5d, 0x1a, 0x11, 0xf0, 0xf6, 0x91, 0xca, 0x24, 0x8e, 0xa1,
+ 0xcc, 0x3b, 0xb0, 0xd8, 0x6f, 0xb6, 0xb1, 0x68, 0xf3, 0x01, 0x07, 0xe7, 0xa3, 0x26, 0xa8, 0x58,
+ 0x5a, 0x0d, 0x7b, 0x1a, 0xf5, 0x06, 0x26, 0x3f, 0x9e, 0xc0, 0x24, 0xc7, 0xdb, 0x86, 0xd6, 0xd4,
+ 0x1c, 0x7a, 0x10, 0x4e, 0x4a, 0xee, 0x83, 0xa0, 0xc0, 0x85, 0x23, 0x24, 0x1a, 0x8b, 0xd6, 0x32,
+ 0xcc, 0x6c, 0x9b, 0x16, 0x56, 0xfc, 0x35, 0xdb, 0x8c, 0xd4, 0x70, 0xf4, 0xea, 0xe0, 0xa7, 0x3c,
+ 0xcc, 0x7a, 0x33, 0x30, 0x89, 0xdf, 0x86, 0x53, 0x55, 0x6c, 0x3b, 0x72, 0x41, 0x76, 0x0c, 0x59,
+ 0x94, 0x47, 0x3e, 0xac, 0xcd, 0x11, 0x94, 0xc2, 0x8e, 0x21, 0xfa, 0xbd, 0x13, 0x0f, 0x59, 0x24,
+ 0xc8, 0x05, 0x39, 0xf4, 0xb1, 0x72, 0x68, 0x64, 0x71, 0xc7, 0x28, 0xf8, 0xc8, 0xd7, 0xe1, 0xac,
+ 0x62, 0x9a, 0x96, 0xd1, 0x91, 0x71, 0xbd, 0x8e, 0x6b, 0x8e, 0xd6, 0xc6, 0xb2, 0x49, 0xd6, 0x81,
+ 0x69, 0x41, 0x33, 0x22, 0x27, 0x2d, 0xb8, 0x44, 0x65, 0x8f, 0x86, 0x2e, 0x15, 0x11, 0xf1, 0x08,
+ 0x00, 0x57, 0x58, 0x9a, 0x8a, 0xfa, 0x00, 0x10, 0x49, 0x84, 0x5f, 0x25, 0xe0, 0xd4, 0xb6, 0xd6,
+ 0x6c, 0x35, 0x14, 0x87, 0xb6, 0xc4, 0x7c, 0x9f, 0xf4, 0xcf, 0x14, 0xdc, 0x10, 0x67, 0x8a, 0x97,
+ 0xfc, 0x33, 0x45, 0xdc, 0x5e, 0xb6, 0x4b, 0x8e, 0x76, 0x21, 0x65, 0x19, 0x2d, 0x47, 0xd3, 0xef,
+ 0xb1, 0x5d, 0xe9, 0xda, 0xc0, 0x3c, 0x1e, 0x21, 0x74, 0x5e, 0x72, 0x31, 0x24, 0x0f, 0x2c, 0xf7,
+ 0x57, 0x0e, 0x52, 0x6c, 0x10, 0xfd, 0x17, 0xa4, 0x54, 0x5c, 0x57, 0x5a, 0x0d, 0x4f, 0xa7, 0xd2,
+ 0x71, 0xe6, 0xc8, 0x97, 0x5c, 0xac, 0xf5, 0x09, 0xc9, 0x83, 0x45, 0xf7, 0x00, 0x6c, 0x4d, 0xbf,
+ 0xd7, 0xc0, 0xf2, 0x9e, 0xe1, 0xb5, 0x0e, 0xd7, 0x8e, 0x35, 0xc9, 0x36, 0x85, 0x5b, 0x37, 0xcc,
+ 0xf5, 0x09, 0x29, 0x63, 0x7b, 0x0f, 0xb9, 0x2c, 0x64, 0xfc, 0x37, 0xb9, 0x0c, 0xa4, 0x98, 0x2c,
+ 0xab, 0x19, 0x48, 0xd9, 0xd8, 0x21, 0x9c, 0xc2, 0x87, 0xa4, 0x52, 0x0a, 0x43, 0xb3, 0x40, 0x29,
+ 0xfb, 0x8b, 0x34, 0xd2, 0x96, 0xe9, 0x2d, 0xd9, 0x2b, 0x90, 0xf6, 0x1a, 0xd3, 0xf1, 0xce, 0x9d,
+ 0x3e, 0xb9, 0xf0, 0x6d, 0x1e, 0x32, 0xe5, 0x36, 0xd6, 0x1d, 0x7a, 0xf1, 0xee, 0xf1, 0xb8, 0x90,
+ 0xc4, 0x3e, 0x11, 0x8d, 0x7c, 0x19, 0x8c, 0x96, 0x33, 0x81, 0x96, 0xc1, 0x6f, 0x78, 0x98, 0xf5,
+ 0x6d, 0xe4, 0x36, 0x3b, 0xc6, 0x6d, 0xa8, 0x3e, 0xd7, 0xe3, 0xf8, 0x47, 0x75, 0x3d, 0x2e, 0x71,
+ 0xec, 0xeb, 0x71, 0xa1, 0x0b, 0x85, 0xc9, 0xd1, 0x2f, 0x14, 0x0a, 0x3f, 0xe7, 0xe1, 0x24, 0xb5,
+ 0x6e, 0xa8, 0xc7, 0x37, 0xd6, 0x6e, 0xd2, 0x98, 0xb7, 0x3c, 0x74, 0x15, 0xc0, 0x6f, 0xbd, 0xc5,
+ 0xfb, 0xd2, 0x95, 0xf1, 0xe8, 0x0b, 0x21, 0xe6, 0x78, 0x5f, 0xbb, 0x7c, 0x66, 0x11, 0x9d, 0x03,
+ 0x4f, 0x10, 0x7a, 0x03, 0x6b, 0x92, 0x7e, 0x22, 0x01, 0x36, 0xb4, 0x86, 0xb1, 0xa0, 0x00, 0x0a,
+ 0x19, 0xf3, 0x11, 0xb4, 0x36, 0x3f, 0xe1, 0xe1, 0x74, 0x68, 0x8e, 0x47, 0xd3, 0xdf, 0x7c, 0x7c,
+ 0x16, 0x2d, 0xd8, 0x7c, 0x9a, 0xec, 0xe9, 0xa6, 0x7e, 0x29, 0x09, 0x67, 0x42, 0xc6, 0x0c, 0xf6,
+ 0x25, 0xff, 0x61, 0xcd, 0x08, 0x6b, 0x96, 0xe0, 0x84, 0x69, 0xe1, 0xb6, 0x1c, 0x98, 0x3e, 0xce,
+ 0x77, 0xdf, 0x19, 0xc2, 0x24, 0xf9, 0x22, 0x1c, 0x42, 0x89, 0xf7, 0x01, 0x38, 0x84, 0x22, 0xa2,
+ 0x5b, 0x90, 0xaa, 0x19, 0xee, 0x7d, 0xaa, 0xd4, 0xe8, 0x07, 0x05, 0x0f, 0x43, 0xf8, 0xd8, 0xdb,
+ 0x68, 0xfc, 0x1e, 0xd9, 0x11, 0xf7, 0xa3, 0xb8, 0x31, 0xdf, 0x8f, 0x52, 0xe0, 0x4c, 0xf8, 0x18,
+ 0x2f, 0x17, 0xe4, 0xba, 0x61, 0xf9, 0x57, 0x00, 0x86, 0xac, 0x4d, 0x50, 0xe8, 0x38, 0x5f, 0x58,
+ 0x33, 0x2c, 0x31, 0x62, 0x0a, 0x91, 0x4e, 0x51, 0x18, 0xe6, 0x36, 0x5a, 0xbf, 0x29, 0xc4, 0x35,
+ 0xc3, 0x2a, 0x08, 0xef, 0x71, 0x6c, 0x37, 0x09, 0xf6, 0x2a, 0x02, 0xcd, 0x04, 0x2e, 0xd4, 0x86,
+ 0x39, 0xdc, 0xba, 0xe0, 0xc7, 0xd0, 0xcf, 0xfb, 0x3d, 0x07, 0x8b, 0x54, 0x06, 0x5a, 0x6c, 0x15,
+ 0x35, 0xab, 0xd6, 0xd2, 0x9c, 0x55, 0x0b, 0x2b, 0xef, 0x62, 0xab, 0x68, 0x61, 0x55, 0x73, 0xd0,
+ 0x32, 0xa4, 0xdd, 0xab, 0x26, 0x7e, 0x60, 0x0f, 0xac, 0xcf, 0xdd, 0xbb, 0x29, 0x1b, 0x2a, 0xba,
+ 0x01, 0x73, 0xc4, 0x0b, 0x35, 0xa3, 0x65, 0xcb, 0x55, 0xf7, 0x93, 0x47, 0xac, 0xda, 0xea, 0x84,
+ 0xc7, 0xc5, 0xbe, 0x93, 0xa0, 0x57, 0x21, 0xab, 0xe3, 0x7d, 0x1f, 0x23, 0x4e, 0x10, 0x83, 0x8e,
+ 0xf7, 0x19, 0xbb, 0xf0, 0x90, 0x83, 0xb3, 0xfd, 0xd4, 0x2c, 0xe1, 0xea, 0x63, 0xa2, 0xe5, 0x37,
+ 0x39, 0x98, 0x29, 0xe1, 0x4e, 0x45, 0xb1, 0x94, 0x26, 0x76, 0xb0, 0x65, 0xa3, 0xb3, 0x00, 0x9a,
+ 0x2d, 0x63, 0x5d, 0xa9, 0x92, 0x7a, 0x9b, 0xa3, 0x0d, 0xa6, 0x8c, 0x66, 0x97, 0xdd, 0x01, 0xf4,
+ 0x3a, 0xcc, 0xd5, 0xb5, 0x0e, 0x56, 0xe5, 0x9a, 0xa2, 0xab, 0x9a, 0xaa, 0x38, 0xd8, 0x66, 0x8d,
+ 0x91, 0x81, 0xca, 0x9f, 0xa0, 0x8c, 0x45, 0x9f, 0x0f, 0x3d, 0x01, 0xe9, 0xa6, 0xd2, 0x21, 0x47,
+ 0x18, 0x9b, 0x0a, 0x3e, 0x23, 0xa5, 0x9a, 0x4a, 0x67, 0xdd, 0x30, 0x6d, 0xe1, 0x1d, 0x98, 0xbd,
+ 0x81, 0x75, 0x6c, 0x6b, 0x76, 0x91, 0x64, 0x0f, 0xdd, 0x41, 0x37, 0x01, 0x54, 0xdc, 0x91, 0x4d,
+ 0x22, 0xa9, 0x1d, 0xf7, 0x40, 0x11, 0x52, 0x4d, 0xca, 0xa8, 0xec, 0xd1, 0x16, 0xff, 0x04, 0x30,
+ 0xfd, 0x66, 0x0b, 0x5b, 0x07, 0xdb, 0xd8, 0x6a, 0x6b, 0x35, 0x8c, 0xbe, 0xca, 0x45, 0x5f, 0x31,
+ 0x5a, 0x1e, 0x25, 0x03, 0xb9, 0x67, 0xab, 0xdc, 0xd5, 0x91, 0x78, 0xd9, 0xe1, 0xe9, 0xbf, 0x7b,
+ 0x3f, 0xe4, 0xbd, 0x38, 0x5c, 0xd4, 0x32, 0x19, 0xae, 0x0c, 0xc9, 0xc5, 0x66, 0x3f, 0x80, 0xe9,
+ 0x50, 0x8a, 0x19, 0x98, 0x88, 0x23, 0x5a, 0xfc, 0xb9, 0x17, 0x87, 0x63, 0x62, 0x53, 0xbf, 0xc7,
+ 0xc1, 0x6c, 0xb8, 0x8b, 0x8d, 0x86, 0x53, 0xc2, 0xeb, 0x97, 0xe6, 0xfe, 0x7d, 0x58, 0x36, 0x57,
+ 0x82, 0x17, 0x38, 0xf4, 0xbf, 0x30, 0x13, 0xea, 0x06, 0xa3, 0xa1, 0x54, 0xb1, 0x63, 0x1b, 0x3f,
+ 0xb2, 0xe5, 0xfc, 0x02, 0x87, 0xbe, 0xc2, 0x01, 0x3a, 0xdc, 0x3a, 0x43, 0xaf, 0x0c, 0xc2, 0xeb,
+ 0xdb, 0x3b, 0xce, 0x2d, 0x8f, 0xc2, 0xea, 0xcb, 0xf3, 0x0d, 0x0e, 0x4e, 0x47, 0xb6, 0x62, 0xd1,
+ 0xb5, 0xa1, 0x71, 0x03, 0x1d, 0xd6, 0xdc, 0xab, 0x23, 0x72, 0x33, 0x57, 0xf9, 0x90, 0x83, 0x33,
+ 0xd1, 0x4d, 0x55, 0x34, 0x3c, 0x72, 0xb0, 0xf5, 0x9b, 0xfb, 0x8f, 0x51, 0xd9, 0x7d, 0x93, 0x7d,
+ 0xc4, 0x45, 0xb5, 0xf2, 0x59, 0xf7, 0x13, 0xbd, 0x36, 0x0a, 0x7e, 0xb0, 0x95, 0x9b, 0x5b, 0x39,
+ 0x06, 0x82, 0x2f, 0xe4, 0x3d, 0x98, 0x72, 0x9b, 0x9b, 0x68, 0x70, 0x4d, 0x10, 0x6c, 0xb3, 0xe6,
+ 0xf2, 0x71, 0xc9, 0xdd, 0xa9, 0xc4, 0xaf, 0x71, 0x70, 0x92, 0x35, 0x89, 0x34, 0x43, 0xf7, 0x92,
+ 0x2e, 0xc9, 0x71, 0xc1, 0xce, 0x51, 0x8c, 0x1c, 0x17, 0xd1, 0xc3, 0x8a, 0x91, 0xe3, 0xa2, 0xda,
+ 0x53, 0xab, 0x3f, 0xe0, 0x7f, 0xf6, 0x60, 0x91, 0xfb, 0xf4, 0xc1, 0x22, 0xf7, 0xbb, 0x07, 0x8b,
+ 0xdc, 0x07, 0x0f, 0x17, 0x27, 0x3e, 0x7d, 0xb8, 0x38, 0xf1, 0xeb, 0x87, 0x8b, 0x13, 0x20, 0xd4,
+ 0x8c, 0xe6, 0x00, 0xd0, 0xd5, 0x34, 0xd9, 0x5c, 0x2c, 0xc3, 0x31, 0x2a, 0xdc, 0x9d, 0xca, 0x3d,
+ 0xcd, 0xd9, 0x6b, 0x55, 0x09, 0xd1, 0x52, 0xcd, 0xb0, 0x9b, 0x86, 0xbd, 0x64, 0xe1, 0x86, 0x72,
+ 0x80, 0xad, 0xa5, 0xb6, 0xe8, 0xff, 0xac, 0xed, 0x29, 0x9a, 0x6e, 0x2f, 0x1d, 0xfd, 0x07, 0xbe,
+ 0x57, 0x55, 0xdc, 0x69, 0x17, 0x3e, 0xe2, 0x93, 0x95, 0x62, 0xb1, 0xf4, 0x5d, 0x7e, 0xb1, 0xe2,
+ 0x49, 0x51, 0x24, 0x52, 0x14, 0x7d, 0x29, 0x4a, 0xb8, 0x93, 0xdf, 0x2d, 0x7c, 0xd2, 0x25, 0xb8,
+ 0x4b, 0x08, 0xee, 0xfa, 0x04, 0x77, 0x4b, 0xb8, 0x73, 0x77, 0xb7, 0xf0, 0x80, 0x7f, 0xee, 0x68,
+ 0x82, 0xbb, 0x37, 0x2a, 0xab, 0xde, 0x7d, 0xf8, 0x3f, 0xf2, 0x82, 0x47, 0xbc, 0xbc, 0x4c, 0xa8,
+ 0xc9, 0xbf, 0x8c, 0x7c, 0x79, 0xb9, 0x84, 0x3b, 0xcb, 0xcb, 0xbb, 0x85, 0xea, 0x14, 0xfd, 0xf3,
+ 0xd8, 0xcb, 0x7f, 0x0f, 0x00, 0x00, 0xff, 0xff, 0xe1, 0x5a, 0x64, 0xb3, 0xaa, 0x3c, 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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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/v1/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.v1.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.v1.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.v1.SimulationService",
+ HandlerType: (*SimulationServiceServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "SimulateTrade",
+ Handler: _SimulationService_SimulateTrade_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "penumbra/core/component/dex/v1/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.Asset_2Metadata != nil {
+ {
+ size, err := m.Asset_2Metadata.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintDex(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x2
+ i--
+ dAtA[i] = 0xca
+ }
+ if m.Asset_1Metadata != nil {
+ {
+ size, err := m.Asset_1Metadata.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintDex(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x2
+ i--
+ dAtA[i] = 0xc2
+ }
+ 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] = 0x1
+ i--
+ dAtA[i] = 0xfa
+ }
+ 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] = 0x1
+ i--
+ dAtA[i] = 0xf2
+ }
+ if m.BatchSwapOutputData != nil {
+ {
+ size, err := m.BatchSwapOutputData.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintDex(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0xa2
+ }
+ if m.ClaimTx != nil {
+ {
+ size, err := m.ClaimTx.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintDex(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 = 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.SwapTx != nil {
+ {
+ size, err := m.SwapTx.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintDex(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x22
+ }
+ 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.Sequence != 0 {
+ i = encodeVarintDex(dAtA, i, uint64(m.Sequence))
+ i--
+ dAtA[i] = 0x10
+ }
+ 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.Sequence != 0 {
+ i = encodeVarintDex(dAtA, i, uint64(m.Sequence))
+ i--
+ dAtA[i] = 0x18
+ }
+ 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 len(m.Rewards) > 0 {
+ for iNdEx := len(m.Rewards) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Rewards[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintDex(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x2a
+ }
+ }
+ if m.Sequence != 0 {
+ i = encodeVarintDex(dAtA, i, uint64(m.Sequence))
+ i--
+ dAtA[i] = 0x20
+ }
+ 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
+ }
+ 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
+ }
+ 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
+ }
+ 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
+ }
+ 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
+ }
+ 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
+ }
+ 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
+ }
+ 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
+ }
+ }
+ 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
+ }
+ 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
+ }
+ 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.Unfilled != nil {
+ {
+ size, err := m.Unfilled.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintDex(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 = 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.Sequence != 0 {
+ i = encodeVarintDex(dAtA, i, uint64(m.Sequence))
+ 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 *EventPositionExecution) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *EventPositionExecution) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EventPositionExecution) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.Context != nil {
+ {
+ size, err := m.Context.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintDex(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x3a
+ }
+ if m.PrevReserves_2 != nil {
+ {
+ size, err := m.PrevReserves_2.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintDex(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x32
+ }
+ if m.PrevReserves_1 != nil {
+ {
+ size, err := m.PrevReserves_1.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintDex(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x2a
+ }
+ 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 *EventBatchSwap) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *EventBatchSwap) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EventBatchSwap) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.SwapExecution_2For_1 != nil {
+ {
+ size, err := m.SwapExecution_2For_1.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintDex(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x1a
+ }
+ if m.SwapExecution_1For_2 != nil {
+ {
+ size, err := m.SwapExecution_1For_2.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintDex(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x12
+ }
+ if m.BatchSwapOutputData != nil {
+ {
+ size, err := m.BatchSwapOutputData.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 *EventArbExecution) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *EventArbExecution) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EventArbExecution) 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] = 0x12
+ }
+ if m.Height != 0 {
+ i = encodeVarintDex(dAtA, i, uint64(m.Height))
+ i--
+ dAtA[i] = 0x8
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *EventValueCircuitBreakerCredit) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *EventValueCircuitBreakerCredit) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EventValueCircuitBreakerCredit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.NewBalance != nil {
+ {
+ size, err := m.NewBalance.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintDex(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x1a
+ }
+ if m.PreviousBalance != nil {
+ {
+ size, err := m.PreviousBalance.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintDex(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x12
+ }
+ if m.AssetId != nil {
+ {
+ size, err := m.AssetId.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 *EventValueCircuitBreakerDebit) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *EventValueCircuitBreakerDebit) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EventValueCircuitBreakerDebit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.NewBalance != nil {
+ {
+ size, err := m.NewBalance.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintDex(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x1a
+ }
+ if m.PreviousBalance != nil {
+ {
+ size, err := m.PreviousBalance.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintDex(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x12
+ }
+ if m.AssetId != nil {
+ {
+ size, err := m.AssetId.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 *DexParameters) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *DexParameters) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DexParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.MaxHops != 0 {
+ i = encodeVarintDex(dAtA, i, uint64(m.MaxHops))
+ i--
+ dAtA[i] = 0x18
+ }
+ if len(m.FixedCandidates) > 0 {
+ for iNdEx := len(m.FixedCandidates) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.FixedCandidates[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintDex(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x12
+ }
+ }
+ if m.IsEnabled {
+ i--
+ if m.IsEnabled {
+ 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.DexParams != nil {
+ {
+ size, err := m.DexParams.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))
+ }
+ if m.ClaimTx != nil {
+ l = m.ClaimTx.Size()
+ n += 1 + l + sovDex(uint64(l))
+ }
+ if m.BatchSwapOutputData != nil {
+ l = m.BatchSwapOutputData.Size()
+ n += 2 + l + sovDex(uint64(l))
+ }
+ if m.Output_1 != nil {
+ l = m.Output_1.Size()
+ n += 2 + l + sovDex(uint64(l))
+ }
+ if m.Output_2 != nil {
+ l = m.Output_2.Size()
+ n += 2 + l + sovDex(uint64(l))
+ }
+ if m.Asset_1Metadata != nil {
+ l = m.Asset_1Metadata.Size()
+ n += 2 + l + sovDex(uint64(l))
+ }
+ if m.Asset_2Metadata != nil {
+ l = m.Asset_2Metadata.Size()
+ n += 2 + 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))
+ }
+ if m.SwapTx != nil {
+ l = m.SwapTx.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))
+ }
+ if m.Sequence != 0 {
+ n += 1 + sovDex(uint64(m.Sequence))
+ }
+ 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))
+ }
+ if m.Sequence != 0 {
+ n += 1 + sovDex(uint64(m.Sequence))
+ }
+ 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))
+ }
+ if m.Sequence != 0 {
+ n += 1 + sovDex(uint64(m.Sequence))
+ }
+ if len(m.Rewards) > 0 {
+ for _, e := range m.Rewards {
+ l = e.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
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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))
+ }
+ if m.Unfilled != nil {
+ l = m.Unfilled.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))
+ }
+ if m.Sequence != 0 {
+ n += 1 + sovDex(uint64(m.Sequence))
+ }
+ return n
+}
+
+func (m *EventPositionExecution) 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.PrevReserves_1 != nil {
+ l = m.PrevReserves_1.Size()
+ n += 1 + l + sovDex(uint64(l))
+ }
+ if m.PrevReserves_2 != nil {
+ l = m.PrevReserves_2.Size()
+ n += 1 + l + sovDex(uint64(l))
+ }
+ if m.Context != nil {
+ l = m.Context.Size()
+ n += 1 + l + sovDex(uint64(l))
+ }
+ return n
+}
+
+func (m *EventBatchSwap) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.BatchSwapOutputData != nil {
+ l = m.BatchSwapOutputData.Size()
+ n += 1 + l + sovDex(uint64(l))
+ }
+ if m.SwapExecution_1For_2 != nil {
+ l = m.SwapExecution_1For_2.Size()
+ n += 1 + l + sovDex(uint64(l))
+ }
+ if m.SwapExecution_2For_1 != nil {
+ l = m.SwapExecution_2For_1.Size()
+ n += 1 + l + sovDex(uint64(l))
+ }
+ return n
+}
+
+func (m *EventArbExecution) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.Height != 0 {
+ n += 1 + sovDex(uint64(m.Height))
+ }
+ if m.SwapExecution != nil {
+ l = m.SwapExecution.Size()
+ n += 1 + l + sovDex(uint64(l))
+ }
+ return n
+}
+
+func (m *EventValueCircuitBreakerCredit) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.AssetId != nil {
+ l = m.AssetId.Size()
+ n += 1 + l + sovDex(uint64(l))
+ }
+ if m.PreviousBalance != nil {
+ l = m.PreviousBalance.Size()
+ n += 1 + l + sovDex(uint64(l))
+ }
+ if m.NewBalance != nil {
+ l = m.NewBalance.Size()
+ n += 1 + l + sovDex(uint64(l))
+ }
+ return n
+}
+
+func (m *EventValueCircuitBreakerDebit) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.AssetId != nil {
+ l = m.AssetId.Size()
+ n += 1 + l + sovDex(uint64(l))
+ }
+ if m.PreviousBalance != nil {
+ l = m.PreviousBalance.Size()
+ n += 1 + l + sovDex(uint64(l))
+ }
+ if m.NewBalance != nil {
+ l = m.NewBalance.Size()
+ n += 1 + l + sovDex(uint64(l))
+ }
+ return n
+}
+
+func (m *DexParameters) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.IsEnabled {
+ n += 2
+ }
+ if len(m.FixedCandidates) > 0 {
+ for _, e := range m.FixedCandidates {
+ l = e.Size()
+ n += 1 + l + sovDex(uint64(l))
+ }
+ }
+ if m.MaxHops != 0 {
+ n += 1 + sovDex(uint64(m.MaxHops))
+ }
+ return n
+}
+
+func (m *GenesisContent) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.DexParams != nil {
+ l = m.DexParams.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 = &v1.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 = &v11.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 = &v12.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 = &v12.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 = &v13.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 = &v13.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 = &v14.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 = &v12.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 = &v13.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 = &v13.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 = &v11.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 = &v15.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
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ClaimTx", 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.ClaimTx == nil {
+ m.ClaimTx = &v16.TransactionId{}
+ }
+ if err := m.ClaimTx.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 20:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field BatchSwapOutputData", 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.BatchSwapOutputData == nil {
+ m.BatchSwapOutputData = &BatchSwapOutputData{}
+ }
+ if err := m.BatchSwapOutputData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 30:
+ 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 = &v17.NoteView{}
+ }
+ if err := m.Output_1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 31:
+ 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 = &v17.NoteView{}
+ }
+ if err := m.Output_2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 40:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Asset_1Metadata", 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_1Metadata == nil {
+ m.Asset_1Metadata = &v14.Metadata{}
+ }
+ if err := m.Asset_1Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 41:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Asset_2Metadata", 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_2Metadata == nil {
+ m.Asset_2Metadata = &v14.Metadata{}
+ }
+ if err := m.Asset_2Metadata.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 = &v17.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 = &v17.NoteView{}
+ }
+ if err := m.Output_2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SwapTx", 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.SwapTx == nil {
+ m.SwapTx = &v16.TransactionId{}
+ }
+ if err := m.SwapTx.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 = &v14.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 = &v14.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 = &v14.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 = &v14.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 = &v13.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 = &v13.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 = &v13.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 = &v13.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 = &v13.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 = &v13.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 = &v13.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 = &v13.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 = &v13.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 = &v13.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
+ }
+ }
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
+ }
+ m.Sequence = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowDex
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.Sequence |= 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 *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 = &v14.BalanceCommitment{}
+ }
+ if err := m.ReservesCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
+ }
+ m.Sequence = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowDex
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.Sequence |= 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 *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 = &v14.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 = &v14.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 = &v14.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, &v14.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
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
+ }
+ m.Sequence = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowDex
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.Sequence |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Rewards", 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.Rewards = append(m.Rewards, &v14.Value{})
+ if err := m.Rewards[len(m.Rewards)-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 *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 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 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 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 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 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 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 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 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 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 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 = &v14.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 = &v14.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
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Unfilled", 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 == nil {
+ m.Unfilled = &v14.Value{}
+ }
+ if err := m.Unfilled.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 = &v13.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 = &v13.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 = &v12.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 = &v12.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 = &v12.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 = &v1.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 = &v13.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 = &v13.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 = &v13.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 = &v13.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 Sequence", wireType)
+ }
+ m.Sequence = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowDex
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.Sequence |= 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 *EventPositionExecution) Unmarshal(dAtA []byte) 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: EventPositionExecution: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EventPositionExecution: 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 = &v13.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 = &v13.Amount{}
+ }
+ if err := m.Reserves_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 PrevReserves_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.PrevReserves_1 == nil {
+ m.PrevReserves_1 = &v13.Amount{}
+ }
+ if err := m.PrevReserves_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 PrevReserves_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.PrevReserves_2 == nil {
+ m.PrevReserves_2 = &v13.Amount{}
+ }
+ if err := m.PrevReserves_2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 7:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Context", 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.Context == nil {
+ m.Context = &DirectedTradingPair{}
+ }
+ if err := m.Context.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 *EventBatchSwap) Unmarshal(dAtA []byte) 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: EventBatchSwap: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EventBatchSwap: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field BatchSwapOutputData", 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.BatchSwapOutputData == nil {
+ m.BatchSwapOutputData = &BatchSwapOutputData{}
+ }
+ if err := m.BatchSwapOutputData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field SwapExecution_1For_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.SwapExecution_1For_2 == nil {
+ m.SwapExecution_1For_2 = &SwapExecution{}
+ }
+ if err := m.SwapExecution_1For_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 SwapExecution_2For_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.SwapExecution_2For_1 == nil {
+ m.SwapExecution_2For_1 = &SwapExecution{}
+ }
+ if err := m.SwapExecution_2For_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 *EventArbExecution) Unmarshal(dAtA []byte) 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: EventArbExecution: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EventArbExecution: 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 ErrIntOverflowDex
+ }
+ 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 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 *EventValueCircuitBreakerCredit) Unmarshal(dAtA []byte) 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: EventValueCircuitBreakerCredit: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EventValueCircuitBreakerCredit: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ 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 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.AssetId == nil {
+ m.AssetId = &v14.AssetId{}
+ }
+ if err := m.AssetId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PreviousBalance", 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.PreviousBalance == nil {
+ m.PreviousBalance = &v13.Amount{}
+ }
+ if err := m.PreviousBalance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field NewBalance", 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.NewBalance == nil {
+ m.NewBalance = &v13.Amount{}
+ }
+ if err := m.NewBalance.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 *EventValueCircuitBreakerDebit) Unmarshal(dAtA []byte) 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: EventValueCircuitBreakerDebit: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EventValueCircuitBreakerDebit: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ 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 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.AssetId == nil {
+ m.AssetId = &v14.AssetId{}
+ }
+ if err := m.AssetId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PreviousBalance", 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.PreviousBalance == nil {
+ m.PreviousBalance = &v13.Amount{}
+ }
+ if err := m.PreviousBalance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field NewBalance", 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.NewBalance == nil {
+ m.NewBalance = &v13.Amount{}
+ }
+ if err := m.NewBalance.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 *DexParameters) Unmarshal(dAtA []byte) 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: DexParameters: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: DexParameters: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field IsEnabled", 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.IsEnabled = bool(v != 0)
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FixedCandidates", 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.FixedCandidates = append(m.FixedCandidates, &v14.AssetId{})
+ if err := m.FixedCandidates[len(m.FixedCandidates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field MaxHops", wireType)
+ }
+ m.MaxHops = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowDex
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.MaxHops |= 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 *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 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: 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 DexParams", 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.DexParams == nil {
+ m.DexParams = &DexParameters{}
+ }
+ if err := m.DexParams.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/v1/distributions.pb.go b/relayer/chains/penumbra/core/component/distributions/v1/distributions.pb.go
new file mode 100644
index 000000000..b45703906
--- /dev/null
+++ b/relayer/chains/penumbra/core/component/distributions/v1/distributions.pb.go
@@ -0,0 +1,495 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: penumbra/core/component/distributions/v1/distributions.proto
+
+package distributionsv1
+
+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_3e86d892e577363a, []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_3e86d892e577363a, []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.v1.DistributionsParameters")
+ proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.distributions.v1.GenesisContent")
+}
+
+func init() {
+ proto.RegisterFile("penumbra/core/component/distributions/v1/distributions.proto", fileDescriptor_3e86d892e577363a)
+}
+
+var fileDescriptor_3e86d892e577363a = []byte{
+ // 366 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xb1, 0x4a, 0xc3, 0x40,
+ 0x18, 0xc7, 0x9b, 0x58, 0x1c, 0x22, 0x38, 0x44, 0xa1, 0xe2, 0x10, 0xa4, 0x53, 0x87, 0x92, 0x23,
+ 0xd5, 0x29, 0x75, 0x31, 0x29, 0x14, 0x07, 0x21, 0x74, 0xc8, 0x20, 0x81, 0x70, 0x49, 0x8e, 0xf6,
+ 0x68, 0x73, 0x17, 0xee, 0x2e, 0x01, 0x1f, 0x40, 0x67, 0x9f, 0xc1, 0xd1, 0x27, 0x11, 0xa7, 0x8e,
+ 0x8e, 0x92, 0x6e, 0x3e, 0x85, 0x5c, 0x69, 0xa3, 0x87, 0x08, 0x59, 0x42, 0xf8, 0xbe, 0xdf, 0x2f,
+ 0xff, 0x3f, 0xb9, 0x33, 0xae, 0x0b, 0x44, 0xca, 0x3c, 0x61, 0x10, 0xa4, 0x94, 0x21, 0x90, 0xd2,
+ 0xbc, 0xa0, 0x04, 0x11, 0x01, 0x32, 0xcc, 0x05, 0xc3, 0x49, 0x29, 0x30, 0x25, 0x1c, 0x54, 0x8e,
+ 0x3a, 0xb0, 0x0b, 0x46, 0x05, 0x35, 0x07, 0x7b, 0xdb, 0x96, 0xb6, 0xdd, 0xd8, 0xb6, 0x0a, 0x57,
+ 0x4e, 0x3f, 0x34, 0x7a, 0x93, 0xdf, 0xb3, 0x00, 0x32, 0x98, 0x23, 0x81, 0x18, 0x37, 0xc7, 0xc6,
+ 0x39, 0x17, 0x70, 0x89, 0xc9, 0x3c, 0xc6, 0x9c, 0x97, 0x90, 0xa4, 0x28, 0x2e, 0x10, 0x8b, 0x93,
+ 0x15, 0x4d, 0x97, 0x67, 0xda, 0x85, 0x36, 0xe8, 0xce, 0x7a, 0x3b, 0xe2, 0x76, 0x07, 0x04, 0x88,
+ 0x79, 0x72, 0xdd, 0x7f, 0xd2, 0x8c, 0xe3, 0x29, 0x22, 0x88, 0x63, 0xee, 0x53, 0x22, 0x10, 0x11,
+ 0xa6, 0x30, 0x4e, 0x95, 0xf8, 0xb8, 0x90, 0x59, 0x7c, 0xfb, 0xa5, 0xa3, 0xd1, 0x8d, 0xdd, 0xb6,
+ 0xb3, 0xfd, 0x4f, 0xe1, 0xd9, 0x49, 0xf6, 0x67, 0xc1, 0xbd, 0xc7, 0x83, 0xb7, 0xda, 0xd2, 0xd6,
+ 0xb5, 0xa5, 0x7d, 0xd6, 0x96, 0xf6, 0xbc, 0xb1, 0x3a, 0xeb, 0x8d, 0xd5, 0xf9, 0xd8, 0x58, 0x1d,
+ 0x63, 0x98, 0xd2, 0xbc, 0x75, 0xaa, 0x67, 0xaa, 0xb1, 0xf2, 0x3f, 0x07, 0xda, 0x7d, 0x36, 0xc7,
+ 0x62, 0x51, 0x26, 0x52, 0x04, 0x29, 0xe5, 0x39, 0xe5, 0x80, 0xa1, 0x15, 0x7c, 0x40, 0x0c, 0x54,
+ 0xa3, 0xe6, 0x35, 0x5d, 0x40, 0x4c, 0x38, 0x68, 0x7b, 0xa6, 0x63, 0x65, 0x50, 0x39, 0x2f, 0x7a,
+ 0x37, 0xf0, 0xfd, 0xc9, 0xab, 0x3e, 0x08, 0xf6, 0x6d, 0x7d, 0xd9, 0xd6, 0x6f, 0xda, 0x2a, 0xdd,
+ 0xec, 0xd0, 0x79, 0xff, 0x41, 0x23, 0x89, 0x46, 0x0d, 0x1a, 0x29, 0x68, 0x14, 0x3a, 0xb5, 0x7e,
+ 0xd5, 0x16, 0x8d, 0xa6, 0x81, 0x77, 0x87, 0x04, 0xcc, 0xa0, 0x80, 0x5f, 0xfa, 0x70, 0xaf, 0xb9,
+ 0xae, 0xf4, 0xe4, 0x73, 0x27, 0xba, 0xae, 0x62, 0xba, 0x6e, 0xe8, 0x24, 0x87, 0xdb, 0x9b, 0x79,
+ 0xf9, 0x1d, 0x00, 0x00, 0xff, 0xff, 0x82, 0x69, 0x0c, 0x43, 0xd9, 0x02, 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/v1/fee.pb.go b/relayer/chains/penumbra/core/component/fee/v1/fee.pb.go
new file mode 100644
index 000000000..5d6e30f68
--- /dev/null
+++ b/relayer/chains/penumbra/core/component/fee/v1/fee.pb.go
@@ -0,0 +1,1626 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: penumbra/core/component/fee/v1/fee.proto
+
+package feev1
+
+import (
+ context "context"
+ fmt "fmt"
+ grpc1 "github.com/cosmos/gogoproto/grpc"
+ proto "github.com/cosmos/gogoproto/proto"
+ v11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/asset/v1"
+ v1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/num/v1"
+ 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
+
+// The tier for the fee.
+type FeeTier_Tier int32
+
+const (
+ FeeTier_TIER_UNSPECIFIED FeeTier_Tier = 0
+ FeeTier_TIER_LOW FeeTier_Tier = 1
+ FeeTier_TIER_MEDIUM FeeTier_Tier = 2
+ FeeTier_TIER_HIGH FeeTier_Tier = 3
+)
+
+var FeeTier_Tier_name = map[int32]string{
+ 0: "TIER_UNSPECIFIED",
+ 1: "TIER_LOW",
+ 2: "TIER_MEDIUM",
+ 3: "TIER_HIGH",
+}
+
+var FeeTier_Tier_value = map[string]int32{
+ "TIER_UNSPECIFIED": 0,
+ "TIER_LOW": 1,
+ "TIER_MEDIUM": 2,
+ "TIER_HIGH": 3,
+}
+
+func (x FeeTier_Tier) String() string {
+ return proto.EnumName(FeeTier_Tier_name, int32(x))
+}
+
+func (FeeTier_Tier) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_80e267509eb0355f, []int{2, 0}
+}
+
+// Specifies fees paid by a transaction.
+type Fee struct {
+ // The amount of the token used to pay fees.
+ Amount *v1.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 *v11.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_80e267509eb0355f, []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() *v1.Amount {
+ if m != nil {
+ return m.Amount
+ }
+ return nil
+}
+
+func (m *Fee) GetAssetId() *v11.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_80e267509eb0355f, []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
+}
+
+type FeeTier struct {
+ // The selected fee tier.
+ FeeTier FeeTier_Tier `protobuf:"varint,1,opt,name=fee_tier,json=feeTier,proto3,enum=penumbra.core.component.fee.v1.FeeTier_Tier" json:"fee_tier,omitempty"`
+}
+
+func (m *FeeTier) Reset() { *m = FeeTier{} }
+func (m *FeeTier) String() string { return proto.CompactTextString(m) }
+func (*FeeTier) ProtoMessage() {}
+func (*FeeTier) Descriptor() ([]byte, []int) {
+ return fileDescriptor_80e267509eb0355f, []int{2}
+}
+func (m *FeeTier) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *FeeTier) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_FeeTier.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *FeeTier) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_FeeTier.Merge(m, src)
+}
+func (m *FeeTier) XXX_Size() int {
+ return m.Size()
+}
+func (m *FeeTier) XXX_DiscardUnknown() {
+ xxx_messageInfo_FeeTier.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FeeTier proto.InternalMessageInfo
+
+func (m *FeeTier) GetFeeTier() FeeTier_Tier {
+ if m != nil {
+ return m.FeeTier
+ }
+ return FeeTier_TIER_UNSPECIFIED
+}
+
+// Fee component configuration data.
+type FeeParameters struct {
+ // Fixed gas prices used to compute transactions' base fees.
+ //
+ // In the future, this should be removed and replaced with parameters for dynamic gas pricing.
+ FixedGasPrices *GasPrices `protobuf:"bytes,1,opt,name=fixed_gas_prices,json=fixedGasPrices,proto3" json:"fixed_gas_prices,omitempty"`
+}
+
+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_80e267509eb0355f, []int{3}
+}
+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
+
+func (m *FeeParameters) GetFixedGasPrices() *GasPrices {
+ if m != nil {
+ return m.FixedGasPrices
+ }
+ return nil
+}
+
+// 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"`
+}
+
+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_80e267509eb0355f, []int{4}
+}
+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
+}
+
+type CurrentGasPricesRequest struct {
+}
+
+func (m *CurrentGasPricesRequest) Reset() { *m = CurrentGasPricesRequest{} }
+func (m *CurrentGasPricesRequest) String() string { return proto.CompactTextString(m) }
+func (*CurrentGasPricesRequest) ProtoMessage() {}
+func (*CurrentGasPricesRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_80e267509eb0355f, []int{5}
+}
+func (m *CurrentGasPricesRequest) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *CurrentGasPricesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_CurrentGasPricesRequest.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *CurrentGasPricesRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_CurrentGasPricesRequest.Merge(m, src)
+}
+func (m *CurrentGasPricesRequest) XXX_Size() int {
+ return m.Size()
+}
+func (m *CurrentGasPricesRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_CurrentGasPricesRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CurrentGasPricesRequest proto.InternalMessageInfo
+
+type CurrentGasPricesResponse struct {
+ // The current gas prices.
+ GasPrices *GasPrices `protobuf:"bytes,1,opt,name=gas_prices,json=gasPrices,proto3" json:"gas_prices,omitempty"`
+}
+
+func (m *CurrentGasPricesResponse) Reset() { *m = CurrentGasPricesResponse{} }
+func (m *CurrentGasPricesResponse) String() string { return proto.CompactTextString(m) }
+func (*CurrentGasPricesResponse) ProtoMessage() {}
+func (*CurrentGasPricesResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_80e267509eb0355f, []int{6}
+}
+func (m *CurrentGasPricesResponse) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *CurrentGasPricesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_CurrentGasPricesResponse.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *CurrentGasPricesResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_CurrentGasPricesResponse.Merge(m, src)
+}
+func (m *CurrentGasPricesResponse) XXX_Size() int {
+ return m.Size()
+}
+func (m *CurrentGasPricesResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_CurrentGasPricesResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CurrentGasPricesResponse proto.InternalMessageInfo
+
+func (m *CurrentGasPricesResponse) GetGasPrices() *GasPrices {
+ if m != nil {
+ return m.GasPrices
+ }
+ return nil
+}
+
+func init() {
+ proto.RegisterEnum("penumbra.core.component.fee.v1.FeeTier_Tier", FeeTier_Tier_name, FeeTier_Tier_value)
+ proto.RegisterType((*Fee)(nil), "penumbra.core.component.fee.v1.Fee")
+ proto.RegisterType((*GasPrices)(nil), "penumbra.core.component.fee.v1.GasPrices")
+ proto.RegisterType((*FeeTier)(nil), "penumbra.core.component.fee.v1.FeeTier")
+ proto.RegisterType((*FeeParameters)(nil), "penumbra.core.component.fee.v1.FeeParameters")
+ proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.fee.v1.GenesisContent")
+ proto.RegisterType((*CurrentGasPricesRequest)(nil), "penumbra.core.component.fee.v1.CurrentGasPricesRequest")
+ proto.RegisterType((*CurrentGasPricesResponse)(nil), "penumbra.core.component.fee.v1.CurrentGasPricesResponse")
+}
+
+func init() {
+ proto.RegisterFile("penumbra/core/component/fee/v1/fee.proto", fileDescriptor_80e267509eb0355f)
+}
+
+var fileDescriptor_80e267509eb0355f = []byte{
+ // 689 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0x4f, 0x6f, 0xd3, 0x4c,
+ 0x10, 0xc6, 0x63, 0x37, 0x6a, 0x93, 0x69, 0x9b, 0xa6, 0xd6, 0xab, 0xf7, 0x6d, 0xab, 0x57, 0x06,
+ 0xf9, 0x42, 0xa9, 0xa8, 0xad, 0x04, 0x24, 0x20, 0x9c, 0x48, 0x1a, 0xa7, 0x41, 0x2d, 0x98, 0xa4,
+ 0x2d, 0x12, 0x8a, 0x88, 0x36, 0xce, 0xa4, 0xb5, 0xa8, 0xed, 0xb0, 0xbb, 0x0e, 0xed, 0x07, 0xe0,
+ 0xce, 0x89, 0x23, 0x07, 0x8e, 0xdc, 0xf9, 0x0e, 0xa8, 0xa7, 0x1e, 0x39, 0xa2, 0xf4, 0xc6, 0xa7,
+ 0x40, 0xbb, 0x4e, 0xdc, 0x7f, 0xa2, 0x05, 0x71, 0x71, 0x66, 0x67, 0x7f, 0xcf, 0xcc, 0x33, 0xbb,
+ 0xd1, 0xc2, 0x72, 0x1f, 0x83, 0xc8, 0xef, 0x50, 0x62, 0xb9, 0x21, 0x45, 0xcb, 0x0d, 0xfd, 0x7e,
+ 0x18, 0x60, 0xc0, 0xad, 0x1e, 0xa2, 0x35, 0x28, 0x88, 0x1f, 0xb3, 0x4f, 0x43, 0x1e, 0x6a, 0xfa,
+ 0x98, 0x34, 0x05, 0x69, 0x26, 0xa4, 0x29, 0x90, 0x41, 0x61, 0xc9, 0x38, 0x5f, 0x89, 0x30, 0x86,
+ 0x5c, 0x54, 0x90, 0x41, 0x5c, 0x63, 0x49, 0x3f, 0xcf, 0x04, 0x91, 0x2f, 0x88, 0x20, 0xf2, 0xe3,
+ 0x7d, 0xe3, 0x2d, 0x4c, 0xd8, 0x88, 0xda, 0x3d, 0x98, 0x24, 0x7e, 0x18, 0x05, 0x7c, 0x41, 0xb9,
+ 0xa9, 0x2c, 0x4f, 0x17, 0xff, 0x37, 0xcf, 0xf7, 0x16, 0x82, 0x41, 0xc1, 0x7c, 0x2c, 0x99, 0xc6,
+ 0x88, 0xd5, 0x4a, 0x90, 0x91, 0xbd, 0xda, 0x5e, 0x77, 0x41, 0x95, 0xba, 0x1b, 0x17, 0x74, 0xb1,
+ 0x15, 0xa1, 0x14, 0x41, 0xbd, 0xdb, 0x98, 0x22, 0x71, 0x60, 0x1c, 0x29, 0x90, 0xad, 0x11, 0xe6,
+ 0x50, 0xcf, 0x45, 0xa6, 0xad, 0xc0, 0x7c, 0x67, 0x3f, 0x74, 0x5f, 0xb7, 0x59, 0x9f, 0xb8, 0xd8,
+ 0xee, 0x8b, 0xac, 0xb4, 0x92, 0x6e, 0xcc, 0xc9, 0x8d, 0xa6, 0xc8, 0x4b, 0x58, 0x7b, 0x08, 0x8b,
+ 0xe2, 0x28, 0x88, 0xcb, 0xdb, 0x97, 0x35, 0xaa, 0xd4, 0xfc, 0x3b, 0x02, 0xca, 0x17, 0xa4, 0xab,
+ 0xa0, 0x0d, 0x90, 0x7a, 0x3d, 0xcf, 0x25, 0xdc, 0x0b, 0x83, 0x91, 0x66, 0x42, 0x6a, 0xe6, 0xcf,
+ 0xee, 0xc4, 0xf8, 0x2d, 0x98, 0xc3, 0x03, 0x74, 0xa3, 0x33, 0x6c, 0x5a, 0xb2, 0xb9, 0x24, 0x2d,
+ 0x41, 0xe3, 0xa3, 0x02, 0x53, 0x36, 0xe2, 0x96, 0x87, 0x54, 0xab, 0x41, 0xa6, 0x87, 0xd8, 0xe6,
+ 0x1e, 0x52, 0x39, 0x41, 0xae, 0x78, 0xc7, 0xbc, 0xfa, 0x22, 0xcd, 0x91, 0xd4, 0x14, 0x9f, 0xc6,
+ 0x54, 0x2f, 0x5e, 0x19, 0x4f, 0x20, 0x2d, 0x0b, 0xfe, 0x03, 0xf9, 0xad, 0x7a, 0xb5, 0xd1, 0xde,
+ 0x7e, 0xda, 0x74, 0xaa, 0x95, 0xba, 0x5d, 0xaf, 0xae, 0xe5, 0x53, 0xda, 0x0c, 0x64, 0x64, 0x76,
+ 0xe3, 0xd9, 0x8b, 0xbc, 0xa2, 0xcd, 0xc1, 0xb4, 0x5c, 0x6d, 0x56, 0xd7, 0xea, 0xdb, 0x9b, 0x79,
+ 0x55, 0x9b, 0x85, 0xac, 0x4c, 0xac, 0xd7, 0x6b, 0xeb, 0xf9, 0x09, 0xa3, 0x0b, 0xb3, 0x36, 0xa2,
+ 0x43, 0x28, 0xf1, 0x91, 0x23, 0x65, 0x5a, 0x13, 0xf2, 0x3d, 0xef, 0x00, 0xbb, 0xed, 0x5d, 0xc2,
+ 0xe2, 0xd1, 0xd8, 0xe8, 0xea, 0x6f, 0x5f, 0xe7, 0x36, 0xb9, 0xb5, 0x46, 0x4e, 0x96, 0x48, 0xd6,
+ 0xc6, 0x2b, 0xc8, 0xd5, 0x30, 0x40, 0xe6, 0xb1, 0x4a, 0x18, 0x70, 0x0c, 0xb8, 0xb6, 0x01, 0x20,
+ 0x0e, 0xa3, 0x2f, 0x1a, 0x8f, 0x1b, 0xac, 0xfe, 0xc6, 0x71, 0x9c, 0x3a, 0x6d, 0x64, 0x7b, 0xa3,
+ 0x25, 0x33, 0x16, 0xe1, 0xbf, 0x4a, 0x44, 0x29, 0x06, 0xfc, 0xd4, 0x03, 0xbe, 0x89, 0x90, 0x71,
+ 0xa3, 0x0b, 0x0b, 0x97, 0xb7, 0x58, 0x3f, 0x0c, 0x18, 0x6a, 0xeb, 0x00, 0x7f, 0x33, 0x65, 0x76,
+ 0x77, 0x1c, 0x16, 0x3f, 0x28, 0x30, 0xf3, 0x3c, 0x42, 0x7a, 0xd8, 0x44, 0x3a, 0x10, 0xff, 0x90,
+ 0x77, 0x0a, 0xe4, 0x2f, 0xf6, 0xd5, 0xee, 0x5f, 0x57, 0xfb, 0x17, 0x43, 0x2c, 0x3d, 0xf8, 0x73,
+ 0x61, 0x3c, 0x62, 0xf9, 0x8b, 0xfa, 0x75, 0xa8, 0x2b, 0xc7, 0x43, 0x5d, 0xf9, 0x3e, 0xd4, 0x95,
+ 0xf7, 0x27, 0x7a, 0xea, 0xf8, 0x44, 0x4f, 0x7d, 0x3b, 0xd1, 0x53, 0x60, 0xb8, 0xa1, 0x7f, 0x4d,
+ 0xdd, 0x72, 0x46, 0x1c, 0xb9, 0x78, 0x0f, 0x1c, 0xe5, 0xa5, 0xb3, 0xeb, 0xf1, 0xbd, 0xa8, 0x23,
+ 0x20, 0xcb, 0x0d, 0x99, 0x1f, 0x32, 0x8b, 0xe2, 0x3e, 0x39, 0x44, 0x6a, 0x0d, 0x8a, 0x49, 0xe8,
+ 0xee, 0x11, 0x2f, 0x60, 0xd6, 0xd5, 0x6f, 0xd9, 0xa3, 0x1e, 0xe2, 0xa0, 0xf0, 0x49, 0x4d, 0x3b,
+ 0x95, 0x8a, 0xfd, 0x59, 0xd5, 0x9d, 0xb1, 0x8b, 0x8a, 0x70, 0x51, 0x49, 0x5c, 0xd8, 0x88, 0xe6,
+ 0x4e, 0xe1, 0xe8, 0x14, 0x68, 0x09, 0xa0, 0x95, 0x00, 0x2d, 0x1b, 0xb1, 0xb5, 0x53, 0x18, 0xaa,
+ 0x2b, 0x57, 0x03, 0xad, 0x9a, 0x53, 0xde, 0x44, 0x4e, 0xba, 0x84, 0x93, 0x1f, 0xaa, 0x31, 0x86,
+ 0x4b, 0x25, 0x41, 0x8b, 0xef, 0x08, 0x2f, 0x95, 0x6c, 0xc4, 0x52, 0x69, 0xa7, 0xd0, 0x99, 0x94,
+ 0xaf, 0xe0, 0xdd, 0x9f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x50, 0x18, 0x19, 0x16, 0x95, 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 {
+ // Get the current gas prices.
+ CurrentGasPrices(ctx context.Context, in *CurrentGasPricesRequest, opts ...grpc.CallOption) (*CurrentGasPricesResponse, error)
+}
+
+type queryServiceClient struct {
+ cc grpc1.ClientConn
+}
+
+func NewQueryServiceClient(cc grpc1.ClientConn) QueryServiceClient {
+ return &queryServiceClient{cc}
+}
+
+func (c *queryServiceClient) CurrentGasPrices(ctx context.Context, in *CurrentGasPricesRequest, opts ...grpc.CallOption) (*CurrentGasPricesResponse, error) {
+ out := new(CurrentGasPricesResponse)
+ err := c.cc.Invoke(ctx, "/penumbra.core.component.fee.v1.QueryService/CurrentGasPrices", 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 current gas prices.
+ CurrentGasPrices(context.Context, *CurrentGasPricesRequest) (*CurrentGasPricesResponse, error)
+}
+
+// UnimplementedQueryServiceServer can be embedded to have forward compatible implementations.
+type UnimplementedQueryServiceServer struct {
+}
+
+func (*UnimplementedQueryServiceServer) CurrentGasPrices(ctx context.Context, req *CurrentGasPricesRequest) (*CurrentGasPricesResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method CurrentGasPrices not implemented")
+}
+
+func RegisterQueryServiceServer(s grpc1.Server, srv QueryServiceServer) {
+ s.RegisterService(&_QueryService_serviceDesc, srv)
+}
+
+func _QueryService_CurrentGasPrices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(CurrentGasPricesRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(QueryServiceServer).CurrentGasPrices(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/penumbra.core.component.fee.v1.QueryService/CurrentGasPrices",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(QueryServiceServer).CurrentGasPrices(ctx, req.(*CurrentGasPricesRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+var _QueryService_serviceDesc = grpc.ServiceDesc{
+ ServiceName: "penumbra.core.component.fee.v1.QueryService",
+ HandlerType: (*QueryServiceServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "CurrentGasPrices",
+ Handler: _QueryService_CurrentGasPrices_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "penumbra/core/component/fee/v1/fee.proto",
+}
+
+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 *FeeTier) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *FeeTier) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *FeeTier) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.FeeTier != 0 {
+ i = encodeVarintFee(dAtA, i, uint64(m.FeeTier))
+ 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
+ if m.FixedGasPrices != nil {
+ {
+ size, err := m.FixedGasPrices.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 *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.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 (m *CurrentGasPricesRequest) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *CurrentGasPricesRequest) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CurrentGasPricesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ return len(dAtA) - i, nil
+}
+
+func (m *CurrentGasPricesResponse) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *CurrentGasPricesResponse) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CurrentGasPricesResponse) 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] = 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 *FeeTier) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.FeeTier != 0 {
+ n += 1 + sovFee(uint64(m.FeeTier))
+ }
+ return n
+}
+
+func (m *FeeParameters) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.FixedGasPrices != nil {
+ l = m.FixedGasPrices.Size()
+ n += 1 + l + sovFee(uint64(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))
+ }
+ return n
+}
+
+func (m *CurrentGasPricesRequest) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ return n
+}
+
+func (m *CurrentGasPricesResponse) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = 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 = &v1.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 = &v11.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 *FeeTier) Unmarshal(dAtA []byte) 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: FeeTier: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: FeeTier: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FeeTier", wireType)
+ }
+ m.FeeTier = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowFee
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.FeeTier |= FeeTier_Tier(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 {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FixedGasPrices", 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.FixedGasPrices == nil {
+ m.FixedGasPrices = &GasPrices{}
+ }
+ if err := m.FixedGasPrices.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 *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
+ 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 *CurrentGasPricesRequest) Unmarshal(dAtA []byte) 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: CurrentGasPricesRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: CurrentGasPricesRequest: 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 *CurrentGasPricesResponse) Unmarshal(dAtA []byte) 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: CurrentGasPricesResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: CurrentGasPricesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ 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/funding/v1/funding.pb.go b/relayer/chains/penumbra/core/component/funding/v1/funding.pb.go
new file mode 100644
index 000000000..aac8c97fb
--- /dev/null
+++ b/relayer/chains/penumbra/core/component/funding/v1/funding.pb.go
@@ -0,0 +1,456 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: penumbra/core/component/funding/v1/funding.proto
+
+package fundingv1
+
+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
+
+// Funding component configuration data.
+type FundingParameters struct {
+}
+
+func (m *FundingParameters) Reset() { *m = FundingParameters{} }
+func (m *FundingParameters) String() string { return proto.CompactTextString(m) }
+func (*FundingParameters) ProtoMessage() {}
+func (*FundingParameters) Descriptor() ([]byte, []int) {
+ return fileDescriptor_586f7399b4e8a469, []int{0}
+}
+func (m *FundingParameters) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *FundingParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_FundingParameters.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *FundingParameters) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_FundingParameters.Merge(m, src)
+}
+func (m *FundingParameters) XXX_Size() int {
+ return m.Size()
+}
+func (m *FundingParameters) XXX_DiscardUnknown() {
+ xxx_messageInfo_FundingParameters.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FundingParameters proto.InternalMessageInfo
+
+// Genesis data for the funding component.
+type GenesisContent struct {
+ FundingParams *FundingParameters `protobuf:"bytes,1,opt,name=funding_params,json=fundingParams,proto3" json:"funding_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_586f7399b4e8a469, []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) GetFundingParams() *FundingParameters {
+ if m != nil {
+ return m.FundingParams
+ }
+ return nil
+}
+
+func init() {
+ proto.RegisterType((*FundingParameters)(nil), "penumbra.core.component.funding.v1.FundingParameters")
+ proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.funding.v1.GenesisContent")
+}
+
+func init() {
+ proto.RegisterFile("penumbra/core/component/funding/v1/funding.proto", fileDescriptor_586f7399b4e8a469)
+}
+
+var fileDescriptor_586f7399b4e8a469 = []byte{
+ // 320 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xb1, 0x4a, 0x3b, 0x31,
+ 0x1c, 0xc7, 0x9b, 0xe3, 0xcf, 0x7f, 0x38, 0xb5, 0x60, 0x5d, 0x9c, 0x82, 0xdc, 0x50, 0x9c, 0x12,
+ 0x53, 0x71, 0x89, 0x5b, 0x0f, 0xda, 0x49, 0x38, 0x1c, 0x8a, 0x48, 0x40, 0xd2, 0x6b, 0xda, 0x1e,
+ 0x78, 0xc9, 0x91, 0xa4, 0x07, 0xbe, 0x85, 0xcf, 0xe0, 0xe8, 0x93, 0x88, 0x53, 0x17, 0xc1, 0x51,
+ 0xae, 0x9b, 0x4f, 0x21, 0xd1, 0xe4, 0x14, 0x1c, 0xea, 0x12, 0x7e, 0x09, 0x9f, 0x0f, 0xdf, 0x6f,
+ 0x42, 0xe2, 0x93, 0x4a, 0xc8, 0x55, 0x39, 0xd5, 0x1c, 0xe7, 0x4a, 0x0b, 0x9c, 0xab, 0xb2, 0x52,
+ 0x52, 0x48, 0x8b, 0xe7, 0x2b, 0x39, 0x2b, 0xe4, 0x02, 0xd7, 0x24, 0x8c, 0xa8, 0xd2, 0xca, 0xaa,
+ 0x5e, 0x12, 0x0c, 0xe4, 0x0c, 0xd4, 0x1a, 0x28, 0x60, 0x35, 0x49, 0x0e, 0xe2, 0xfd, 0xd1, 0xd7,
+ 0x2e, 0xe3, 0x9a, 0x97, 0xc2, 0x0a, 0x6d, 0x12, 0x19, 0x77, 0xc7, 0x42, 0x0a, 0x53, 0x98, 0x54,
+ 0x49, 0x2b, 0xa4, 0xed, 0xb1, 0xb8, 0xeb, 0xa5, 0x9b, 0xca, 0x71, 0xe6, 0x10, 0x1c, 0x81, 0xe3,
+ 0x9d, 0xc1, 0x19, 0xda, 0x9e, 0x81, 0x7e, 0x05, 0x5c, 0xee, 0xcd, 0x7f, 0x1c, 0x99, 0xe1, 0x4b,
+ 0xf4, 0xd4, 0x40, 0xb0, 0x6e, 0x20, 0x78, 0x6b, 0x20, 0xb8, 0xdf, 0xc0, 0xce, 0x7a, 0x03, 0x3b,
+ 0xaf, 0x1b, 0xd8, 0x89, 0xfb, 0xb9, 0x2a, 0xff, 0x90, 0x31, 0xdc, 0x0d, 0x21, 0xee, 0xe6, 0x19,
+ 0xb8, 0xbe, 0x5a, 0x14, 0x76, 0xb9, 0x9a, 0x3a, 0x18, 0xe7, 0xca, 0x94, 0xca, 0x60, 0x2d, 0x6e,
+ 0xf9, 0x9d, 0xd0, 0xb8, 0x1e, 0xb4, 0x63, 0xbe, 0xe4, 0x85, 0x34, 0x78, 0xfb, 0xcb, 0x9e, 0xfb,
+ 0xb1, 0x26, 0x0f, 0xd1, 0xbf, 0x2c, 0x4d, 0x47, 0x8f, 0x51, 0x92, 0x85, 0x56, 0xa9, 0x6b, 0x95,
+ 0xb6, 0xad, 0x7c, 0x13, 0x34, 0x21, 0xcf, 0xdf, 0x10, 0x73, 0x10, 0x6b, 0x21, 0xe6, 0x21, 0x36,
+ 0x21, 0x4d, 0x84, 0xb6, 0x43, 0x6c, 0x9c, 0x0d, 0x2f, 0x84, 0xe5, 0x33, 0x6e, 0xf9, 0x7b, 0xd4,
+ 0x0f, 0x02, 0xa5, 0xce, 0x70, 0xab, 0x57, 0x28, 0xf5, 0x0e, 0xa5, 0x13, 0x32, 0xfd, 0xff, 0xf9,
+ 0x0f, 0x4e, 0x3f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x6d, 0x01, 0xe0, 0xb6, 0x3b, 0x02, 0x00, 0x00,
+}
+
+func (m *FundingParameters) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *FundingParameters) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *FundingParameters) 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.FundingParams != nil {
+ {
+ size, err := m.FundingParams.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintFunding(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func encodeVarintFunding(dAtA []byte, offset int, v uint64) int {
+ offset -= sovFunding(v)
+ base := offset
+ for v >= 1<<7 {
+ dAtA[offset] = uint8(v&0x7f | 0x80)
+ v >>= 7
+ offset++
+ }
+ dAtA[offset] = uint8(v)
+ return base
+}
+func (m *FundingParameters) 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.FundingParams != nil {
+ l = m.FundingParams.Size()
+ n += 1 + l + sovFunding(uint64(l))
+ }
+ return n
+}
+
+func sovFunding(x uint64) (n int) {
+ return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozFunding(x uint64) (n int) {
+ return sovFunding(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *FundingParameters) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowFunding
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: FundingParameters: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: FundingParameters: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ default:
+ iNdEx = preIndex
+ skippy, err := skipFunding(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthFunding
+ }
+ 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 ErrIntOverflowFunding
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ 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 FundingParams", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowFunding
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ msglen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthFunding
+ }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthFunding
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.FundingParams == nil {
+ m.FundingParams = &FundingParameters{}
+ }
+ if err := m.FundingParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipFunding(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthFunding
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func skipFunding(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, ErrIntOverflowFunding
+ }
+ 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, ErrIntOverflowFunding
+ }
+ 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, ErrIntOverflowFunding
+ }
+ 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, ErrInvalidLengthFunding
+ }
+ iNdEx += length
+ case 3:
+ depth++
+ case 4:
+ if depth == 0 {
+ return 0, ErrUnexpectedEndOfGroupFunding
+ }
+ depth--
+ case 5:
+ iNdEx += 4
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ if iNdEx < 0 {
+ return 0, ErrInvalidLengthFunding
+ }
+ if depth == 0 {
+ return iNdEx, nil
+ }
+ }
+ return 0, io.ErrUnexpectedEOF
+}
+
+var (
+ ErrInvalidLengthFunding = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowFunding = fmt.Errorf("proto: integer overflow")
+ ErrUnexpectedEndOfGroupFunding = fmt.Errorf("proto: unexpected end of group")
+)
diff --git a/relayer/chains/penumbra/core/component/governance/v1/governance.pb.go b/relayer/chains/penumbra/core/component/governance/v1/governance.pb.go
new file mode 100644
index 000000000..e1125806c
--- /dev/null
+++ b/relayer/chains/penumbra/core/component/governance/v1/governance.pb.go
@@ -0,0 +1,16319 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: penumbra/core/component/governance/v1/governance.proto
+
+package governancev1
+
+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"
+ v13 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/asset/v1"
+ v17 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/community_pool/v1"
+ v112 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/dex/v1"
+ v110 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/distributions/v1"
+ v19 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/fee/v1"
+ v111 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/funding/v1"
+ v18 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/ibc/v1"
+ v14 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/sct/v1"
+ v15 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/shielded_pool/v1"
+ v16 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/stake/v1"
+ v12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/keys/v1"
+ v1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/num/v1"
+ v11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/decaf377_rdsa/v1"
+ 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_a9098f9e68b782a3, []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_a9098f9e68b782a3, []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 *v1.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_a9098f9e68b782a3, []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() *v1.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_a9098f9e68b782a3, []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 *v1.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_a9098f9e68b782a3, []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() *v1.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 *v11.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_a9098f9e68b782a3, []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() *v11.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_a9098f9e68b782a3, []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 *v12.IdentityKey `protobuf:"bytes,3,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"`
+ // The validator governance key.
+ GovernanceKey *v12.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_a9098f9e68b782a3, []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() *v12.IdentityKey {
+ if m != nil {
+ return m.IdentityKey
+ }
+ return nil
+}
+
+func (m *ValidatorVoteBody) GetGovernanceKey() *v12.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 *v11.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_a9098f9e68b782a3, []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() *v11.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 *v13.Value `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"`
+ // The amount of the delegation note, in unbonded penumbra.
+ UnbondedAmount *v1.Amount `protobuf:"bytes,5,opt,name=unbonded_amount,json=unbondedAmount,proto3" json:"unbonded_amount,omitempty"`
+ // The nullifier of the input note.
+ Nullifier *v14.Nullifier `protobuf:"bytes,6,opt,name=nullifier,proto3" json:"nullifier,omitempty"`
+ // The randomized validating key for the spend authorization signature.
+ Rk *v11.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_a9098f9e68b782a3, []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() *v13.Value {
+ if m != nil {
+ return m.Value
+ }
+ return nil
+}
+
+func (m *DelegatorVoteBody) GetUnbondedAmount() *v1.Amount {
+ if m != nil {
+ return m.UnbondedAmount
+ }
+ return nil
+}
+
+func (m *DelegatorVoteBody) GetNullifier() *v14.Nullifier {
+ if m != nil {
+ return m.Nullifier
+ }
+ return nil
+}
+
+func (m *DelegatorVoteBody) GetRk() *v11.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_a9098f9e68b782a3, []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 *v15.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_a9098f9e68b782a3, []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() *v15.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_a9098f9e68b782a3, []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 *v15.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 *v1.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_a9098f9e68b782a3, []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() *v15.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() *v1.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 *v13.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_a9098f9e68b782a3, []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() *v13.Value {
+ if m != nil {
+ return m.Value
+ }
+ return nil
+}
+
+type CommunityPoolSpend struct {
+ // The value to spend from the Community Pool.
+ Value *v13.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_a9098f9e68b782a3, []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() *v13.Value {
+ if m != nil {
+ return m.Value
+ }
+ return nil
+}
+
+type CommunityPoolOutput struct {
+ // The value to output from the Community Pool.
+ Value *v13.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
+ // The address to send the output to.
+ Address *v12.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_a9098f9e68b782a3, []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() *v13.Value {
+ if m != nil {
+ return m.Value
+ }
+ return nil
+}
+
+func (m *CommunityPoolOutput) GetAddress() *v12.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.v1.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_a9098f9e68b782a3, []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_a9098f9e68b782a3, []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_a9098f9e68b782a3, []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_a9098f9e68b782a3, []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_a9098f9e68b782a3, []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_a9098f9e68b782a3, []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_a9098f9e68b782a3, []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_a9098f9e68b782a3, []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_a9098f9e68b782a3, []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_a9098f9e68b782a3, []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_a9098f9e68b782a3, []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_a9098f9e68b782a3, []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 proposal's payload.
+ //
+ // Types that are valid to be assigned to Payload:
+ //
+ // *Proposal_Signaling_
+ // *Proposal_Emergency_
+ // *Proposal_ParameterChange_
+ // *Proposal_CommunityPoolSpend_
+ // *Proposal_UpgradePlan_
+ // *Proposal_FreezeIbcClient_
+ // *Proposal_UnfreezeIbcClient_
+ Payload isProposal_Payload `protobuf_oneof:"payload"`
+}
+
+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_a9098f9e68b782a3, []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
+
+type isProposal_Payload interface {
+ isProposal_Payload()
+ MarshalTo([]byte) (int, error)
+ Size() int
+}
+
+type Proposal_Signaling_ struct {
+ Signaling *Proposal_Signaling `protobuf:"bytes,5,opt,name=signaling,proto3,oneof" json:"signaling,omitempty"`
+}
+type Proposal_Emergency_ struct {
+ Emergency *Proposal_Emergency `protobuf:"bytes,6,opt,name=emergency,proto3,oneof" json:"emergency,omitempty"`
+}
+type Proposal_ParameterChange_ struct {
+ ParameterChange *Proposal_ParameterChange `protobuf:"bytes,7,opt,name=parameter_change,json=parameterChange,proto3,oneof" json:"parameter_change,omitempty"`
+}
+type Proposal_CommunityPoolSpend_ struct {
+ CommunityPoolSpend *Proposal_CommunityPoolSpend `protobuf:"bytes,8,opt,name=community_pool_spend,json=communityPoolSpend,proto3,oneof" json:"community_pool_spend,omitempty"`
+}
+type Proposal_UpgradePlan_ struct {
+ UpgradePlan *Proposal_UpgradePlan `protobuf:"bytes,9,opt,name=upgrade_plan,json=upgradePlan,proto3,oneof" json:"upgrade_plan,omitempty"`
+}
+type Proposal_FreezeIbcClient_ struct {
+ FreezeIbcClient *Proposal_FreezeIbcClient `protobuf:"bytes,10,opt,name=freeze_ibc_client,json=freezeIbcClient,proto3,oneof" json:"freeze_ibc_client,omitempty"`
+}
+type Proposal_UnfreezeIbcClient_ struct {
+ UnfreezeIbcClient *Proposal_UnfreezeIbcClient `protobuf:"bytes,11,opt,name=unfreeze_ibc_client,json=unfreezeIbcClient,proto3,oneof" json:"unfreeze_ibc_client,omitempty"`
+}
+
+func (*Proposal_Signaling_) isProposal_Payload() {}
+func (*Proposal_Emergency_) isProposal_Payload() {}
+func (*Proposal_ParameterChange_) isProposal_Payload() {}
+func (*Proposal_CommunityPoolSpend_) isProposal_Payload() {}
+func (*Proposal_UpgradePlan_) isProposal_Payload() {}
+func (*Proposal_FreezeIbcClient_) isProposal_Payload() {}
+func (*Proposal_UnfreezeIbcClient_) isProposal_Payload() {}
+
+func (m *Proposal) GetPayload() isProposal_Payload {
+ if m != nil {
+ return m.Payload
+ }
+ return nil
+}
+
+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 x, ok := m.GetPayload().(*Proposal_Signaling_); ok {
+ return x.Signaling
+ }
+ return nil
+}
+
+func (m *Proposal) GetEmergency() *Proposal_Emergency {
+ if x, ok := m.GetPayload().(*Proposal_Emergency_); ok {
+ return x.Emergency
+ }
+ return nil
+}
+
+func (m *Proposal) GetParameterChange() *Proposal_ParameterChange {
+ if x, ok := m.GetPayload().(*Proposal_ParameterChange_); ok {
+ return x.ParameterChange
+ }
+ return nil
+}
+
+func (m *Proposal) GetCommunityPoolSpend() *Proposal_CommunityPoolSpend {
+ if x, ok := m.GetPayload().(*Proposal_CommunityPoolSpend_); ok {
+ return x.CommunityPoolSpend
+ }
+ return nil
+}
+
+func (m *Proposal) GetUpgradePlan() *Proposal_UpgradePlan {
+ if x, ok := m.GetPayload().(*Proposal_UpgradePlan_); ok {
+ return x.UpgradePlan
+ }
+ return nil
+}
+
+func (m *Proposal) GetFreezeIbcClient() *Proposal_FreezeIbcClient {
+ if x, ok := m.GetPayload().(*Proposal_FreezeIbcClient_); ok {
+ return x.FreezeIbcClient
+ }
+ return nil
+}
+
+func (m *Proposal) GetUnfreezeIbcClient() *Proposal_UnfreezeIbcClient {
+ if x, ok := m.GetPayload().(*Proposal_UnfreezeIbcClient_); ok {
+ return x.UnfreezeIbcClient
+ }
+ return nil
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*Proposal) XXX_OneofWrappers() []interface{} {
+ return []interface{}{
+ (*Proposal_Signaling_)(nil),
+ (*Proposal_Emergency_)(nil),
+ (*Proposal_ParameterChange_)(nil),
+ (*Proposal_CommunityPoolSpend_)(nil),
+ (*Proposal_UpgradePlan_)(nil),
+ (*Proposal_FreezeIbcClient_)(nil),
+ (*Proposal_UnfreezeIbcClient_)(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_a9098f9e68b782a3, []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_a9098f9e68b782a3, []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_a9098f9e68b782a3, []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_a9098f9e68b782a3, []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_a9098f9e68b782a3, []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.
+// Like `Emergency` proposals, it is enacted immediately after receiving
+// +2/3 of validator votes.
+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_a9098f9e68b782a3, []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.
+// Like `Emergency` proposals, it is enacted immediately after receiving
+// +2/3 of validator votes.
+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_a9098f9e68b782a3, []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 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_a9098f9e68b782a3, []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) 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_a9098f9e68b782a3, []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 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_a9098f9e68b782a3, []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) 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 *v1.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_a9098f9e68b782a3, []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() *v1.Amount {
+ if m != nil {
+ return m.ProposalDepositAmount
+ }
+ return nil
+}
+
+// Requests the validator rate data for a proposal.
+type ProposalRateDataRequest struct {
+ // 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_a9098f9e68b782a3, []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) GetProposalId() uint64 {
+ if m != nil {
+ return m.ProposalId
+ }
+ return 0
+}
+
+// The rate data for a single validator.
+type ProposalRateDataResponse struct {
+ RateData *v16.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_a9098f9e68b782a3, []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() *v16.RateData {
+ if m != nil {
+ return m.RateData
+ }
+ return nil
+}
+
+// Requests the list of all proposals.
+type ProposalListRequest struct {
+ // 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_a9098f9e68b782a3, []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) 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_a9098f9e68b782a3, []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 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_a9098f9e68b782a3, []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) 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 *v12.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_a9098f9e68b782a3, []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() *v12.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 *v1.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_a9098f9e68b782a3, []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() *v1.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_a9098f9e68b782a3, []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 {
+ // Sct module parameters.
+ SctParams *v14.SctParameters `protobuf:"bytes,1,opt,name=sct_params,json=sctParams,proto3" json:"sct_params,omitempty"`
+ // Community Pool module parameters.
+ CommunityPoolParams *v17.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 *v18.IbcParameters `protobuf:"bytes,4,opt,name=ibc_params,json=ibcParams,proto3" json:"ibc_params,omitempty"`
+ // Stake module parameters.
+ StakeParams *v16.StakeParameters `protobuf:"bytes,5,opt,name=stake_params,json=stakeParams,proto3" json:"stake_params,omitempty"`
+ // Fee module parameters.
+ FeeParams *v19.FeeParameters `protobuf:"bytes,6,opt,name=fee_params,json=feeParams,proto3" json:"fee_params,omitempty"`
+ // Distributions module parameters.
+ DistributionsParams *v110.DistributionsParameters `protobuf:"bytes,7,opt,name=distributions_params,json=distributionsParams,proto3" json:"distributions_params,omitempty"`
+ // Funding module parameters.
+ FundingParams *v111.FundingParameters `protobuf:"bytes,8,opt,name=funding_params,json=fundingParams,proto3" json:"funding_params,omitempty"`
+ // Shielded pool module parameters
+ ShieldedPoolParams *v15.ShieldedPoolParameters `protobuf:"bytes,9,opt,name=shielded_pool_params,json=shieldedPoolParams,proto3" json:"shielded_pool_params,omitempty"`
+ // DEX component parameters
+ DexParams *v112.DexParameters `protobuf:"bytes,10,opt,name=dex_params,json=dexParams,proto3" json:"dex_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_a9098f9e68b782a3, []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) GetSctParams() *v14.SctParameters {
+ if m != nil {
+ return m.SctParams
+ }
+ return nil
+}
+
+func (m *ChangedAppParameters) GetCommunityPoolParams() *v17.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() *v18.IbcParameters {
+ if m != nil {
+ return m.IbcParams
+ }
+ return nil
+}
+
+func (m *ChangedAppParameters) GetStakeParams() *v16.StakeParameters {
+ if m != nil {
+ return m.StakeParams
+ }
+ return nil
+}
+
+func (m *ChangedAppParameters) GetFeeParams() *v19.FeeParameters {
+ if m != nil {
+ return m.FeeParams
+ }
+ return nil
+}
+
+func (m *ChangedAppParameters) GetDistributionsParams() *v110.DistributionsParameters {
+ if m != nil {
+ return m.DistributionsParams
+ }
+ return nil
+}
+
+func (m *ChangedAppParameters) GetFundingParams() *v111.FundingParameters {
+ if m != nil {
+ return m.FundingParams
+ }
+ return nil
+}
+
+func (m *ChangedAppParameters) GetShieldedPoolParams() *v15.ShieldedPoolParameters {
+ if m != nil {
+ return m.ShieldedPoolParams
+ }
+ return nil
+}
+
+func (m *ChangedAppParameters) GetDexParams() *v112.DexParameters {
+ if m != nil {
+ return m.DexParams
+ }
+ 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_a9098f9e68b782a3, []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 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 *v12.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_a9098f9e68b782a3, []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) GetProposalId() uint64 {
+ if m != nil {
+ return m.ProposalId
+ }
+ return 0
+}
+
+func (m *VotingPowerAtProposalStartRequest) GetIdentityKey() *v12.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_a9098f9e68b782a3, []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 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_a9098f9e68b782a3, []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) 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 *v12.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_a9098f9e68b782a3, []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() *v12.IdentityKey {
+ if m != nil {
+ return m.IdentityKey
+ }
+ return nil
+}
+
+type NextProposalIdRequest struct {
+}
+
+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_a9098f9e68b782a3, []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
+
+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_a9098f9e68b782a3, []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
+}
+
+// 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_a9098f9e68b782a3, []int{39}
+}
+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
+}
+
+type EventDelegatorVote struct {
+ // The delegator vote.
+ Vote *DelegatorVote `protobuf:"bytes,1,opt,name=vote,proto3" json:"vote,omitempty"`
+}
+
+func (m *EventDelegatorVote) Reset() { *m = EventDelegatorVote{} }
+func (m *EventDelegatorVote) String() string { return proto.CompactTextString(m) }
+func (*EventDelegatorVote) ProtoMessage() {}
+func (*EventDelegatorVote) Descriptor() ([]byte, []int) {
+ return fileDescriptor_a9098f9e68b782a3, []int{40}
+}
+func (m *EventDelegatorVote) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *EventDelegatorVote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_EventDelegatorVote.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *EventDelegatorVote) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EventDelegatorVote.Merge(m, src)
+}
+func (m *EventDelegatorVote) XXX_Size() int {
+ return m.Size()
+}
+func (m *EventDelegatorVote) XXX_DiscardUnknown() {
+ xxx_messageInfo_EventDelegatorVote.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EventDelegatorVote proto.InternalMessageInfo
+
+func (m *EventDelegatorVote) GetVote() *DelegatorVote {
+ if m != nil {
+ return m.Vote
+ }
+ return nil
+}
+
+type EventProposalDepositClaim struct {
+ // The deposit claim body.
+ DepositClaim *ProposalDepositClaim `protobuf:"bytes,1,opt,name=deposit_claim,json=depositClaim,proto3" json:"deposit_claim,omitempty"`
+}
+
+func (m *EventProposalDepositClaim) Reset() { *m = EventProposalDepositClaim{} }
+func (m *EventProposalDepositClaim) String() string { return proto.CompactTextString(m) }
+func (*EventProposalDepositClaim) ProtoMessage() {}
+func (*EventProposalDepositClaim) Descriptor() ([]byte, []int) {
+ return fileDescriptor_a9098f9e68b782a3, []int{41}
+}
+func (m *EventProposalDepositClaim) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *EventProposalDepositClaim) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_EventProposalDepositClaim.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *EventProposalDepositClaim) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EventProposalDepositClaim.Merge(m, src)
+}
+func (m *EventProposalDepositClaim) XXX_Size() int {
+ return m.Size()
+}
+func (m *EventProposalDepositClaim) XXX_DiscardUnknown() {
+ xxx_messageInfo_EventProposalDepositClaim.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EventProposalDepositClaim proto.InternalMessageInfo
+
+func (m *EventProposalDepositClaim) GetDepositClaim() *ProposalDepositClaim {
+ if m != nil {
+ return m.DepositClaim
+ }
+ return nil
+}
+
+type EventValidatorVote struct {
+ // The validator vote.
+ Vote *ValidatorVote `protobuf:"bytes,1,opt,name=vote,proto3" json:"vote,omitempty"`
+}
+
+func (m *EventValidatorVote) Reset() { *m = EventValidatorVote{} }
+func (m *EventValidatorVote) String() string { return proto.CompactTextString(m) }
+func (*EventValidatorVote) ProtoMessage() {}
+func (*EventValidatorVote) Descriptor() ([]byte, []int) {
+ return fileDescriptor_a9098f9e68b782a3, []int{42}
+}
+func (m *EventValidatorVote) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *EventValidatorVote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_EventValidatorVote.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *EventValidatorVote) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EventValidatorVote.Merge(m, src)
+}
+func (m *EventValidatorVote) XXX_Size() int {
+ return m.Size()
+}
+func (m *EventValidatorVote) XXX_DiscardUnknown() {
+ xxx_messageInfo_EventValidatorVote.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EventValidatorVote proto.InternalMessageInfo
+
+func (m *EventValidatorVote) GetVote() *ValidatorVote {
+ if m != nil {
+ return m.Vote
+ }
+ return nil
+}
+
+type EventProposalWithdraw struct {
+ // Details on the withdrawn proposal.
+ Withdraw *ProposalWithdraw `protobuf:"bytes,1,opt,name=withdraw,proto3" json:"withdraw,omitempty"`
+}
+
+func (m *EventProposalWithdraw) Reset() { *m = EventProposalWithdraw{} }
+func (m *EventProposalWithdraw) String() string { return proto.CompactTextString(m) }
+func (*EventProposalWithdraw) ProtoMessage() {}
+func (*EventProposalWithdraw) Descriptor() ([]byte, []int) {
+ return fileDescriptor_a9098f9e68b782a3, []int{43}
+}
+func (m *EventProposalWithdraw) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *EventProposalWithdraw) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_EventProposalWithdraw.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *EventProposalWithdraw) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EventProposalWithdraw.Merge(m, src)
+}
+func (m *EventProposalWithdraw) XXX_Size() int {
+ return m.Size()
+}
+func (m *EventProposalWithdraw) XXX_DiscardUnknown() {
+ xxx_messageInfo_EventProposalWithdraw.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EventProposalWithdraw proto.InternalMessageInfo
+
+func (m *EventProposalWithdraw) GetWithdraw() *ProposalWithdraw {
+ if m != nil {
+ return m.Withdraw
+ }
+ return nil
+}
+
+type EventProposalSubmit struct {
+ // Details on the submitted proposal.
+ Submit *ProposalSubmit `protobuf:"bytes,1,opt,name=submit,proto3" json:"submit,omitempty"`
+}
+
+func (m *EventProposalSubmit) Reset() { *m = EventProposalSubmit{} }
+func (m *EventProposalSubmit) String() string { return proto.CompactTextString(m) }
+func (*EventProposalSubmit) ProtoMessage() {}
+func (*EventProposalSubmit) Descriptor() ([]byte, []int) {
+ return fileDescriptor_a9098f9e68b782a3, []int{44}
+}
+func (m *EventProposalSubmit) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *EventProposalSubmit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_EventProposalSubmit.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *EventProposalSubmit) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EventProposalSubmit.Merge(m, src)
+}
+func (m *EventProposalSubmit) XXX_Size() int {
+ return m.Size()
+}
+func (m *EventProposalSubmit) XXX_DiscardUnknown() {
+ xxx_messageInfo_EventProposalSubmit.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EventProposalSubmit proto.InternalMessageInfo
+
+func (m *EventProposalSubmit) GetSubmit() *ProposalSubmit {
+ if m != nil {
+ return m.Submit
+ }
+ return nil
+}
+
+type EventEnactProposal struct {
+ // The enacted proposal.
+ Proposal *Proposal `protobuf:"bytes,1,opt,name=proposal,proto3" json:"proposal,omitempty"`
+}
+
+func (m *EventEnactProposal) Reset() { *m = EventEnactProposal{} }
+func (m *EventEnactProposal) String() string { return proto.CompactTextString(m) }
+func (*EventEnactProposal) ProtoMessage() {}
+func (*EventEnactProposal) Descriptor() ([]byte, []int) {
+ return fileDescriptor_a9098f9e68b782a3, []int{45}
+}
+func (m *EventEnactProposal) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *EventEnactProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_EventEnactProposal.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *EventEnactProposal) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EventEnactProposal.Merge(m, src)
+}
+func (m *EventEnactProposal) XXX_Size() int {
+ return m.Size()
+}
+func (m *EventEnactProposal) XXX_DiscardUnknown() {
+ xxx_messageInfo_EventEnactProposal.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EventEnactProposal proto.InternalMessageInfo
+
+func (m *EventEnactProposal) GetProposal() *Proposal {
+ if m != nil {
+ return m.Proposal
+ }
+ return nil
+}
+
+type EventProposalFailed struct {
+ // The failed proposal.
+ Proposal *Proposal `protobuf:"bytes,1,opt,name=proposal,proto3" json:"proposal,omitempty"`
+}
+
+func (m *EventProposalFailed) Reset() { *m = EventProposalFailed{} }
+func (m *EventProposalFailed) String() string { return proto.CompactTextString(m) }
+func (*EventProposalFailed) ProtoMessage() {}
+func (*EventProposalFailed) Descriptor() ([]byte, []int) {
+ return fileDescriptor_a9098f9e68b782a3, []int{46}
+}
+func (m *EventProposalFailed) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *EventProposalFailed) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_EventProposalFailed.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *EventProposalFailed) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EventProposalFailed.Merge(m, src)
+}
+func (m *EventProposalFailed) XXX_Size() int {
+ return m.Size()
+}
+func (m *EventProposalFailed) XXX_DiscardUnknown() {
+ xxx_messageInfo_EventProposalFailed.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EventProposalFailed proto.InternalMessageInfo
+
+func (m *EventProposalFailed) GetProposal() *Proposal {
+ if m != nil {
+ return m.Proposal
+ }
+ return nil
+}
+
+type EventProposalSlashed struct {
+ // The slashed proposal.
+ Proposal *Proposal `protobuf:"bytes,1,opt,name=proposal,proto3" json:"proposal,omitempty"`
+}
+
+func (m *EventProposalSlashed) Reset() { *m = EventProposalSlashed{} }
+func (m *EventProposalSlashed) String() string { return proto.CompactTextString(m) }
+func (*EventProposalSlashed) ProtoMessage() {}
+func (*EventProposalSlashed) Descriptor() ([]byte, []int) {
+ return fileDescriptor_a9098f9e68b782a3, []int{47}
+}
+func (m *EventProposalSlashed) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *EventProposalSlashed) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_EventProposalSlashed.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *EventProposalSlashed) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EventProposalSlashed.Merge(m, src)
+}
+func (m *EventProposalSlashed) XXX_Size() int {
+ return m.Size()
+}
+func (m *EventProposalSlashed) XXX_DiscardUnknown() {
+ xxx_messageInfo_EventProposalSlashed.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EventProposalSlashed proto.InternalMessageInfo
+
+func (m *EventProposalSlashed) GetProposal() *Proposal {
+ if m != nil {
+ return m.Proposal
+ }
+ return nil
+}
+
+func init() {
+ proto.RegisterEnum("penumbra.core.component.governance.v1.Vote_Vote", Vote_Vote_name, Vote_Vote_value)
+ proto.RegisterType((*ZKDelegatorVoteProof)(nil), "penumbra.core.component.governance.v1.ZKDelegatorVoteProof")
+ proto.RegisterType((*ProposalSubmit)(nil), "penumbra.core.component.governance.v1.ProposalSubmit")
+ proto.RegisterType((*ProposalWithdraw)(nil), "penumbra.core.component.governance.v1.ProposalWithdraw")
+ proto.RegisterType((*ProposalDepositClaim)(nil), "penumbra.core.component.governance.v1.ProposalDepositClaim")
+ proto.RegisterType((*ValidatorVote)(nil), "penumbra.core.component.governance.v1.ValidatorVote")
+ proto.RegisterType((*ValidatorVoteReason)(nil), "penumbra.core.component.governance.v1.ValidatorVoteReason")
+ proto.RegisterType((*ValidatorVoteBody)(nil), "penumbra.core.component.governance.v1.ValidatorVoteBody")
+ proto.RegisterType((*DelegatorVote)(nil), "penumbra.core.component.governance.v1.DelegatorVote")
+ proto.RegisterType((*DelegatorVoteBody)(nil), "penumbra.core.component.governance.v1.DelegatorVoteBody")
+ proto.RegisterType((*DelegatorVoteView)(nil), "penumbra.core.component.governance.v1.DelegatorVoteView")
+ proto.RegisterType((*DelegatorVoteView_Visible)(nil), "penumbra.core.component.governance.v1.DelegatorVoteView.Visible")
+ proto.RegisterType((*DelegatorVoteView_Opaque)(nil), "penumbra.core.component.governance.v1.DelegatorVoteView.Opaque")
+ proto.RegisterType((*DelegatorVotePlan)(nil), "penumbra.core.component.governance.v1.DelegatorVotePlan")
+ proto.RegisterType((*CommunityPoolDeposit)(nil), "penumbra.core.component.governance.v1.CommunityPoolDeposit")
+ proto.RegisterType((*CommunityPoolSpend)(nil), "penumbra.core.component.governance.v1.CommunityPoolSpend")
+ proto.RegisterType((*CommunityPoolOutput)(nil), "penumbra.core.component.governance.v1.CommunityPoolOutput")
+ proto.RegisterType((*Vote)(nil), "penumbra.core.component.governance.v1.Vote")
+ proto.RegisterType((*ProposalState)(nil), "penumbra.core.component.governance.v1.ProposalState")
+ proto.RegisterType((*ProposalState_Voting)(nil), "penumbra.core.component.governance.v1.ProposalState.Voting")
+ proto.RegisterType((*ProposalState_Withdrawn)(nil), "penumbra.core.component.governance.v1.ProposalState.Withdrawn")
+ proto.RegisterType((*ProposalState_Finished)(nil), "penumbra.core.component.governance.v1.ProposalState.Finished")
+ proto.RegisterType((*ProposalState_Claimed)(nil), "penumbra.core.component.governance.v1.ProposalState.Claimed")
+ proto.RegisterType((*ProposalOutcome)(nil), "penumbra.core.component.governance.v1.ProposalOutcome")
+ proto.RegisterType((*ProposalOutcome_Withdrawn)(nil), "penumbra.core.component.governance.v1.ProposalOutcome.Withdrawn")
+ proto.RegisterType((*ProposalOutcome_Passed)(nil), "penumbra.core.component.governance.v1.ProposalOutcome.Passed")
+ proto.RegisterType((*ProposalOutcome_Failed)(nil), "penumbra.core.component.governance.v1.ProposalOutcome.Failed")
+ proto.RegisterType((*ProposalOutcome_Slashed)(nil), "penumbra.core.component.governance.v1.ProposalOutcome.Slashed")
+ proto.RegisterType((*Tally)(nil), "penumbra.core.component.governance.v1.Tally")
+ proto.RegisterType((*Proposal)(nil), "penumbra.core.component.governance.v1.Proposal")
+ proto.RegisterType((*Proposal_Signaling)(nil), "penumbra.core.component.governance.v1.Proposal.Signaling")
+ proto.RegisterType((*Proposal_Emergency)(nil), "penumbra.core.component.governance.v1.Proposal.Emergency")
+ proto.RegisterType((*Proposal_ParameterChange)(nil), "penumbra.core.component.governance.v1.Proposal.ParameterChange")
+ proto.RegisterType((*Proposal_CommunityPoolSpend)(nil), "penumbra.core.component.governance.v1.Proposal.CommunityPoolSpend")
+ proto.RegisterType((*Proposal_UpgradePlan)(nil), "penumbra.core.component.governance.v1.Proposal.UpgradePlan")
+ proto.RegisterType((*Proposal_FreezeIbcClient)(nil), "penumbra.core.component.governance.v1.Proposal.FreezeIbcClient")
+ proto.RegisterType((*Proposal_UnfreezeIbcClient)(nil), "penumbra.core.component.governance.v1.Proposal.UnfreezeIbcClient")
+ proto.RegisterType((*ProposalInfoRequest)(nil), "penumbra.core.component.governance.v1.ProposalInfoRequest")
+ proto.RegisterType((*ProposalInfoResponse)(nil), "penumbra.core.component.governance.v1.ProposalInfoResponse")
+ proto.RegisterType((*ProposalDataRequest)(nil), "penumbra.core.component.governance.v1.ProposalDataRequest")
+ proto.RegisterType((*ProposalDataResponse)(nil), "penumbra.core.component.governance.v1.ProposalDataResponse")
+ proto.RegisterType((*ProposalRateDataRequest)(nil), "penumbra.core.component.governance.v1.ProposalRateDataRequest")
+ proto.RegisterType((*ProposalRateDataResponse)(nil), "penumbra.core.component.governance.v1.ProposalRateDataResponse")
+ proto.RegisterType((*ProposalListRequest)(nil), "penumbra.core.component.governance.v1.ProposalListRequest")
+ proto.RegisterType((*ProposalListResponse)(nil), "penumbra.core.component.governance.v1.ProposalListResponse")
+ proto.RegisterType((*ValidatorVotesRequest)(nil), "penumbra.core.component.governance.v1.ValidatorVotesRequest")
+ proto.RegisterType((*ValidatorVotesResponse)(nil), "penumbra.core.component.governance.v1.ValidatorVotesResponse")
+ proto.RegisterType((*GovernanceParameters)(nil), "penumbra.core.component.governance.v1.GovernanceParameters")
+ proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.governance.v1.GenesisContent")
+ proto.RegisterType((*ChangedAppParameters)(nil), "penumbra.core.component.governance.v1.ChangedAppParameters")
+ proto.RegisterType((*ChangedAppParametersSet)(nil), "penumbra.core.component.governance.v1.ChangedAppParametersSet")
+ proto.RegisterType((*VotingPowerAtProposalStartRequest)(nil), "penumbra.core.component.governance.v1.VotingPowerAtProposalStartRequest")
+ proto.RegisterType((*VotingPowerAtProposalStartResponse)(nil), "penumbra.core.component.governance.v1.VotingPowerAtProposalStartResponse")
+ proto.RegisterType((*AllTalliedDelegatorVotesForProposalRequest)(nil), "penumbra.core.component.governance.v1.AllTalliedDelegatorVotesForProposalRequest")
+ proto.RegisterType((*AllTalliedDelegatorVotesForProposalResponse)(nil), "penumbra.core.component.governance.v1.AllTalliedDelegatorVotesForProposalResponse")
+ proto.RegisterType((*NextProposalIdRequest)(nil), "penumbra.core.component.governance.v1.NextProposalIdRequest")
+ proto.RegisterType((*NextProposalIdResponse)(nil), "penumbra.core.component.governance.v1.NextProposalIdResponse")
+ proto.RegisterType((*Ratio)(nil), "penumbra.core.component.governance.v1.Ratio")
+ proto.RegisterType((*EventDelegatorVote)(nil), "penumbra.core.component.governance.v1.EventDelegatorVote")
+ proto.RegisterType((*EventProposalDepositClaim)(nil), "penumbra.core.component.governance.v1.EventProposalDepositClaim")
+ proto.RegisterType((*EventValidatorVote)(nil), "penumbra.core.component.governance.v1.EventValidatorVote")
+ proto.RegisterType((*EventProposalWithdraw)(nil), "penumbra.core.component.governance.v1.EventProposalWithdraw")
+ proto.RegisterType((*EventProposalSubmit)(nil), "penumbra.core.component.governance.v1.EventProposalSubmit")
+ proto.RegisterType((*EventEnactProposal)(nil), "penumbra.core.component.governance.v1.EventEnactProposal")
+ proto.RegisterType((*EventProposalFailed)(nil), "penumbra.core.component.governance.v1.EventProposalFailed")
+ proto.RegisterType((*EventProposalSlashed)(nil), "penumbra.core.component.governance.v1.EventProposalSlashed")
+}
+
+func init() {
+ proto.RegisterFile("penumbra/core/component/governance/v1/governance.proto", fileDescriptor_a9098f9e68b782a3)
+}
+
+var fileDescriptor_a9098f9e68b782a3 = []byte{
+ // 3138 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5b, 0xcd, 0x8f, 0x1b, 0xc7,
+ 0xb1, 0xdf, 0xe1, 0x7e, 0x90, 0xac, 0x5d, 0x51, 0x54, 0x8b, 0x92, 0xd6, 0x7c, 0xf6, 0x3e, 0x79,
+ 0xfc, 0x04, 0xc8, 0xb6, 0xcc, 0x15, 0x65, 0x59, 0xd6, 0x5b, 0xd9, 0xd6, 0xdb, 0xa5, 0xf6, 0xeb,
+ 0xc9, 0x92, 0xa8, 0xa1, 0xb4, 0x8e, 0xed, 0x85, 0xe9, 0xe1, 0x4c, 0x93, 0x1c, 0x68, 0xd8, 0x43,
+ 0xcf, 0xf4, 0x50, 0xa2, 0x81, 0x1c, 0x02, 0x18, 0x08, 0x82, 0x20, 0x48, 0x2e, 0x41, 0xae, 0x81,
+ 0x91, 0x53, 0x0e, 0x02, 0x72, 0x4a, 0xfe, 0x04, 0x27, 0x08, 0x0c, 0x5f, 0x02, 0x38, 0xb7, 0x40,
+ 0xbe, 0x05, 0x30, 0x90, 0x53, 0xce, 0x41, 0x7f, 0xcc, 0x70, 0x86, 0x1f, 0xbb, 0x24, 0x41, 0x01,
+ 0x39, 0xe4, 0x22, 0xb1, 0x7b, 0xaa, 0x7e, 0x55, 0x5d, 0x55, 0x5d, 0x5d, 0xd5, 0x33, 0x0b, 0xd7,
+ 0xda, 0x98, 0xf8, 0xad, 0x9a, 0xab, 0xaf, 0x1b, 0x8e, 0x8b, 0xd7, 0x0d, 0xa7, 0xd5, 0x76, 0x08,
+ 0x26, 0x74, 0xbd, 0xe1, 0x74, 0xb0, 0x4b, 0x74, 0x62, 0xe0, 0xf5, 0x4e, 0x31, 0x32, 0x2a, 0xb4,
+ 0x5d, 0x87, 0x3a, 0xe8, 0x42, 0xc0, 0x57, 0x60, 0x7c, 0x85, 0x90, 0xaf, 0x10, 0xa1, 0xec, 0x14,
+ 0xf3, 0x2f, 0x34, 0x1c, 0xa7, 0x61, 0xe3, 0x75, 0xce, 0x54, 0xf3, 0xeb, 0xeb, 0x3a, 0xe9, 0x0a,
+ 0x84, 0xbc, 0x1a, 0x97, 0xac, 0x7b, 0x1e, 0xa6, 0x4c, 0x14, 0xff, 0x21, 0x69, 0xde, 0x1b, 0xa5,
+ 0x9d, 0xe1, 0xb4, 0x5a, 0x3e, 0xb1, 0x68, 0xb7, 0xda, 0x76, 0x1c, 0x9b, 0xb1, 0xc5, 0x67, 0x24,
+ 0xff, 0xc5, 0x51, 0xfc, 0x26, 0x7e, 0xc2, 0x98, 0x4c, 0xfc, 0x44, 0x52, 0xbe, 0x33, 0x92, 0xd2,
+ 0xf2, 0xa8, 0x6b, 0xd5, 0x7c, 0x6a, 0x39, 0xc4, 0xe3, 0x3c, 0xd1, 0x89, 0xe3, 0xe4, 0xd4, 0x31,
+ 0x37, 0x5f, 0x1d, 0x4b, 0xbb, 0xe5, 0x2f, 0x8f, 0xa4, 0xf4, 0x89, 0x69, 0x91, 0x06, 0xa7, 0x16,
+ 0x3f, 0x8f, 0xc3, 0xb6, 0x6a, 0x06, 0xa3, 0xb6, 0x6a, 0xc6, 0x71, 0x94, 0x9e, 0xc1, 0x2d, 0xeb,
+ 0x19, 0xf4, 0xb8, 0xd5, 0x7a, 0x4d, 0x0b, 0xdb, 0x26, 0x36, 0x43, 0xb3, 0xc6, 0x26, 0x24, 0xf7,
+ 0xa5, 0x91, 0xdc, 0x54, 0x7f, 0xc4, 0xd7, 0xcb, 0x7f, 0x48, 0xea, 0xf3, 0x71, 0xea, 0x47, 0xb8,
+ 0xcb, 0xcd, 0xc8, 0xfe, 0x97, 0x14, 0x6b, 0x71, 0x0a, 0xe2, 0xb7, 0x18, 0x01, 0xf1, 0x5b, 0xf2,
+ 0xf9, 0xd5, 0xde, 0x73, 0xb7, 0xdb, 0xa6, 0xce, 0xba, 0x89, 0x0d, 0xbd, 0xfe, 0xe6, 0xdb, 0x6f,
+ 0x57, 0x5d, 0xd3, 0xd3, 0x85, 0x1f, 0x23, 0x13, 0x82, 0x4b, 0xbd, 0x04, 0xb9, 0x8f, 0x6e, 0xdf,
+ 0xc2, 0x36, 0x6e, 0xe8, 0xd4, 0x71, 0x0f, 0x1c, 0x8a, 0xcb, 0xae, 0xe3, 0xd4, 0x51, 0x0e, 0x16,
+ 0x2d, 0x42, 0xb0, 0xbb, 0xaa, 0x9c, 0x57, 0x2e, 0xae, 0x68, 0x62, 0xa0, 0x7e, 0xa9, 0x40, 0xa6,
+ 0xec, 0x3a, 0x6d, 0xc7, 0xd3, 0xed, 0x8a, 0x5f, 0x6b, 0x59, 0x14, 0xdd, 0x86, 0x54, 0x5b, 0xce,
+ 0x70, 0xda, 0xe5, 0x2b, 0xeb, 0x85, 0xb1, 0xa2, 0xbe, 0x10, 0x00, 0x69, 0x21, 0x00, 0x2a, 0x41,
+ 0xc6, 0xc4, 0x6d, 0xc7, 0xb3, 0x68, 0x55, 0x6f, 0x39, 0x3e, 0xa1, 0xab, 0xf3, 0x1c, 0xf2, 0xc5,
+ 0x3e, 0x48, 0xb6, 0xea, 0x4e, 0xb1, 0xb0, 0xc9, 0x69, 0xb4, 0x13, 0x92, 0x47, 0x0c, 0xd5, 0x1d,
+ 0xc8, 0x06, 0xd0, 0x1f, 0x58, 0xb4, 0x69, 0xba, 0xfa, 0x63, 0x94, 0xef, 0xd3, 0x72, 0x21, 0x22,
+ 0xf4, 0x2c, 0x2c, 0xb9, 0x58, 0xf7, 0x1c, 0xb2, 0x9a, 0x38, 0xaf, 0x5c, 0x4c, 0x6b, 0x72, 0xa4,
+ 0xfe, 0x51, 0x81, 0x5c, 0x00, 0x74, 0x4b, 0x48, 0x28, 0xd9, 0xba, 0xd5, 0x3a, 0x12, 0x6c, 0x70,
+ 0x05, 0x89, 0x89, 0x57, 0x80, 0xca, 0x90, 0x74, 0x7c, 0x6a, 0x38, 0x2d, 0x2c, 0xd7, 0x7f, 0x6d,
+ 0x42, 0x93, 0xde, 0x13, 0xdc, 0x5a, 0x00, 0xa3, 0x3e, 0x55, 0xe0, 0xc4, 0x81, 0x6e, 0x5b, 0x66,
+ 0xe0, 0x65, 0xf4, 0x3e, 0x2c, 0xd4, 0x1c, 0xb3, 0x2b, 0x7d, 0x76, 0x7d, 0x4c, 0x01, 0x31, 0x8c,
+ 0x2d, 0xc7, 0xec, 0x6a, 0x1c, 0x05, 0xdd, 0x83, 0x94, 0xee, 0xd3, 0x66, 0xd5, 0xb3, 0x1a, 0x72,
+ 0xc1, 0x57, 0x23, 0x88, 0x3c, 0x1e, 0x0b, 0xf1, 0xf0, 0xeb, 0x14, 0x0b, 0x95, 0x36, 0x26, 0xe6,
+ 0xa6, 0x4f, 0x9b, 0x15, 0xab, 0x41, 0x74, 0xea, 0xbb, 0x58, 0x4b, 0xea, 0x62, 0xa8, 0xbe, 0x01,
+ 0xa7, 0x63, 0xb2, 0x34, 0xee, 0x93, 0x88, 0xaf, 0x94, 0x98, 0xaf, 0xbe, 0x4d, 0xc0, 0xa9, 0x01,
+ 0xdd, 0x8e, 0x74, 0xd4, 0x4d, 0x58, 0xe8, 0x38, 0x14, 0x4b, 0x6d, 0x5f, 0x1f, 0x77, 0xfd, 0x4c,
+ 0x15, 0xce, 0x88, 0xb6, 0x61, 0xc5, 0x32, 0x31, 0xa1, 0x2c, 0x99, 0x3e, 0xc2, 0x5d, 0xe9, 0x29,
+ 0xb5, 0x0f, 0x88, 0x6f, 0xe0, 0x4e, 0xb1, 0xb0, 0x2f, 0x49, 0x6f, 0xe3, 0xae, 0xb6, 0x6c, 0xf5,
+ 0x06, 0xe8, 0x36, 0x64, 0x7a, 0x22, 0x38, 0xd0, 0x02, 0x07, 0xfa, 0x9f, 0x11, 0x40, 0xbb, 0x21,
+ 0x31, 0x83, 0x3a, 0xd1, 0x88, 0x0e, 0x91, 0x16, 0x9a, 0x67, 0x91, 0x83, 0x6c, 0x4c, 0xe3, 0x56,
+ 0x61, 0xea, 0xd0, 0xb4, 0x3f, 0x4a, 0xc0, 0x89, 0x58, 0x82, 0x98, 0x32, 0x74, 0x62, 0x18, 0xcf,
+ 0x31, 0x74, 0xd0, 0x7d, 0x58, 0x6c, 0xb3, 0x1c, 0x26, 0x3d, 0x72, 0x63, 0x4c, 0xfd, 0x86, 0xa5,
+ 0x41, 0x4d, 0x20, 0xa9, 0xbf, 0x99, 0x87, 0x53, 0x03, 0xfa, 0x1f, 0x19, 0x5e, 0x17, 0x20, 0xe3,
+ 0x51, 0xdd, 0xa5, 0x55, 0xbe, 0xaf, 0x2d, 0x99, 0x5c, 0x16, 0xb4, 0x13, 0x7c, 0xb6, 0x2c, 0x27,
+ 0xc3, 0x28, 0x9c, 0x9f, 0x36, 0x0a, 0xdf, 0x84, 0xc5, 0x8e, 0x6e, 0xfb, 0x58, 0x46, 0xcd, 0x4b,
+ 0x7d, 0x08, 0xa2, 0x4c, 0x10, 0x1e, 0xf6, 0xb1, 0x26, 0x68, 0xd1, 0x36, 0x9c, 0xf4, 0x49, 0xcd,
+ 0x21, 0xec, 0xc4, 0x92, 0x59, 0x6a, 0x71, 0x8c, 0x2c, 0x95, 0x09, 0x98, 0x64, 0x9a, 0xda, 0x85,
+ 0x34, 0xf1, 0x6d, 0xdb, 0xaa, 0x5b, 0xd8, 0x5d, 0x5d, 0xe2, 0x00, 0xaf, 0x8e, 0x5c, 0x01, 0x3b,
+ 0x56, 0x3b, 0xc5, 0xc2, 0xdd, 0x80, 0x41, 0xeb, 0xf1, 0xa2, 0x1d, 0x48, 0xb8, 0x8f, 0x56, 0x93,
+ 0x03, 0xa9, 0xee, 0x28, 0xe7, 0x1f, 0x60, 0xd7, 0xaa, 0x5b, 0x86, 0xce, 0xcc, 0xc8, 0x76, 0x42,
+ 0xc2, 0x7d, 0xa4, 0xfe, 0xb3, 0xdf, 0x4d, 0x07, 0x16, 0x7e, 0x8c, 0x0e, 0x21, 0xd9, 0xb1, 0x3c,
+ 0xab, 0x66, 0x63, 0x19, 0xb1, 0xff, 0x37, 0x4d, 0xc4, 0x32, 0xa8, 0xc2, 0x81, 0xc0, 0xd9, 0x9b,
+ 0xd3, 0x02, 0x48, 0xf4, 0x21, 0x2c, 0x39, 0x6d, 0xfd, 0x33, 0x3f, 0xc8, 0x24, 0x37, 0xa7, 0x06,
+ 0xbf, 0xc7, 0x61, 0xf6, 0xe6, 0x34, 0x09, 0x98, 0x7f, 0xaa, 0x40, 0x52, 0x4a, 0x44, 0x1f, 0xb3,
+ 0x73, 0x45, 0x72, 0x54, 0x79, 0xc8, 0x28, 0x03, 0x7b, 0x65, 0x6c, 0x71, 0xec, 0xbc, 0x89, 0x6e,
+ 0xe8, 0x1d, 0x58, 0x20, 0xbd, 0x5c, 0x78, 0x65, 0xb4, 0x0f, 0x63, 0x65, 0x0e, 0xf3, 0xa6, 0xd4,
+ 0x5d, 0xe3, 0xfc, 0x79, 0x0c, 0x4b, 0x62, 0x11, 0xcf, 0x55, 0xdd, 0xad, 0x6c, 0x3f, 0xb8, 0xfa,
+ 0x97, 0x7e, 0xc7, 0x97, 0x6d, 0x9d, 0xfc, 0x5b, 0xec, 0xcf, 0x7b, 0xb0, 0xcc, 0xcb, 0x3c, 0xb3,
+ 0xca, 0x2d, 0x2c, 0x76, 0x69, 0x61, 0x32, 0x0b, 0x6b, 0x20, 0x20, 0xd8, 0x6f, 0x74, 0x19, 0x72,
+ 0x11, 0xc0, 0x9e, 0xfa, 0x8b, 0x5c, 0x7d, 0xd4, 0xa3, 0x0c, 0xd7, 0x30, 0x64, 0xb7, 0x2f, 0x4d,
+ 0xb1, 0xdb, 0xd7, 0x00, 0x5c, 0x9d, 0x98, 0x4e, 0xcb, 0xfa, 0x1c, 0xbb, 0x7c, 0xb3, 0xae, 0x68,
+ 0x91, 0x19, 0x74, 0x11, 0xb2, 0x3c, 0x59, 0x56, 0x6b, 0xb6, 0xc5, 0x2b, 0xf3, 0xaa, 0xbb, 0x9a,
+ 0xe2, 0x54, 0x19, 0x3e, 0xbf, 0x25, 0xa7, 0xb5, 0x21, 0x94, 0xde, 0x6a, 0x7a, 0x08, 0x65, 0x45,
+ 0xbd, 0x0d, 0xb9, 0x52, 0xd0, 0xb1, 0x94, 0x1d, 0x27, 0x28, 0xc3, 0x7a, 0x59, 0x4f, 0x19, 0x3f,
+ 0xeb, 0xa9, 0xfb, 0x80, 0x62, 0x60, 0x3c, 0x8d, 0x4c, 0x07, 0xf5, 0x85, 0x02, 0xa7, 0x63, 0x58,
+ 0xf7, 0x7c, 0xda, 0xf6, 0xa7, 0xd3, 0x0b, 0x5d, 0x87, 0xa4, 0x6e, 0x9a, 0x2e, 0xf6, 0x3c, 0xb9,
+ 0x01, 0xd7, 0x46, 0x1c, 0xfd, 0x9b, 0x82, 0x4a, 0x0b, 0xc8, 0xd5, 0x5f, 0x29, 0xb0, 0xc0, 0x37,
+ 0xf0, 0x2d, 0x19, 0xa6, 0x4c, 0x6c, 0xe6, 0xca, 0xe5, 0x09, 0xc2, 0x34, 0x12, 0xab, 0xea, 0xbe,
+ 0x44, 0xcb, 0x41, 0xf6, 0xe0, 0xde, 0x83, 0xed, 0xea, 0xc3, 0xbb, 0x95, 0xf2, 0x76, 0x69, 0x7f,
+ 0x67, 0x7f, 0xfb, 0x56, 0x76, 0x0e, 0x65, 0x61, 0x85, 0xcf, 0x6e, 0x6e, 0x55, 0x1e, 0x6c, 0xee,
+ 0xdf, 0xcd, 0x2a, 0x68, 0x05, 0x52, 0x7c, 0xe6, 0xc3, 0xed, 0x4a, 0x36, 0x81, 0x96, 0x21, 0xc9,
+ 0x47, 0x77, 0xef, 0x65, 0xe7, 0xd5, 0x7f, 0x2c, 0xc0, 0x89, 0xb0, 0x51, 0xa0, 0x3a, 0xc5, 0xe8,
+ 0x21, 0x2c, 0x75, 0x1c, 0x6a, 0x91, 0xe0, 0x90, 0xbf, 0x31, 0x61, 0x49, 0xcb, 0x51, 0x98, 0xb6,
+ 0x16, 0x69, 0xb0, 0x1c, 0x29, 0xc0, 0xd0, 0x27, 0x90, 0x7e, 0x2c, 0x8b, 0x7c, 0x22, 0x77, 0xe9,
+ 0x7b, 0x53, 0x21, 0x07, 0xad, 0x02, 0xd9, 0x9b, 0xd3, 0x7a, 0x90, 0xe8, 0x63, 0x48, 0xd5, 0x2d,
+ 0x62, 0x79, 0x4d, 0x6c, 0xca, 0xcd, 0xfb, 0xee, 0x54, 0xf0, 0x3b, 0x12, 0x64, 0x6f, 0x4e, 0x0b,
+ 0x01, 0xd1, 0x0f, 0x20, 0x69, 0xb0, 0x8e, 0x02, 0x9b, 0xf2, 0xfc, 0x7d, 0x67, 0x2a, 0xec, 0x92,
+ 0xc0, 0x60, 0xa7, 0x92, 0x84, 0xcb, 0xa7, 0x60, 0x49, 0x98, 0x2a, 0xff, 0x0a, 0xa4, 0xc3, 0xa5,
+ 0x8d, 0x2a, 0x9f, 0xf3, 0x87, 0x90, 0x0a, 0x14, 0x8c, 0x36, 0x1f, 0xca, 0x4c, 0x9a, 0x8f, 0xfc,
+ 0xc7, 0x90, 0x94, 0x2a, 0xce, 0x1e, 0x7c, 0x2b, 0x09, 0x8b, 0x1e, 0xb3, 0x82, 0xfa, 0x74, 0x01,
+ 0x4e, 0xf6, 0x51, 0xa1, 0x0f, 0x60, 0xa9, 0xcd, 0x36, 0x9d, 0x29, 0xa5, 0xbd, 0x3b, 0x9d, 0xb4,
+ 0x42, 0x99, 0x83, 0xb0, 0xb0, 0x13, 0x70, 0x0c, 0xb8, 0xae, 0x5b, 0x36, 0x36, 0x65, 0x34, 0x4f,
+ 0x0b, 0xbc, 0xc3, 0x41, 0x18, 0xb0, 0x80, 0x43, 0x1f, 0x41, 0xd2, 0xb3, 0x75, 0x1e, 0x6e, 0xd3,
+ 0x45, 0x73, 0x80, 0x5c, 0x11, 0x28, 0x2c, 0x28, 0x24, 0xe0, 0x78, 0xa1, 0x90, 0x82, 0x25, 0xb1,
+ 0xda, 0x7c, 0x13, 0x96, 0x84, 0x7a, 0xf1, 0x4d, 0x36, 0x59, 0x0d, 0xd5, 0xaf, 0x56, 0xa8, 0x40,
+ 0x64, 0x93, 0xe5, 0x2d, 0x48, 0x4a, 0x75, 0x9f, 0xb7, 0xa8, 0xad, 0x74, 0x18, 0x80, 0x6a, 0x09,
+ 0x16, 0x1f, 0xe8, 0xb6, 0xdd, 0x45, 0x59, 0x98, 0xef, 0x62, 0x4f, 0x96, 0x08, 0xec, 0x27, 0xca,
+ 0x40, 0x82, 0x38, 0xb2, 0x22, 0x48, 0x10, 0x07, 0xad, 0x42, 0x52, 0xaf, 0x79, 0x54, 0xb7, 0x44,
+ 0x8e, 0x59, 0xd0, 0x82, 0xa1, 0xfa, 0x67, 0x80, 0x54, 0x20, 0x98, 0xb1, 0x59, 0x22, 0x4d, 0x2c,
+ 0x68, 0x09, 0xcb, 0x44, 0x39, 0x58, 0xa4, 0x16, 0x95, 0x75, 0x67, 0x5a, 0x13, 0x03, 0x74, 0x1e,
+ 0x96, 0x4d, 0xec, 0x19, 0xae, 0xd5, 0x0e, 0xeb, 0x8e, 0xb4, 0x16, 0x9d, 0x42, 0x1f, 0x42, 0xda,
+ 0x63, 0x7d, 0x8d, 0xcd, 0xd2, 0xa5, 0xc8, 0x0c, 0xff, 0x3b, 0xa1, 0x11, 0x0a, 0x95, 0x00, 0x80,
+ 0xe5, 0xb3, 0x10, 0x8d, 0x41, 0xe3, 0x16, 0x76, 0x1b, 0x98, 0x18, 0x5d, 0x59, 0x06, 0x4c, 0x0c,
+ 0xbd, 0x1d, 0x00, 0x30, 0xe8, 0x10, 0x0d, 0xd9, 0x90, 0x6d, 0xeb, 0xae, 0xde, 0xc2, 0x14, 0xbb,
+ 0x55, 0xa3, 0xa9, 0x93, 0x06, 0x96, 0x35, 0xfd, 0xcd, 0x49, 0x25, 0x94, 0x03, 0x9c, 0x12, 0x87,
+ 0xd9, 0x9b, 0xd3, 0x4e, 0xb6, 0xe3, 0x53, 0xa8, 0x03, 0xb9, 0xf8, 0x65, 0x66, 0xd5, 0x63, 0xe7,
+ 0x39, 0x2f, 0x39, 0x96, 0xaf, 0x6c, 0x4d, 0x2a, 0x71, 0xb0, 0x32, 0xd8, 0x9b, 0xd3, 0x90, 0x31,
+ 0x58, 0x2f, 0x7c, 0x0a, 0x2b, 0x7e, 0xbb, 0xe1, 0xea, 0x26, 0xae, 0xb6, 0x6d, 0x9d, 0xf0, 0xc2,
+ 0x65, 0xf2, 0xd3, 0xac, 0xf0, 0x50, 0x60, 0xb0, 0x3a, 0x75, 0x6f, 0x4e, 0x5b, 0xf6, 0x7b, 0x43,
+ 0xd4, 0x82, 0x53, 0x75, 0x17, 0xe3, 0xcf, 0x71, 0xd5, 0xaa, 0x19, 0x55, 0xc3, 0xb6, 0x30, 0xa1,
+ 0xab, 0x30, 0x9d, 0x21, 0x77, 0x38, 0xd0, 0x7e, 0xcd, 0x28, 0x71, 0x18, 0x66, 0xc8, 0x7a, 0x7c,
+ 0x0a, 0x79, 0x70, 0xda, 0x27, 0x83, 0x02, 0x97, 0xb9, 0xc0, 0xcd, 0x89, 0xd7, 0x45, 0xea, 0x03,
+ 0x22, 0x4f, 0xf9, 0xfd, 0x93, 0x2c, 0x15, 0x85, 0x01, 0xca, 0x52, 0x11, 0x33, 0xb4, 0x45, 0x83,
+ 0x54, 0x24, 0x46, 0xf9, 0xd7, 0x20, 0x1d, 0x86, 0x1a, 0x7a, 0x09, 0xa0, 0xa9, 0xdb, 0x94, 0x05,
+ 0x96, 0x25, 0x32, 0x43, 0x4a, 0x4b, 0xb3, 0x99, 0x12, 0x9b, 0xc8, 0xff, 0x55, 0x81, 0x93, 0x7d,
+ 0x51, 0x83, 0x6a, 0x90, 0x71, 0x6c, 0xb3, 0x1a, 0x46, 0x8e, 0x27, 0x13, 0xca, 0xb8, 0xce, 0x12,
+ 0x30, 0xe6, 0x66, 0xbb, 0x1d, 0x22, 0x7b, 0xda, 0x09, 0xc7, 0x36, 0x7b, 0x43, 0x26, 0x83, 0xe0,
+ 0xc7, 0x51, 0x19, 0x89, 0x19, 0xc8, 0x20, 0xf8, 0x71, 0x6f, 0x98, 0x7f, 0x38, 0xb4, 0x70, 0xbd,
+ 0x09, 0x59, 0xea, 0xea, 0xc4, 0xd3, 0x0d, 0x96, 0x33, 0x44, 0x30, 0x0a, 0xd9, 0xb9, 0x82, 0x78,
+ 0x9f, 0x50, 0x08, 0xde, 0x27, 0x14, 0x36, 0x49, 0x57, 0x3b, 0x19, 0xa1, 0x66, 0x71, 0x96, 0xbf,
+ 0x00, 0xcb, 0x91, 0x28, 0x64, 0x5e, 0x68, 0x62, 0xab, 0xd1, 0xa4, 0x32, 0x11, 0xca, 0x51, 0xbe,
+ 0x00, 0x27, 0xfb, 0xa2, 0x08, 0xfd, 0x17, 0xa4, 0x45, 0x94, 0x54, 0x2d, 0x53, 0xfa, 0x2c, 0x25,
+ 0x26, 0xf6, 0xcd, 0xfc, 0x65, 0x38, 0x35, 0x10, 0x04, 0x47, 0x72, 0xb0, 0x9c, 0xdc, 0xd6, 0xbb,
+ 0xb6, 0xa3, 0x9b, 0xea, 0x35, 0x38, 0x1d, 0x84, 0xd2, 0x3e, 0xa9, 0x3b, 0x1a, 0xfe, 0xcc, 0xc7,
+ 0x1e, 0x45, 0xff, 0x0d, 0xcb, 0x41, 0xe7, 0xc6, 0x00, 0x44, 0x62, 0x86, 0x60, 0x6a, 0xdf, 0x54,
+ 0x1f, 0xf5, 0xae, 0x6a, 0x05, 0x9f, 0xd7, 0x76, 0x88, 0x87, 0xd1, 0x25, 0x40, 0xa2, 0xcd, 0xab,
+ 0xd9, 0x8e, 0xf1, 0xa8, 0x1a, 0x5b, 0x60, 0x96, 0x3f, 0xd9, 0x62, 0x0f, 0xf6, 0xf8, 0xfc, 0x98,
+ 0x4d, 0x61, 0x54, 0xc9, 0x5b, 0x3a, 0xd5, 0xc7, 0x56, 0xf2, 0x8b, 0xf9, 0xc8, 0x85, 0x32, 0x67,
+ 0x94, 0x5a, 0xce, 0xf4, 0x0e, 0x7d, 0xf8, 0x92, 0x13, 0x23, 0x96, 0x7c, 0x11, 0xb2, 0x98, 0x98,
+ 0x71, 0x5a, 0x71, 0xc4, 0x65, 0x30, 0x31, 0x8f, 0x36, 0xce, 0xc2, 0xb0, 0x8e, 0xf9, 0xff, 0x65,
+ 0x3d, 0x26, 0xcf, 0xad, 0xab, 0xd3, 0x54, 0xb4, 0x9a, 0x80, 0x40, 0x0f, 0xe0, 0x5c, 0x68, 0xd1,
+ 0xbe, 0x5b, 0xf5, 0x71, 0x3a, 0xd8, 0x33, 0xed, 0xf8, 0xed, 0xbd, 0x7c, 0x3f, 0xb0, 0x01, 0xe7,
+ 0x42, 0xb3, 0xe9, 0x14, 0x4f, 0xe4, 0x42, 0x03, 0x56, 0x07, 0x79, 0xa5, 0x17, 0x77, 0x21, 0xed,
+ 0xea, 0x14, 0x57, 0x4d, 0x9d, 0xea, 0xd2, 0x8d, 0xaf, 0x8d, 0x6e, 0xf4, 0xf9, 0xbb, 0x9f, 0x4e,
+ 0xb1, 0x10, 0xc2, 0xa4, 0x5c, 0xf9, 0x4b, 0x2d, 0xf6, 0xe2, 0xeb, 0x7d, 0xcb, 0xa3, 0x81, 0x72,
+ 0x79, 0x48, 0x59, 0x84, 0xed, 0xdf, 0x8e, 0xb8, 0xa9, 0x49, 0x69, 0xe1, 0x58, 0x7d, 0x9a, 0xe8,
+ 0x85, 0x96, 0xe0, 0xf9, 0x4f, 0x68, 0x1d, 0x15, 0x5a, 0xea, 0x75, 0x38, 0x13, 0xbb, 0xf4, 0xf6,
+ 0xc6, 0x0e, 0x81, 0x5f, 0x2b, 0x70, 0xb6, 0x9f, 0x55, 0x1a, 0xfb, 0x66, 0xa4, 0x0d, 0x9f, 0xc9,
+ 0x3b, 0x85, 0xc4, 0x54, 0xef, 0x14, 0xd4, 0xaf, 0x12, 0x90, 0xeb, 0xbd, 0x27, 0x88, 0x9c, 0x56,
+ 0x57, 0xe1, 0x6c, 0xb8, 0x38, 0xd1, 0x40, 0x0b, 0xf7, 0x04, 0xc5, 0x6f, 0x2e, 0x78, 0x2a, 0x9a,
+ 0x47, 0xee, 0x23, 0xef, 0xa8, 0x6d, 0x98, 0x98, 0x7a, 0x1b, 0xa2, 0x2b, 0x70, 0xa6, 0xa7, 0x0b,
+ 0xb3, 0x67, 0xf5, 0x33, 0xdf, 0x71, 0xfd, 0x16, 0x8f, 0x91, 0xb4, 0x76, 0x3a, 0x54, 0x85, 0x3d,
+ 0xbb, 0xcf, 0x1f, 0xa1, 0x6b, 0x11, 0x4d, 0x58, 0x27, 0x56, 0xa5, 0x4d, 0x17, 0x7b, 0x4d, 0xc7,
+ 0x16, 0x55, 0x77, 0xba, 0x27, 0x8b, 0xf5, 0x30, 0x0f, 0x82, 0x87, 0xe8, 0x3a, 0xac, 0x86, 0x7c,
+ 0xbc, 0x1b, 0x8a, 0x30, 0x2e, 0x72, 0xc6, 0xd0, 0x2e, 0xbc, 0x11, 0x09, 0x39, 0xd5, 0xcf, 0x21,
+ 0xb3, 0x8b, 0x09, 0xf6, 0x2c, 0xaf, 0xe4, 0x10, 0xca, 0x8e, 0xb2, 0x26, 0x9c, 0x8a, 0xbc, 0xb0,
+ 0xe1, 0x07, 0xff, 0xa4, 0x85, 0xc5, 0x30, 0xdf, 0x68, 0xd9, 0x46, 0x7c, 0xd6, 0x53, 0xbf, 0x4e,
+ 0x42, 0x6e, 0x58, 0x7d, 0x80, 0xde, 0x07, 0xf0, 0x0c, 0x1a, 0x97, 0xfd, 0xc6, 0x71, 0x37, 0xef,
+ 0x15, 0x83, 0x46, 0xa4, 0xa5, 0x3d, 0x39, 0xf4, 0x50, 0x07, 0xce, 0xf4, 0x55, 0xd2, 0x12, 0x38,
+ 0x71, 0x4c, 0x29, 0xdd, 0xf7, 0x31, 0x01, 0xab, 0x66, 0xa2, 0x65, 0x4a, 0x44, 0xda, 0x69, 0x63,
+ 0xe0, 0x81, 0x37, 0xdc, 0x90, 0xf3, 0xcf, 0xc1, 0x90, 0xcc, 0x5e, 0xac, 0xb2, 0x95, 0x22, 0x16,
+ 0x8e, 0xb1, 0x97, 0x55, 0x33, 0xf8, 0xee, 0xaa, 0x19, 0x51, 0x7b, 0x59, 0x72, 0xc8, 0xb6, 0xc3,
+ 0x0a, 0xcf, 0xde, 0x01, 0x9e, 0xc8, 0x46, 0xc5, 0xe3, 0x53, 0x7d, 0x85, 0xfd, 0x88, 0x60, 0x8a,
+ 0x9b, 0xe1, 0x9e, 0x8e, 0x75, 0x1c, 0x62, 0x2e, 0x1d, 0xa3, 0x63, 0x1d, 0x73, 0xc4, 0x1d, 0x1c,
+ 0xc5, 0x4b, 0xd7, 0x71, 0x80, 0x46, 0x21, 0x17, 0xfb, 0x02, 0x23, 0xc0, 0x4d, 0x1e, 0x53, 0xd5,
+ 0xc7, 0x3f, 0xdb, 0xe8, 0x14, 0x0b, 0xb7, 0xa2, 0x13, 0x51, 0x8f, 0x9a, 0x03, 0x0f, 0x3c, 0x74,
+ 0x08, 0x19, 0xf9, 0x55, 0x46, 0x20, 0x4f, 0x74, 0x63, 0x6f, 0x8d, 0x5e, 0x87, 0xfc, 0x88, 0x83,
+ 0xad, 0x45, 0xfc, 0x8c, 0x96, 0xc1, 0xf5, 0xc8, 0x94, 0x87, 0x5c, 0xc8, 0xc5, 0xae, 0xc7, 0x03,
+ 0x19, 0xe9, 0x63, 0x6e, 0x09, 0x06, 0xee, 0xd4, 0x2b, 0x72, 0xa2, 0x2f, 0x48, 0x91, 0xd7, 0x3f,
+ 0xcf, 0xbd, 0x62, 0xe2, 0x27, 0x81, 0x24, 0x38, 0xc6, 0x2b, 0x26, 0x7e, 0x22, 0x5e, 0x5e, 0x3c,
+ 0x89, 0x7a, 0xc5, 0x94, 0x43, 0x4f, 0xfd, 0xbd, 0x02, 0xe7, 0x86, 0x6d, 0xe8, 0x0a, 0xa6, 0xe8,
+ 0x0e, 0xcc, 0xb3, 0x6c, 0x34, 0x83, 0x0e, 0x85, 0xe1, 0x30, 0x38, 0x82, 0x1f, 0xcf, 0xa2, 0x19,
+ 0x61, 0x38, 0xea, 0x4f, 0x15, 0x78, 0x59, 0x9c, 0x09, 0x65, 0xe7, 0x31, 0x76, 0x37, 0x69, 0xe4,
+ 0x50, 0x75, 0xe9, 0xb8, 0x67, 0xe7, 0x8c, 0xde, 0x99, 0xab, 0xbb, 0xa0, 0x1e, 0xa5, 0x8c, 0x3c,
+ 0x8d, 0x5f, 0x86, 0x15, 0x79, 0xc6, 0xb5, 0x19, 0x99, 0x3c, 0xe2, 0x96, 0x3b, 0x3d, 0x4e, 0xf5,
+ 0x0e, 0xbc, 0xb6, 0x69, 0xdb, 0x0f, 0x74, 0xdb, 0xb6, 0xb0, 0x19, 0x7b, 0x81, 0xe4, 0xed, 0x38,
+ 0x6e, 0x58, 0x01, 0x8d, 0x5b, 0x1a, 0xfc, 0x41, 0x81, 0xd7, 0xc7, 0xc2, 0x93, 0x1a, 0x6e, 0xc1,
+ 0x22, 0xd5, 0x6d, 0x3b, 0x78, 0x93, 0x7e, 0x69, 0x4c, 0x37, 0xf1, 0x5b, 0x2b, 0x4d, 0xb0, 0xce,
+ 0xaa, 0x64, 0x38, 0x07, 0x67, 0xee, 0xe2, 0x27, 0xa1, 0x25, 0xf7, 0x4d, 0xb9, 0x68, 0x75, 0x0b,
+ 0xce, 0xf6, 0x3f, 0x90, 0xda, 0x5f, 0x84, 0x2c, 0xc1, 0x4f, 0x68, 0x35, 0x6a, 0x13, 0x61, 0xe3,
+ 0x0c, 0x89, 0x71, 0xa8, 0xbb, 0xb0, 0xa8, 0xe9, 0xd4, 0x72, 0xd0, 0x8b, 0x90, 0x26, 0x7e, 0x0b,
+ 0xbb, 0xcc, 0x2a, 0x92, 0xb6, 0x37, 0x21, 0x2e, 0xc6, 0x88, 0xd3, 0xb2, 0x08, 0x7f, 0x2e, 0xec,
+ 0x1b, 0x9d, 0x52, 0x3f, 0x01, 0xb4, 0xdd, 0xc1, 0x84, 0xc6, 0xbf, 0x47, 0xd8, 0x8b, 0x95, 0x5d,
+ 0xd3, 0xbd, 0x62, 0x14, 0x6f, 0x40, 0x7e, 0x08, 0x2f, 0x70, 0xfc, 0xa1, 0x9f, 0xfd, 0x7c, 0x0a,
+ 0xc1, 0x67, 0x3a, 0x55, 0x7e, 0xcd, 0x3e, 0xe1, 0x5e, 0x1d, 0x86, 0xa9, 0xad, 0x98, 0x91, 0x51,
+ 0xb8, 0xbc, 0xf8, 0x97, 0x3a, 0xd3, 0x2d, 0x2f, 0xfe, 0x49, 0x87, 0x58, 0x9e, 0x0d, 0x67, 0x62,
+ 0xcb, 0x0b, 0x3f, 0x8f, 0xaa, 0x40, 0x2a, 0xb8, 0x22, 0x95, 0x62, 0xde, 0x9e, 0x70, 0x55, 0x01,
+ 0x94, 0x16, 0x02, 0xa9, 0x26, 0x9c, 0x8e, 0x49, 0x93, 0x1f, 0x8c, 0xdd, 0x81, 0x25, 0x8f, 0xff,
+ 0x92, 0x92, 0xde, 0x9a, 0xb4, 0x8c, 0xe7, 0xcc, 0x9a, 0x04, 0x51, 0x75, 0x69, 0xb3, 0x6d, 0xd6,
+ 0x0a, 0x85, 0x37, 0xb1, 0xb3, 0x6c, 0x7b, 0xd4, 0x5a, 0xdf, 0x42, 0xe4, 0xad, 0xf8, 0x4c, 0x65,
+ 0x18, 0x90, 0x8b, 0x1b, 0x4b, 0xde, 0x87, 0xcf, 0x52, 0xc8, 0x95, 0xef, 0xd3, 0xb0, 0x72, 0xdf,
+ 0xc7, 0x6e, 0xb7, 0x82, 0xdd, 0x8e, 0x65, 0x60, 0xf4, 0x63, 0x05, 0x56, 0xa2, 0xf7, 0x26, 0x68,
+ 0x63, 0x42, 0xf0, 0xc8, 0x25, 0x4d, 0xfe, 0xc6, 0x54, 0xbc, 0x32, 0x99, 0xfc, 0x24, 0xa2, 0x09,
+ 0x6b, 0x60, 0x27, 0xd6, 0x24, 0xd2, 0x29, 0x4f, 0xac, 0x49, 0xb4, 0x63, 0xbe, 0xac, 0xc4, 0xac,
+ 0xc2, 0x1a, 0xf2, 0x89, 0x75, 0x89, 0x5c, 0x29, 0x4c, 0xac, 0x4b, 0xec, 0x4a, 0xe1, 0x67, 0x0a,
+ 0x64, 0xe2, 0xd9, 0x17, 0x8d, 0xfb, 0x8a, 0x70, 0x68, 0x36, 0xcf, 0xbf, 0x3b, 0x25, 0xb7, 0xd4,
+ 0xe7, 0xe7, 0x0a, 0x64, 0xe2, 0xbd, 0xef, 0xd8, 0xfa, 0x0c, 0xed, 0xb6, 0xc7, 0xd6, 0x67, 0x78,
+ 0xc3, 0x7d, 0x59, 0x41, 0xbf, 0x53, 0x20, 0x3f, 0xba, 0x16, 0x40, 0x7b, 0xe3, 0xf7, 0xe0, 0x47,
+ 0xd7, 0x36, 0xf9, 0xfd, 0x19, 0x20, 0x49, 0x2b, 0x7e, 0xad, 0xc0, 0x2b, 0x63, 0x94, 0x09, 0xe8,
+ 0xfe, 0x98, 0x22, 0xc7, 0x2f, 0x61, 0xf2, 0xda, 0x2c, 0x21, 0x43, 0x27, 0xfc, 0x52, 0xe9, 0x7d,
+ 0x72, 0x1b, 0xdc, 0x67, 0xa1, 0x49, 0x5f, 0x5c, 0xf6, 0xdd, 0xc5, 0xe5, 0x6f, 0x4e, 0xcd, 0x1f,
+ 0xe8, 0xb5, 0xf5, 0x7d, 0xe2, 0xab, 0x67, 0x6b, 0xca, 0x37, 0xcf, 0xd6, 0x94, 0xbf, 0x3d, 0x5b,
+ 0x53, 0x7e, 0xf1, 0xdd, 0xda, 0xdc, 0x37, 0xdf, 0xad, 0xcd, 0x7d, 0xfb, 0xdd, 0xda, 0x1c, 0xbc,
+ 0x6a, 0x38, 0xad, 0xf1, 0x04, 0x6c, 0x9d, 0x8c, 0x74, 0x99, 0xae, 0x43, 0x9d, 0xb2, 0xf2, 0xd1,
+ 0x27, 0x0d, 0x8b, 0x36, 0xfd, 0x1a, 0x63, 0x59, 0x37, 0x1c, 0xaf, 0xe5, 0x78, 0xeb, 0x2e, 0xb6,
+ 0xf5, 0x2e, 0x76, 0xd7, 0x3b, 0x57, 0xc2, 0x9f, 0xfc, 0x55, 0x85, 0xb7, 0x3e, 0xd6, 0xdf, 0x0e,
+ 0xdc, 0xe8, 0x8d, 0x3a, 0xc5, 0x2f, 0x13, 0x0b, 0xe5, 0x52, 0x69, 0xf7, 0xb7, 0x89, 0x0b, 0xe5,
+ 0x40, 0xc3, 0x12, 0xd3, 0xb0, 0x14, 0x6a, 0xd8, 0x53, 0xa9, 0x70, 0x50, 0xfc, 0x53, 0x8f, 0xee,
+ 0x90, 0xd1, 0x1d, 0x86, 0x74, 0x87, 0x3d, 0xba, 0xc3, 0x83, 0xe2, 0xb3, 0x44, 0x71, 0x2c, 0xba,
+ 0xc3, 0xdd, 0xf2, 0xd6, 0x1d, 0x4c, 0x75, 0x53, 0xa7, 0xfa, 0xdf, 0x13, 0xaf, 0x06, 0x3c, 0x1b,
+ 0x1b, 0x8c, 0x89, 0xfd, 0x2b, 0xb9, 0x36, 0x36, 0x7a, 0x6c, 0x1b, 0x1b, 0x07, 0xc5, 0xda, 0x12,
+ 0x7f, 0xe1, 0xf0, 0xe6, 0xbf, 0x02, 0x00, 0x00, 0xff, 0xff, 0xc9, 0xcc, 0x34, 0x1d, 0x2f, 0x31,
+ 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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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/v1/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.Payload != nil {
+ {
+ size := m.Payload.Size()
+ i -= size
+ if _, err := m.Payload.MarshalTo(dAtA[i:]); err != nil {
+ return 0, err
+ }
+ }
+ }
+ 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_) 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)
+ 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
+ }
+ return len(dAtA) - i, 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)
+ 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
+ }
+ return len(dAtA) - i, 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)
+ 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
+ }
+ return len(dAtA) - i, 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)
+ 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
+ }
+ return len(dAtA) - i, 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)
+ 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
+ }
+ return len(dAtA) - i, 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)
+ 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
+ }
+ return len(dAtA) - i, 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)
+ 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
+ }
+ 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
+ }
+ 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
+ }
+ 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
+ }
+ 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
+ }
+ 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
+ }
+ 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.DexParams != nil {
+ {
+ size, err := m.DexParams.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintGovernance(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x52
+ }
+ if m.ShieldedPoolParams != nil {
+ {
+ size, err := m.ShieldedPoolParams.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintGovernance(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x4a
+ }
+ if m.FundingParams != nil {
+ {
+ size, err := m.FundingParams.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintGovernance(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x42
+ }
+ 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.SctParams != nil {
+ {
+ size, err := m.SctParams.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
+ }
+ 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
+ }
+ 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
+ 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 (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 = encodeVarintGovernance(dAtA, i, uint64(m.Denominator))
+ i--
+ dAtA[i] = 0x10
+ }
+ if m.Numerator != 0 {
+ i = encodeVarintGovernance(dAtA, i, uint64(m.Numerator))
+ i--
+ dAtA[i] = 0x8
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *EventDelegatorVote) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *EventDelegatorVote) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EventDelegatorVote) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ 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 *EventProposalDepositClaim) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *EventProposalDepositClaim) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EventProposalDepositClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.DepositClaim != nil {
+ {
+ size, err := m.DepositClaim.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 *EventValidatorVote) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *EventValidatorVote) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EventValidatorVote) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ 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 *EventProposalWithdraw) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *EventProposalWithdraw) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EventProposalWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.Withdraw != nil {
+ {
+ size, err := m.Withdraw.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 *EventProposalSubmit) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *EventProposalSubmit) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EventProposalSubmit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.Submit != nil {
+ {
+ size, err := m.Submit.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 *EventEnactProposal) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *EventEnactProposal) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EventEnactProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ 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 *EventProposalFailed) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *EventProposalFailed) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EventProposalFailed) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ 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 *EventProposalSlashed) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *EventProposalSlashed) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EventProposalSlashed) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ 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 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.Payload != nil {
+ n += m.Payload.Size()
+ }
+ return n
+}
+
+func (m *Proposal_Signaling_) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.Signaling != nil {
+ l = m.Signaling.Size()
+ 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.Emergency != nil {
+ l = m.Emergency.Size()
+ n += 1 + l + sovGovernance(uint64(l))
+ }
+ return n
+}
+func (m *Proposal_ParameterChange_) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.ParameterChange != nil {
+ l = m.ParameterChange.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.CommunityPoolSpend != nil {
+ l = m.CommunityPoolSpend.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.UpgradePlan != nil {
+ l = m.UpgradePlan.Size()
+ n += 1 + l + sovGovernance(uint64(l))
+ }
+ return n
+}
+func (m *Proposal_FreezeIbcClient_) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.FreezeIbcClient != nil {
+ l = m.FreezeIbcClient.Size()
+ n += 1 + l + sovGovernance(uint64(l))
+ }
+ return n
+}
+func (m *Proposal_UnfreezeIbcClient_) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = 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
+ 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
+ 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
+ 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
+ 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
+ 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.SctParams != nil {
+ l = m.SctParams.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))
+ }
+ if m.FundingParams != nil {
+ l = m.FundingParams.Size()
+ n += 1 + l + sovGovernance(uint64(l))
+ }
+ if m.ShieldedPoolParams != nil {
+ l = m.ShieldedPoolParams.Size()
+ n += 1 + l + sovGovernance(uint64(l))
+ }
+ if m.DexParams != nil {
+ l = m.DexParams.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
+ 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
+ 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
+ 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 (m *Ratio) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.Numerator != 0 {
+ n += 1 + sovGovernance(uint64(m.Numerator))
+ }
+ if m.Denominator != 0 {
+ n += 1 + sovGovernance(uint64(m.Denominator))
+ }
+ return n
+}
+
+func (m *EventDelegatorVote) 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))
+ }
+ return n
+}
+
+func (m *EventProposalDepositClaim) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.DepositClaim != nil {
+ l = m.DepositClaim.Size()
+ n += 1 + l + sovGovernance(uint64(l))
+ }
+ return n
+}
+
+func (m *EventValidatorVote) 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))
+ }
+ return n
+}
+
+func (m *EventProposalWithdraw) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.Withdraw != nil {
+ l = m.Withdraw.Size()
+ n += 1 + l + sovGovernance(uint64(l))
+ }
+ return n
+}
+
+func (m *EventProposalSubmit) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.Submit != nil {
+ l = m.Submit.Size()
+ n += 1 + l + sovGovernance(uint64(l))
+ }
+ return n
+}
+
+func (m *EventEnactProposal) 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))
+ }
+ return n
+}
+
+func (m *EventProposalFailed) 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))
+ }
+ return n
+}
+
+func (m *EventProposalSlashed) 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))
+ }
+ 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 = &v1.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 = &v1.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 = &v11.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 = &v12.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 = &v12.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 = &v11.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 = &v13.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 = &v1.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 = &v14.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 = &v11.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 = &v15.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 = &v15.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 = &v1.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 = &v13.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 = &v13.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 = &v13.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 = &v12.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
+ }
+ v := &Proposal_Signaling{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ m.Payload = &Proposal_Signaling_{v}
+ 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
+ }
+ v := &Proposal_Emergency{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ m.Payload = &Proposal_Emergency_{v}
+ 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
+ }
+ v := &Proposal_ParameterChange{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ m.Payload = &Proposal_ParameterChange_{v}
+ 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
+ }
+ v := &Proposal_CommunityPoolSpend{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ m.Payload = &Proposal_CommunityPoolSpend_{v}
+ 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
+ }
+ v := &Proposal_UpgradePlan{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ m.Payload = &Proposal_UpgradePlan_{v}
+ 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
+ }
+ v := &Proposal_FreezeIbcClient{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ m.Payload = &Proposal_FreezeIbcClient_{v}
+ 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
+ }
+ v := &Proposal_UnfreezeIbcClient{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ m.Payload = &Proposal_UnfreezeIbcClient_{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 *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 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 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 = &v1.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 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 = &v16.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 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 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 = &v12.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 = &v1.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 SctParams", 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.SctParams == nil {
+ m.SctParams = &v14.SctParameters{}
+ }
+ if err := m.SctParams.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 = &v17.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 = &v18.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 = &v16.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 = &v19.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 = &v110.DistributionsParameters{}
+ }
+ if err := m.DistributionsParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 8:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FundingParams", 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.FundingParams == nil {
+ m.FundingParams = &v111.FundingParameters{}
+ }
+ if err := m.FundingParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 9:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ShieldedPoolParams", 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.ShieldedPoolParams == nil {
+ m.ShieldedPoolParams = &v15.ShieldedPoolParameters{}
+ }
+ if err := m.ShieldedPoolParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 10:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DexParams", 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.DexParams == nil {
+ m.DexParams = &v112.DexParameters{}
+ }
+ if err := m.DexParams.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 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 = &v12.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 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 = &v12.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 {
+ 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 (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 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: 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 ErrIntOverflowGovernance
+ }
+ 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 ErrIntOverflowGovernance
+ }
+ 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 := 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 *EventDelegatorVote) Unmarshal(dAtA []byte) 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: EventDelegatorVote: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EventDelegatorVote: 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 = &DelegatorVote{}
+ }
+ if err := m.Vote.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 *EventProposalDepositClaim) Unmarshal(dAtA []byte) 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: EventProposalDepositClaim: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EventProposalDepositClaim: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DepositClaim", 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.DepositClaim == nil {
+ m.DepositClaim = &ProposalDepositClaim{}
+ }
+ if err := m.DepositClaim.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 *EventValidatorVote) Unmarshal(dAtA []byte) 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: EventValidatorVote: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EventValidatorVote: 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 = &ValidatorVote{}
+ }
+ if err := m.Vote.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 *EventProposalWithdraw) Unmarshal(dAtA []byte) 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: EventProposalWithdraw: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EventProposalWithdraw: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Withdraw", 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.Withdraw == nil {
+ m.Withdraw = &ProposalWithdraw{}
+ }
+ if err := m.Withdraw.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 *EventProposalSubmit) Unmarshal(dAtA []byte) 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: EventProposalSubmit: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EventProposalSubmit: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Submit", 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.Submit == nil {
+ m.Submit = &ProposalSubmit{}
+ }
+ if err := m.Submit.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 *EventEnactProposal) Unmarshal(dAtA []byte) 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: EventEnactProposal: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EventEnactProposal: 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
+ 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 *EventProposalFailed) Unmarshal(dAtA []byte) 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: EventProposalFailed: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EventProposalFailed: 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
+ 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 *EventProposalSlashed) Unmarshal(dAtA []byte) 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: EventProposalSlashed: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: EventProposalSlashed: 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
+ 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/v1/ibc.pb.go
similarity index 69%
rename from relayer/chains/penumbra/core/ibc/v1alpha1/ibc.pb.go
rename to relayer/chains/penumbra/core/component/ibc/v1/ibc.pb.go
index 8bf6ff767..1b01d2a31 100644
--- a/relayer/chains/penumbra/core/ibc/v1alpha1/ibc.pb.go
+++ b/relayer/chains/penumbra/core/component/ibc/v1/ibc.pb.go
@@ -1,14 +1,16 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: penumbra/core/ibc/v1alpha1/ibc.proto
+// source: penumbra/core/component/ibc/v1/ibc.proto
-package ibcv1alpha1
+package ibcv1
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"
+ v11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/asset/v1"
+ v12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/keys/v1"
+ v1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/num/v1"
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_2bed36356ff7581e, []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,17 +79,19 @@ 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"`
+ // optional memo
+ Memo string `protobuf:"bytes,5,opt,name=memo,proto3" json:"memo,omitempty"`
}
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_2bed36356ff7581e, []int{1}
}
func (m *FungibleTokenPacketData) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -167,20 +148,25 @@ func (m *FungibleTokenPacketData) GetReceiver() string {
return ""
}
+func (m *FungibleTokenPacketData) GetMemo() string {
+ if m != nil {
+ return m.Memo
+ }
+ 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"`
+ Amount *v1.Amount `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount,omitempty"`
+ Denom *v11.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 *v12.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 +177,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_2bed36356ff7581e, []int{2}
}
func (m *Ics20Withdrawal) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -220,14 +206,14 @@ func (m *Ics20Withdrawal) XXX_DiscardUnknown() {
var xxx_messageInfo_Ics20Withdrawal proto.InternalMessageInfo
-func (m *Ics20Withdrawal) GetAmount() *v1alpha1.Amount {
+func (m *Ics20Withdrawal) GetAmount() *v1.Amount {
if m != nil {
return m.Amount
}
return nil
}
-func (m *Ics20Withdrawal) GetDenom() *v1alpha1.Denom {
+func (m *Ics20Withdrawal) GetDenom() *v11.Denom {
if m != nil {
return m.Denom
}
@@ -241,18 +227,18 @@ func (m *Ics20Withdrawal) GetDestinationChainAddress() string {
return ""
}
-func (m *Ics20Withdrawal) GetReturnAddress() *v1alpha1.Address {
+func (m *Ics20Withdrawal) GetReturnAddress() *v12.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 +266,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_2bed36356ff7581e, []int{3}
}
func (m *ClientData) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -345,7 +331,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_2bed36356ff7581e, []int{4}
}
func (m *ClientCounter) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -389,7 +375,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_2bed36356ff7581e, []int{5}
}
func (m *ConsensusState) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -433,7 +419,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_2bed36356ff7581e, []int{6}
}
func (m *VerifiedHeights) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -477,7 +463,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_2bed36356ff7581e, []int{7}
}
func (m *ConnectionCounter) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -521,7 +507,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_2bed36356ff7581e, []int{8}
}
func (m *ClientConnections) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -557,76 +543,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_2bed36356ff7581e, []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_2bed36356ff7581e, []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.v1.IbcRelay")
+ proto.RegisterType((*FungibleTokenPacketData)(nil), "penumbra.core.component.ibc.v1.FungibleTokenPacketData")
+ proto.RegisterType((*Ics20Withdrawal)(nil), "penumbra.core.component.ibc.v1.Ics20Withdrawal")
+ proto.RegisterType((*ClientData)(nil), "penumbra.core.component.ibc.v1.ClientData")
+ proto.RegisterType((*ClientCounter)(nil), "penumbra.core.component.ibc.v1.ClientCounter")
+ proto.RegisterType((*ConsensusState)(nil), "penumbra.core.component.ibc.v1.ConsensusState")
+ proto.RegisterType((*VerifiedHeights)(nil), "penumbra.core.component.ibc.v1.VerifiedHeights")
+ proto.RegisterType((*ConnectionCounter)(nil), "penumbra.core.component.ibc.v1.ConnectionCounter")
+ proto.RegisterType((*ClientConnections)(nil), "penumbra.core.component.ibc.v1.ClientConnections")
+ proto.RegisterType((*IbcParameters)(nil), "penumbra.core.component.ibc.v1.IbcParameters")
+ proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.ibc.v1.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/v1/ibc.proto", fileDescriptor_2bed36356ff7581e)
+}
+
+var fileDescriptor_2bed36356ff7581e = []byte{
+ // 942 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x95, 0xcf, 0x6f, 0x23, 0x35,
+ 0x14, 0xc7, 0x3b, 0x69, 0xb6, 0x3f, 0x9c, 0x4d, 0xca, 0x8e, 0x56, 0x6c, 0xb6, 0xec, 0x4e, 0xc3,
+ 0x48, 0x48, 0x5d, 0xa4, 0x9d, 0x61, 0xda, 0x45, 0x48, 0x41, 0x08, 0xb5, 0xb3, 0xa5, 0x44, 0x02,
+ 0x11, 0x0d, 0x55, 0x91, 0x50, 0x45, 0xe4, 0xf1, 0xbc, 0x26, 0x56, 0x33, 0x76, 0x64, 0x7b, 0x52,
+ 0xf5, 0x7f, 0x40, 0x82, 0xbf, 0x81, 0x23, 0x67, 0xb8, 0x73, 0x44, 0x9c, 0xf6, 0xc8, 0x11, 0xb5,
+ 0x37, 0xfe, 0x8a, 0x95, 0xed, 0x99, 0xe9, 0x66, 0xb5, 0x4a, 0x2f, 0x19, 0xfb, 0xf9, 0xf3, 0x9e,
+ 0xbf, 0xef, 0xf9, 0xd9, 0x41, 0xbb, 0x33, 0x60, 0x45, 0x9e, 0x0a, 0x1c, 0x12, 0x2e, 0x20, 0x24,
+ 0x3c, 0x9f, 0x71, 0x06, 0x4c, 0x85, 0x34, 0x25, 0xe1, 0x3c, 0xd2, 0x9f, 0x60, 0x26, 0xb8, 0xe2,
+ 0xae, 0x57, 0x91, 0x81, 0x26, 0x83, 0x9a, 0x0c, 0x34, 0x32, 0x8f, 0xb6, 0x1f, 0x8f, 0x39, 0x1f,
+ 0x4f, 0x21, 0x34, 0x74, 0x5a, 0x9c, 0x87, 0x98, 0x5d, 0x59, 0xd7, 0xed, 0x1d, 0x1d, 0xcc, 0xc6,
+ 0x9f, 0x52, 0x1d, 0x7c, 0x1e, 0x95, 0xa3, 0x12, 0xf0, 0x17, 0x55, 0x60, 0x29, 0xc1, 0x40, 0x66,
+ 0x50, 0x32, 0xbd, 0x45, 0xe6, 0x02, 0xae, 0xa4, 0x46, 0xf4, 0xb7, 0x24, 0xbc, 0x45, 0x82, 0x15,
+ 0xb9, 0x06, 0x58, 0x91, 0xdb, 0x75, 0xff, 0x4b, 0xb4, 0x31, 0x48, 0x49, 0x02, 0x53, 0x7c, 0xe5,
+ 0xee, 0x23, 0x24, 0xf0, 0xe5, 0x08, 0x13, 0x45, 0x39, 0xeb, 0x3a, 0x3d, 0x67, 0xb7, 0xb5, 0xf7,
+ 0x30, 0xb0, 0x29, 0x04, 0x55, 0x0a, 0xc1, 0x01, 0xbb, 0x4a, 0x36, 0x05, 0xbe, 0x3c, 0x30, 0x98,
+ 0xff, 0x8b, 0x83, 0x1e, 0x7d, 0x55, 0xb0, 0x31, 0x4d, 0xa7, 0x70, 0xc2, 0x2f, 0x80, 0x0d, 0x31,
+ 0xb9, 0x00, 0xf5, 0x12, 0x2b, 0xec, 0x3e, 0x44, 0xf7, 0x32, 0x60, 0x3c, 0x37, 0xb1, 0x36, 0x13,
+ 0x3b, 0x71, 0xdf, 0x47, 0x6b, 0x38, 0xe7, 0x05, 0x53, 0xdd, 0x86, 0x31, 0x97, 0x33, 0x6d, 0x97,
+ 0xc0, 0x32, 0x10, 0xdd, 0x55, 0x6b, 0xb7, 0x33, 0x77, 0x1b, 0x6d, 0x08, 0x20, 0x40, 0xe7, 0x20,
+ 0xba, 0x4d, 0xb3, 0x52, 0xcf, 0x5d, 0x17, 0x35, 0x73, 0xc8, 0x79, 0xf7, 0x9e, 0xb1, 0x9b, 0xb1,
+ 0xff, 0xf3, 0x2a, 0xda, 0x1a, 0x10, 0xb9, 0xf7, 0xc9, 0x0f, 0x54, 0x4d, 0x32, 0x81, 0x2f, 0xf1,
+ 0xd4, 0x7d, 0x51, 0xef, 0x69, 0xd3, 0x7a, 0x12, 0x2c, 0x9e, 0x9c, 0x2e, 0xc8, 0x3c, 0x0a, 0x0e,
+ 0x0c, 0x53, 0x2b, 0xda, 0xaf, 0xf4, 0x37, 0x8c, 0xd3, 0xd3, 0xb7, 0x9c, 0xec, 0x49, 0xcc, 0xa3,
+ 0xe0, 0xa5, 0x86, 0xaa, 0xf4, 0xfa, 0xe8, 0x71, 0x06, 0x52, 0x51, 0x86, 0x75, 0x7d, 0x46, 0x64,
+ 0x82, 0x29, 0x1b, 0xe1, 0x2c, 0x13, 0x20, 0x65, 0x99, 0xd9, 0xa3, 0x37, 0x80, 0x58, 0xaf, 0x1f,
+ 0xd8, 0x65, 0xf7, 0x08, 0x75, 0x04, 0xa8, 0x42, 0xdc, 0x3a, 0x34, 0xcd, 0xce, 0xde, 0x5b, 0x3b,
+ 0x9b, 0x03, 0xd6, 0x7a, 0x2d, 0x95, 0xb4, 0xad, 0x57, 0x15, 0xe6, 0x00, 0x75, 0x14, 0xcd, 0x81,
+ 0x17, 0x6a, 0x34, 0x01, 0x3a, 0x9e, 0x28, 0x53, 0x9f, 0xd6, 0xde, 0xb6, 0xe9, 0x4b, 0xdb, 0xaa,
+ 0xb6, 0xd5, 0xe6, 0x51, 0xf0, 0xb5, 0x21, 0x92, 0x76, 0xe9, 0x61, 0xa7, 0xee, 0x87, 0xe8, 0x7e,
+ 0x15, 0x42, 0x7f, 0xbb, 0x6b, 0x3d, 0x67, 0xb7, 0x99, 0xb4, 0x4a, 0xdb, 0x09, 0xcd, 0xc1, 0xfd,
+ 0x08, 0x75, 0x24, 0x2f, 0x04, 0x01, 0x9d, 0x23, 0x63, 0x30, 0xed, 0xae, 0x9b, 0xec, 0xda, 0xd6,
+ 0x1a, 0x5b, 0xa3, 0xff, 0x87, 0x83, 0x50, 0x6c, 0x76, 0x33, 0x3d, 0xf1, 0x01, 0xda, 0xb4, 0x7b,
+ 0x8f, 0x68, 0x56, 0xf6, 0xc5, 0x86, 0x35, 0x0c, 0x32, 0xf7, 0x33, 0x74, 0xbf, 0x5c, 0x94, 0x0a,
+ 0x2b, 0x28, 0xeb, 0xfe, 0xee, 0x1e, 0x6c, 0x59, 0xf2, 0x7b, 0x0d, 0x6a, 0x2d, 0x33, 0xc1, 0x09,
+ 0x48, 0x09, 0x99, 0x15, 0x6c, 0x2b, 0xdd, 0xae, 0xad, 0x46, 0xf2, 0x33, 0xf4, 0xde, 0x2d, 0x56,
+ 0x96, 0xa6, 0x69, 0x32, 0xdb, 0xaa, 0xed, 0xb6, 0x00, 0xfe, 0x33, 0xd4, 0xb6, 0xaa, 0x63, 0xdd,
+ 0x0a, 0x20, 0xdc, 0x2e, 0x5a, 0x27, 0x76, 0x68, 0x64, 0x37, 0x93, 0x6a, 0xea, 0x7f, 0x87, 0x3a,
+ 0x31, 0x67, 0x12, 0x98, 0x2c, 0xa4, 0x95, 0xf3, 0x05, 0xda, 0x22, 0x95, 0xa5, 0x4c, 0x65, 0xd9,
+ 0x75, 0xea, 0x90, 0x05, 0x77, 0xff, 0x18, 0x6d, 0x9d, 0x82, 0xa0, 0xe7, 0xb4, 0x52, 0x23, 0xdd,
+ 0x17, 0x68, 0xdd, 0xea, 0x95, 0x5d, 0xa7, 0xb7, 0x7a, 0xc7, 0x59, 0x56, 0xa8, 0xff, 0x1c, 0x3d,
+ 0x88, 0x39, 0x63, 0x60, 0xae, 0xea, 0xdd, 0x89, 0x7c, 0x8a, 0x1e, 0x54, 0x39, 0x57, 0x4e, 0xd2,
+ 0xed, 0xa1, 0x16, 0xb9, 0x9d, 0x9a, 0xdd, 0x37, 0x93, 0x37, 0x4d, 0xfe, 0x5f, 0x0e, 0x6a, 0x0f,
+ 0x52, 0x32, 0xc4, 0x02, 0xe7, 0xa0, 0x40, 0x48, 0x77, 0x07, 0xb5, 0x68, 0x4a, 0x46, 0xc0, 0x70,
+ 0x3a, 0x05, 0x7b, 0xcc, 0x1b, 0x09, 0xa2, 0x29, 0x39, 0xb2, 0x16, 0xf7, 0x08, 0xed, 0x50, 0x96,
+ 0xf2, 0x82, 0x65, 0x23, 0xaa, 0xaf, 0xea, 0x48, 0x09, 0xcc, 0xe4, 0x39, 0x08, 0x59, 0x3b, 0x35,
+ 0x8c, 0xd3, 0x93, 0x12, 0x33, 0x17, 0xfa, 0xa4, 0x82, 0xaa, 0x30, 0xc7, 0xa8, 0xc7, 0x0b, 0xb5,
+ 0x3c, 0xce, 0xaa, 0x89, 0xf3, 0xb4, 0xe2, 0xde, 0x19, 0xc8, 0xff, 0x09, 0x75, 0x8e, 0x81, 0x81,
+ 0xa4, 0x32, 0xe6, 0x4c, 0x01, 0x53, 0xee, 0x37, 0x48, 0xeb, 0x1d, 0xcd, 0x74, 0x52, 0xb2, 0x3c,
+ 0xbd, 0xe7, 0xc1, 0xf2, 0xf7, 0x3e, 0x58, 0xa8, 0x42, 0xb2, 0x49, 0xcb, 0xa9, 0x3c, 0xfc, 0xb3,
+ 0xf1, 0xf7, 0xb5, 0xe7, 0xbc, 0xba, 0xf6, 0x9c, 0xff, 0xae, 0x3d, 0xe7, 0xd7, 0x1b, 0x6f, 0xe5,
+ 0xd5, 0x8d, 0xb7, 0xf2, 0xef, 0x8d, 0xb7, 0x82, 0x7c, 0xc2, 0xf3, 0x3b, 0xe2, 0x1e, 0xea, 0x37,
+ 0x7a, 0xa8, 0x3b, 0x66, 0xe8, 0xfc, 0x38, 0x1c, 0x53, 0x35, 0x29, 0x52, 0x0d, 0x85, 0x84, 0xcb,
+ 0x9c, 0xcb, 0x50, 0xe8, 0xe7, 0x1b, 0x44, 0x38, 0xdf, 0xab, 0x87, 0xe6, 0xd9, 0x91, 0xe1, 0xf2,
+ 0x7f, 0xb2, 0xcf, 0x69, 0x4a, 0xe6, 0xd1, 0x6f, 0x8d, 0xe6, 0x30, 0x8e, 0x07, 0xbf, 0x37, 0xbc,
+ 0x61, 0xa5, 0x22, 0xd6, 0x2a, 0xe2, 0x5a, 0xc5, 0x20, 0x25, 0xc1, 0x69, 0xf4, 0xcf, 0x2d, 0x70,
+ 0xa6, 0x81, 0xb3, 0x1a, 0x38, 0x1b, 0xa4, 0xe4, 0xec, 0x34, 0xba, 0x6e, 0x7c, 0xbc, 0x1c, 0x38,
+ 0x3b, 0x1e, 0x1e, 0x7e, 0x0b, 0x0a, 0x67, 0x58, 0xe1, 0xff, 0x1b, 0x7e, 0x05, 0xf7, 0xfb, 0x9a,
+ 0xd6, 0xbf, 0x25, 0xde, 0xef, 0x0f, 0x52, 0xd2, 0xef, 0x9f, 0x46, 0xe9, 0x9a, 0xb9, 0x27, 0xfb,
+ 0xaf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x08, 0xe5, 0x06, 0x9c, 0x93, 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 +744,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
@@ -681,6 +789,13 @@ func (m *FungibleTokenPacketData) MarshalToSizedBuffer(dAtA []byte) (int, error)
_ = i
var l int
_ = l
+ if len(m.Memo) > 0 {
+ i -= len(m.Memo)
+ copy(dAtA[i:], m.Memo)
+ i = encodeVarintIbc(dAtA, i, uint64(len(m.Memo)))
+ i--
+ dAtA[i] = 0x2a
+ }
if len(m.Receiver) > 0 {
i -= len(m.Receiver)
copy(dAtA[i:], m.Receiver)
@@ -744,10 +859,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 +1131,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 +1230,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
}
@@ -1055,6 +1265,10 @@ func (m *FungibleTokenPacketData) Size() (n int) {
if l > 0 {
n += 1 + l + sovIbc(uint64(l))
}
+ l = len(m.Memo)
+ if l > 0 {
+ n += 1 + l + sovIbc(uint64(l))
+ }
return n
}
@@ -1080,8 +1294,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 +1399,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 +1459,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:
@@ -1433,6 +1679,38 @@ func (m *FungibleTokenPacketData) Unmarshal(dAtA []byte) error {
}
m.Receiver = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Memo", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowIbc
+ }
+ 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 ErrInvalidLengthIbc
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthIbc
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Memo = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipIbc(dAtA[iNdEx:])
@@ -1513,7 +1791,7 @@ func (m *Ics20Withdrawal) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.Amount == nil {
- m.Amount = &v1alpha1.Amount{}
+ m.Amount = &v1.Amount{}
}
if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@@ -1549,7 +1827,7 @@ func (m *Ics20Withdrawal) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.Denom == nil {
- m.Denom = &v1alpha1.Denom{}
+ m.Denom = &v11.Denom{}
}
if err := m.Denom.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@@ -1617,17 +1895,17 @@ func (m *Ics20Withdrawal) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.ReturnAddress == nil {
- m.ReturnAddress = &v1alpha1.Address{}
+ m.ReturnAddress = &v12.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 +1915,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 +2568,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/v1/sct.pb.go b/relayer/chains/penumbra/core/component/sct/v1/sct.pb.go
new file mode 100644
index 000000000..03329660b
--- /dev/null
+++ b/relayer/chains/penumbra/core/component/sct/v1/sct.pb.go
@@ -0,0 +1,3851 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: penumbra/core/component/sct/v1/sct.proto
+
+package sctv1
+
+import (
+ context "context"
+ fmt "fmt"
+ grpc1 "github.com/cosmos/gogoproto/grpc"
+ proto "github.com/cosmos/gogoproto/proto"
+ v1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/tct/v1"
+ 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
+
+// Configuration data for the SCT component.
+type SctParameters struct {
+ // The default duration of each epoch, in number of blocks.
+ EpochDuration uint64 `protobuf:"varint,1,opt,name=epoch_duration,json=epochDuration,proto3" json:"epoch_duration,omitempty"`
+}
+
+func (m *SctParameters) Reset() { *m = SctParameters{} }
+func (m *SctParameters) String() string { return proto.CompactTextString(m) }
+func (*SctParameters) ProtoMessage() {}
+func (*SctParameters) Descriptor() ([]byte, []int) {
+ return fileDescriptor_85f1e312317b2642, []int{0}
+}
+func (m *SctParameters) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *SctParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_SctParameters.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *SctParameters) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_SctParameters.Merge(m, src)
+}
+func (m *SctParameters) XXX_Size() int {
+ return m.Size()
+}
+func (m *SctParameters) XXX_DiscardUnknown() {
+ xxx_messageInfo_SctParameters.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SctParameters proto.InternalMessageInfo
+
+func (m *SctParameters) GetEpochDuration() uint64 {
+ if m != nil {
+ return m.EpochDuration
+ }
+ return 0
+}
+
+// Sct-specific genesis content.
+type GenesisContent struct {
+ // The SctParameters present at genesis.
+ SctParams *SctParameters `protobuf:"bytes,1,opt,name=sct_params,json=sctParams,proto3" json:"sct_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_85f1e312317b2642, []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) GetSctParams() *SctParameters {
+ if m != nil {
+ return m.SctParams
+ }
+ return nil
+}
+
+// An epoch is a sequentially numbered collection of contiguous blocks.
+type Epoch struct {
+ // The unique index of the epoch.
+ Index uint64 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
+ // The starting height for the epoch.
+ 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_85f1e312317b2642, []int{2}
+}
+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
+}
+
+// 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_85f1e312317b2642, []int{3}
+}
+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_85f1e312317b2642, []int{3, 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_85f1e312317b2642, []int{3, 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_85f1e312317b2642, []int{3, 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_85f1e312317b2642, []int{3, 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_85f1e312317b2642, []int{3, 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_85f1e312317b2642, []int{4}
+}
+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_85f1e312317b2642, []int{5}
+}
+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 *v1.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_85f1e312317b2642, []int{6}
+}
+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() *v1.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 *v1.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_85f1e312317b2642, []int{7}
+}
+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() *v1.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 *v1.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_85f1e312317b2642, []int{8}
+}
+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() *v1.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 *v1.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_85f1e312317b2642, []int{9}
+}
+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() *v1.MerkleRoot {
+ if m != nil {
+ return m.Root
+ }
+ return nil
+}
+
+func (m *EventBlockRoot) GetHeight() uint64 {
+ if m != nil {
+ return m.Height
+ }
+ 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_85f1e312317b2642, []int{10}
+}
+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_85f1e312317b2642, []int{11}
+}
+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((*SctParameters)(nil), "penumbra.core.component.sct.v1.SctParameters")
+ proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.sct.v1.GenesisContent")
+ proto.RegisterType((*Epoch)(nil), "penumbra.core.component.sct.v1.Epoch")
+ proto.RegisterType((*CommitmentSource)(nil), "penumbra.core.component.sct.v1.CommitmentSource")
+ proto.RegisterType((*CommitmentSource_Genesis)(nil), "penumbra.core.component.sct.v1.CommitmentSource.Genesis")
+ proto.RegisterType((*CommitmentSource_Transaction)(nil), "penumbra.core.component.sct.v1.CommitmentSource.Transaction")
+ proto.RegisterType((*CommitmentSource_FundingStreamReward)(nil), "penumbra.core.component.sct.v1.CommitmentSource.FundingStreamReward")
+ proto.RegisterType((*CommitmentSource_CommunityPoolOutput)(nil), "penumbra.core.component.sct.v1.CommitmentSource.CommunityPoolOutput")
+ proto.RegisterType((*CommitmentSource_Ics20Transfer)(nil), "penumbra.core.component.sct.v1.CommitmentSource.Ics20Transfer")
+ proto.RegisterType((*Nullifier)(nil), "penumbra.core.component.sct.v1.Nullifier")
+ proto.RegisterType((*NullificationInfo)(nil), "penumbra.core.component.sct.v1.NullificationInfo")
+ proto.RegisterType((*EventCommitment)(nil), "penumbra.core.component.sct.v1.EventCommitment")
+ proto.RegisterType((*EventAnchor)(nil), "penumbra.core.component.sct.v1.EventAnchor")
+ proto.RegisterType((*EventEpochRoot)(nil), "penumbra.core.component.sct.v1.EventEpochRoot")
+ proto.RegisterType((*EventBlockRoot)(nil), "penumbra.core.component.sct.v1.EventBlockRoot")
+ proto.RegisterType((*EpochByHeightRequest)(nil), "penumbra.core.component.sct.v1.EpochByHeightRequest")
+ proto.RegisterType((*EpochByHeightResponse)(nil), "penumbra.core.component.sct.v1.EpochByHeightResponse")
+}
+
+func init() {
+ proto.RegisterFile("penumbra/core/component/sct/v1/sct.proto", fileDescriptor_85f1e312317b2642)
+}
+
+var fileDescriptor_85f1e312317b2642 = []byte{
+ // 947 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0xcf, 0x6f, 0x1b, 0x45,
+ 0x14, 0xb6, 0x4d, 0x93, 0xc6, 0xcf, 0x49, 0x0a, 0x93, 0x04, 0x59, 0x96, 0x6a, 0xda, 0x95, 0x2a,
+ 0x22, 0x24, 0xd6, 0xb1, 0x81, 0x08, 0xb9, 0x08, 0x81, 0xdd, 0x36, 0x8e, 0x44, 0xc1, 0xac, 0xa3,
+ 0x1c, 0x50, 0xc4, 0x76, 0x33, 0xfb, 0x12, 0xaf, 0xe2, 0x9d, 0xd9, 0xcc, 0xcc, 0x1a, 0x82, 0xf8,
+ 0x13, 0x38, 0x70, 0xe2, 0x0f, 0xe0, 0xc8, 0x9d, 0x3b, 0x47, 0xc4, 0xa9, 0x47, 0x8e, 0x28, 0xb9,
+ 0xf1, 0x57, 0xa0, 0x99, 0x1d, 0xff, 0x6c, 0x9b, 0x60, 0xb8, 0x24, 0x9e, 0x6f, 0xbf, 0xf7, 0x7d,
+ 0xef, 0xcd, 0x9b, 0x37, 0xbb, 0xb0, 0x9d, 0x20, 0x4b, 0xe3, 0x63, 0x11, 0xd4, 0x28, 0x17, 0x58,
+ 0xa3, 0x3c, 0x4e, 0x38, 0x43, 0xa6, 0x6a, 0x92, 0xaa, 0xda, 0xb0, 0xae, 0xff, 0xb9, 0x89, 0xe0,
+ 0x8a, 0x93, 0xea, 0x88, 0xe9, 0x6a, 0xa6, 0x3b, 0x66, 0xba, 0x9a, 0x32, 0xac, 0x57, 0xee, 0x4d,
+ 0x94, 0xc4, 0x45, 0xa2, 0x78, 0x4d, 0x65, 0x0a, 0x6a, 0xa4, 0xe0, 0xec, 0xc2, 0x5a, 0x8f, 0xaa,
+ 0x6e, 0x20, 0x82, 0x18, 0x15, 0x0a, 0x49, 0x1e, 0xc0, 0x3a, 0x26, 0x9c, 0xf6, 0xfd, 0x30, 0x15,
+ 0x81, 0x8a, 0x38, 0x2b, 0xe7, 0xef, 0xe5, 0xb7, 0x6f, 0x79, 0x6b, 0x06, 0x7d, 0x64, 0x41, 0xe7,
+ 0x6b, 0x58, 0xdf, 0x43, 0x86, 0x32, 0x92, 0x6d, 0xce, 0x14, 0x32, 0x45, 0x3e, 0x03, 0x90, 0x54,
+ 0xf9, 0x89, 0x96, 0x92, 0x26, 0xa8, 0xd4, 0x78, 0xd7, 0xbd, 0x3e, 0x41, 0x77, 0xc6, 0xdb, 0x2b,
+ 0x4a, 0xbb, 0x94, 0xce, 0x27, 0xb0, 0xf4, 0x58, 0x1b, 0x92, 0x4d, 0x58, 0x8a, 0x58, 0x88, 0xdf,
+ 0xda, 0x34, 0xb2, 0x05, 0xb9, 0x0f, 0xab, 0x52, 0x05, 0x42, 0xf9, 0x7d, 0x8c, 0x4e, 0xfb, 0xaa,
+ 0x5c, 0x30, 0x0f, 0x4b, 0x06, 0xeb, 0x18, 0xc8, 0xf9, 0x69, 0x19, 0x5e, 0x6f, 0xf3, 0x38, 0x8e,
+ 0x54, 0x8c, 0x4c, 0xf5, 0x78, 0x2a, 0x28, 0x92, 0x67, 0x50, 0x52, 0x22, 0x60, 0x32, 0xa0, 0xe3,
+ 0xd2, 0x4a, 0x8d, 0x8f, 0x6e, 0xca, 0x72, 0x5e, 0xc6, 0x3d, 0x98, 0x68, 0x74, 0x72, 0xde, 0xb4,
+ 0x24, 0xe9, 0xc3, 0x9d, 0x88, 0x4a, 0xbf, 0xb1, 0xe3, 0x1b, 0xf4, 0x04, 0x85, 0x49, 0xae, 0xd4,
+ 0xf8, 0x78, 0x61, 0x97, 0x7d, 0x2a, 0x1b, 0x3b, 0x07, 0x56, 0xa5, 0x93, 0xf3, 0xd6, 0xa2, 0x69,
+ 0x80, 0x7c, 0x07, 0x5b, 0x27, 0x29, 0x0b, 0x23, 0x76, 0xea, 0x4b, 0x25, 0x30, 0x88, 0x7d, 0x81,
+ 0xdf, 0x04, 0x22, 0x2c, 0x6f, 0x1a, 0xbf, 0x47, 0x0b, 0xfb, 0x3d, 0xc9, 0xd4, 0x7a, 0x46, 0xcc,
+ 0x33, 0x5a, 0x9d, 0x9c, 0xb7, 0x71, 0xf2, 0x22, 0xac, 0xbd, 0x29, 0x8f, 0xe3, 0x94, 0x45, 0xea,
+ 0xc2, 0x4f, 0x38, 0x1f, 0xf8, 0x3c, 0x55, 0x49, 0xaa, 0xca, 0xd5, 0xff, 0xe8, 0xdd, 0x1e, 0xa9,
+ 0x75, 0x39, 0x1f, 0x7c, 0x61, 0xb4, 0xb4, 0x37, 0x7d, 0x11, 0x26, 0x07, 0x70, 0xfb, 0x34, 0x3b,
+ 0x7a, 0xe5, 0x6d, 0xe3, 0xf6, 0xe1, 0xc2, 0x6e, 0xf6, 0xe8, 0x76, 0x72, 0xde, 0x48, 0xaa, 0x52,
+ 0x84, 0xdb, 0x16, 0xad, 0xdc, 0x85, 0xd2, 0x54, 0x83, 0xc9, 0x3a, 0x14, 0xa2, 0xd0, 0x1c, 0x95,
+ 0x55, 0xaf, 0x10, 0x85, 0x95, 0x5d, 0xd8, 0x78, 0xc9, 0x4e, 0x91, 0xb7, 0xa0, 0x94, 0x0d, 0xce,
+ 0xf4, 0x71, 0x05, 0x03, 0xed, 0x6b, 0xa4, 0xb2, 0x05, 0x1b, 0x2f, 0xa9, 0xb2, 0x82, 0xb0, 0x36,
+ 0xd3, 0x68, 0x72, 0x17, 0x20, 0x09, 0xe8, 0x19, 0x2a, 0x5f, 0xe2, 0xb9, 0xd5, 0x29, 0x66, 0x48,
+ 0x0f, 0xcf, 0xf5, 0x63, 0xda, 0x0f, 0x18, 0xc3, 0x81, 0x1f, 0x85, 0xe6, 0x6c, 0x15, 0xbd, 0xa2,
+ 0x45, 0xf6, 0x43, 0xf2, 0x26, 0x2c, 0x4b, 0x64, 0x21, 0x8a, 0xf2, 0x6b, 0xe6, 0x91, 0x5d, 0xb5,
+ 0x56, 0x60, 0x59, 0x9a, 0xe2, 0x9d, 0xfb, 0x50, 0xfc, 0x3c, 0x1d, 0x0c, 0xa2, 0x93, 0x08, 0x45,
+ 0x36, 0x5e, 0x0c, 0x85, 0xad, 0x2f, 0x5b, 0x38, 0x4f, 0xe0, 0x0d, 0x4b, 0xa1, 0x66, 0xdc, 0xf7,
+ 0xd9, 0x09, 0x9f, 0xdf, 0x07, 0x33, 0x83, 0x09, 0xb2, 0x70, 0x7e, 0x06, 0x35, 0x66, 0x67, 0xf0,
+ 0xb7, 0x3c, 0xdc, 0x79, 0x3c, 0x44, 0xa6, 0x26, 0x1d, 0x20, 0x7b, 0x00, 0x74, 0xbc, 0xb2, 0x13,
+ 0xf8, 0xf6, 0x54, 0x07, 0xcd, 0x45, 0xe5, 0x2a, 0x7b, 0x3f, 0xa8, 0x40, 0xe1, 0x24, 0xd8, 0x9b,
+ 0x0a, 0x25, 0x15, 0x58, 0x49, 0xb8, 0x8c, 0xcc, 0x20, 0x67, 0xde, 0xe3, 0x35, 0xe9, 0x8c, 0xaa,
+ 0x35, 0xbb, 0x50, 0x6a, 0xec, 0x2c, 0x7a, 0x44, 0xbc, 0xd1, 0x6e, 0x05, 0x50, 0x32, 0x15, 0x7c,
+ 0xca, 0x68, 0x9f, 0x0b, 0xd2, 0x84, 0xe5, 0xc0, 0xfc, 0xb2, 0x99, 0x3b, 0xaf, 0xca, 0xfc, 0x29,
+ 0x8a, 0xb3, 0x01, 0x7a, 0x9c, 0x2b, 0xcf, 0x46, 0xe8, 0xd6, 0xcc, 0x6c, 0x95, 0x5d, 0xe9, 0xbb,
+ 0xd4, 0x58, 0x98, 0x0b, 0x4f, 0x47, 0x90, 0x5d, 0xb8, 0x25, 0x38, 0x57, 0x0b, 0x78, 0x18, 0xfe,
+ 0xe4, 0xb2, 0x2c, 0x4c, 0x5d, 0x96, 0xce, 0x33, 0xab, 0xdf, 0x1a, 0x70, 0x7a, 0xf6, 0xbf, 0xf4,
+ 0x5f, 0x55, 0x81, 0x0b, 0x9b, 0x26, 0xf9, 0xd6, 0x45, 0xd6, 0x78, 0x0f, 0xcf, 0x53, 0x94, 0xd3,
+ 0xfc, 0xfc, 0x0c, 0xff, 0x00, 0xb6, 0xe6, 0xf8, 0x32, 0xe1, 0x4c, 0x22, 0x79, 0x08, 0x4b, 0x66,
+ 0x62, 0x6c, 0x66, 0x0f, 0x6e, 0x6a, 0x5b, 0xb6, 0x65, 0x59, 0x4c, 0xe3, 0x87, 0x3c, 0xac, 0x7e,
+ 0x99, 0xa2, 0xb8, 0xe8, 0xa1, 0x18, 0x46, 0x14, 0xc9, 0xf7, 0xb0, 0x36, 0x63, 0x43, 0xde, 0xff,
+ 0x57, 0x7a, 0x73, 0x55, 0x54, 0x3e, 0x58, 0x30, 0x2a, 0xab, 0xa5, 0xf5, 0x6b, 0xe1, 0xf7, 0xcb,
+ 0x6a, 0xfe, 0xf9, 0x65, 0x35, 0xff, 0xd7, 0x65, 0x35, 0xff, 0xe3, 0x55, 0x35, 0xf7, 0xfc, 0xaa,
+ 0x9a, 0xfb, 0xf3, 0xaa, 0x9a, 0x03, 0x87, 0xf2, 0xf8, 0x06, 0xd1, 0xd6, 0x8a, 0x7e, 0x37, 0xea,
+ 0x77, 0x74, 0x37, 0xff, 0x55, 0xf7, 0x34, 0x52, 0xfd, 0xf4, 0x58, 0x93, 0x6a, 0x94, 0xcb, 0x98,
+ 0xcb, 0x9a, 0xc0, 0x41, 0x70, 0x81, 0xa2, 0x36, 0x6c, 0x8c, 0x7f, 0xd2, 0x7e, 0x10, 0x31, 0x59,
+ 0xbb, 0xfe, 0xeb, 0xe1, 0xa1, 0xa4, 0x6a, 0x58, 0xff, 0xb9, 0x70, 0xab, 0xdb, 0x6e, 0xf7, 0x7e,
+ 0x29, 0x54, 0xbb, 0xa3, 0x2c, 0xda, 0x3a, 0x8b, 0xf6, 0x38, 0x8b, 0x1e, 0x55, 0xee, 0x61, 0xfd,
+ 0x8f, 0x09, 0xe1, 0x48, 0x13, 0x8e, 0xc6, 0x84, 0xa3, 0x1e, 0x55, 0x47, 0x87, 0xf5, 0xcb, 0xc2,
+ 0x3b, 0xd7, 0x13, 0x8e, 0xf6, 0xba, 0xad, 0xa7, 0xa8, 0x82, 0x30, 0x50, 0xc1, 0xdf, 0x05, 0x67,
+ 0x44, 0x6e, 0x36, 0x35, 0x5b, 0xff, 0xb5, 0xf4, 0x66, 0xb3, 0x47, 0x55, 0xb3, 0x79, 0x58, 0x3f,
+ 0x5e, 0x36, 0x5f, 0x26, 0xef, 0xfd, 0x13, 0x00, 0x00, 0xff, 0xff, 0x62, 0x18, 0xb8, 0x98, 0x07,
+ 0x09, 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 {
+ 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.sct.v1.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 {
+ 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.sct.v1.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.sct.v1.QueryService",
+ HandlerType: (*QueryServiceServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "EpochByHeight",
+ Handler: _QueryService_EpochByHeight_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "penumbra/core/component/sct/v1/sct.proto",
+}
+
+func (m *SctParameters) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *SctParameters) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *SctParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.EpochDuration != 0 {
+ i = encodeVarintSct(dAtA, i, uint64(m.EpochDuration))
+ 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.SctParams != nil {
+ {
+ size, err := m.SctParams.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 *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 = encodeVarintSct(dAtA, i, uint64(m.StartHeight))
+ i--
+ dAtA[i] = 0x10
+ }
+ if m.Index != 0 {
+ i = encodeVarintSct(dAtA, i, uint64(m.Index))
+ i--
+ dAtA[i] = 0x8
+ }
+ return len(dAtA) - i, nil
+}
+
+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 (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 = encodeVarintSct(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 = 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 *SctParameters) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.EpochDuration != 0 {
+ n += 1 + sovSct(uint64(m.EpochDuration))
+ }
+ return n
+}
+
+func (m *GenesisContent) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.SctParams != nil {
+ l = m.SctParams.Size()
+ n += 1 + l + sovSct(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 + sovSct(uint64(m.Index))
+ }
+ if m.StartHeight != 0 {
+ n += 1 + sovSct(uint64(m.StartHeight))
+ }
+ return n
+}
+
+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 (m *EpochByHeightRequest) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.Height != 0 {
+ n += 1 + sovSct(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 + sovSct(uint64(l))
+ }
+ 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 *SctParameters) Unmarshal(dAtA []byte) 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: SctParameters: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: SctParameters: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ 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 ErrIntOverflowSct
+ }
+ 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 := 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 *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 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: 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 SctParams", 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.SctParams == nil {
+ m.SctParams = &SctParameters{}
+ }
+ if err := m.SctParams.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 *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 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: 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 ErrIntOverflowSct
+ }
+ 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 ErrIntOverflowSct
+ }
+ 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 := 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) Unmarshal(dAtA []byte) 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 = &v1.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 = &v1.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 = &v1.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 = &v1.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 (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 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: 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 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 *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 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: 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 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.Epoch == nil {
+ m.Epoch = &Epoch{}
+ }
+ if err := m.Epoch.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 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/v1/shielded_pool.pb.go b/relayer/chains/penumbra/core/component/shielded_pool/v1/shielded_pool.pb.go
new file mode 100644
index 000000000..3962a79bf
--- /dev/null
+++ b/relayer/chains/penumbra/core/component/shielded_pool/v1/shielded_pool.pb.go
@@ -0,0 +1,7148 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: penumbra/core/component/shielded_pool/v1/shielded_pool.proto
+
+package shielded_poolv1
+
+import (
+ context "context"
+ fmt "fmt"
+ grpc1 "github.com/cosmos/gogoproto/grpc"
+ proto "github.com/cosmos/gogoproto/proto"
+ v12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/asset/v1"
+ v15 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/sct/v1"
+ v11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/keys/v1"
+ v1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/num/v1"
+ v14 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/decaf377_rdsa/v1"
+ v13 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/tct/v1"
+ 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
+
+// Configuration data for the shielded pool component.
+type ShieldedPoolParameters struct {
+ FixedFmdParams *FmdParameters `protobuf:"bytes,1,opt,name=fixed_fmd_params,json=fixedFmdParams,proto3" json:"fixed_fmd_params,omitempty"`
+}
+
+func (m *ShieldedPoolParameters) Reset() { *m = ShieldedPoolParameters{} }
+func (m *ShieldedPoolParameters) String() string { return proto.CompactTextString(m) }
+func (*ShieldedPoolParameters) ProtoMessage() {}
+func (*ShieldedPoolParameters) Descriptor() ([]byte, []int) {
+ return fileDescriptor_26a9f446de1cd73c, []int{0}
+}
+func (m *ShieldedPoolParameters) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *ShieldedPoolParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_ShieldedPoolParameters.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *ShieldedPoolParameters) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ShieldedPoolParameters.Merge(m, src)
+}
+func (m *ShieldedPoolParameters) XXX_Size() int {
+ return m.Size()
+}
+func (m *ShieldedPoolParameters) XXX_DiscardUnknown() {
+ xxx_messageInfo_ShieldedPoolParameters.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ShieldedPoolParameters proto.InternalMessageInfo
+
+func (m *ShieldedPoolParameters) GetFixedFmdParams() *FmdParameters {
+ if m != nil {
+ return m.FixedFmdParams
+ }
+ return nil
+}
+
+// Genesis data for the shielded pool component.
+type GenesisContent struct {
+ ShieldedPoolParams *ShieldedPoolParameters `protobuf:"bytes,1,opt,name=shielded_pool_params,json=shieldedPoolParams,proto3" json:"shielded_pool_params,omitempty"`
+ // The allocations present at genesis
+ Allocations []*GenesisContent_Allocation `protobuf:"bytes,3,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_26a9f446de1cd73c, []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) GetShieldedPoolParams() *ShieldedPoolParameters {
+ if m != nil {
+ return m.ShieldedPoolParams
+ }
+ return nil
+}
+
+func (m *GenesisContent) GetAllocations() []*GenesisContent_Allocation {
+ if m != nil {
+ return m.Allocations
+ }
+ return nil
+}
+
+type GenesisContent_Allocation struct {
+ Amount *v1.Amount `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount,omitempty"`
+ Denom string `protobuf:"bytes,2,opt,name=denom,proto3" json:"denom,omitempty"`
+ Address *v11.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_26a9f446de1cd73c, []int{1, 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() *v1.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() *v11.Address {
+ if m != nil {
+ return m.Address
+ }
+ return nil
+}
+
+// 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_26a9f446de1cd73c, []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
+}
+
+type Note struct {
+ Value *v12.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
+ Rseed []byte `protobuf:"bytes,2,opt,name=rseed,proto3" json:"rseed,omitempty"`
+ Address *v11.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_26a9f446de1cd73c, []int{3}
+}
+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() *v12.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() *v11.Address {
+ if m != nil {
+ return m.Address
+ }
+ return nil
+}
+
+type NoteView struct {
+ Value *v12.ValueView `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
+ Rseed []byte `protobuf:"bytes,2,opt,name=rseed,proto3" json:"rseed,omitempty"`
+ Address *v11.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_26a9f446de1cd73c, []int{4}
+}
+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() *v12.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() *v11.AddressView {
+ if m != nil {
+ return m.Address
+ }
+ return nil
+}
+
+// An encrypted note.
+// 176 = 80(address) + 16(amount) + 32(asset ID) + 32(rseed) + 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_26a9f446de1cd73c, []int{5}
+}
+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 *v13.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.
+ // 176 = 80(address) + 16(amount) + 32(asset ID) + 32(rseed) + 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_26a9f446de1cd73c, []int{6}
+}
+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() *v13.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_26a9f446de1cd73c, []int{7}
+}
+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_26a9f446de1cd73c, []int{8}
+}
+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_26a9f446de1cd73c, []int{9}
+}
+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 *v14.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_26a9f446de1cd73c, []int{10}
+}
+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() *v14.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 *v15.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_26a9f446de1cd73c, []int{11}
+}
+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() *v15.Nullifier {
+ if m != nil {
+ return m.Nullifier
+ }
+ return nil
+}
+
+// ABCI Event recording an output.
+type EventOutput struct {
+ NoteCommitment *v13.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_26a9f446de1cd73c, []int{12}
+}
+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() *v13.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 *v12.BalanceCommitment `protobuf:"bytes,1,opt,name=balance_commitment,json=balanceCommitment,proto3" json:"balance_commitment,omitempty"`
+ // The nullifier of the input note.
+ Nullifier *v15.Nullifier `protobuf:"bytes,6,opt,name=nullifier,proto3" json:"nullifier,omitempty"`
+ // The randomized validating key for the spend authorization signature.
+ Rk *v14.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_26a9f446de1cd73c, []int{13}
+}
+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() *v12.BalanceCommitment {
+ if m != nil {
+ return m.BalanceCommitment
+ }
+ return nil
+}
+
+func (m *SpendBody) GetNullifier() *v15.Nullifier {
+ if m != nil {
+ return m.Nullifier
+ }
+ return nil
+}
+
+func (m *SpendBody) GetRk() *v14.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_26a9f446de1cd73c, []int{14}
+}
+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_26a9f446de1cd73c, []int{14, 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_26a9f446de1cd73c, []int{14, 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_26a9f446de1cd73c, []int{15}
+}
+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_26a9f446de1cd73c, []int{16}
+}
+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 *v12.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_26a9f446de1cd73c, []int{17}
+}
+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() *v12.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_26a9f446de1cd73c, []int{18}
+}
+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 *v11.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_26a9f446de1cd73c, []int{18, 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() *v11.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_26a9f446de1cd73c, []int{18, 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 *v12.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
+ // The destination address to send it to.
+ DestAddress *v11.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_26a9f446de1cd73c, []int{19}
+}
+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() *v12.Value {
+ if m != nil {
+ return m.Value
+ }
+ return nil
+}
+
+func (m *OutputPlan) GetDestAddress() *v11.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 AssetMetadataByIdRequest struct {
+ // The asset id to request information on.
+ AssetId *v12.AssetId `protobuf:"bytes,2,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"`
+}
+
+func (m *AssetMetadataByIdRequest) Reset() { *m = AssetMetadataByIdRequest{} }
+func (m *AssetMetadataByIdRequest) String() string { return proto.CompactTextString(m) }
+func (*AssetMetadataByIdRequest) ProtoMessage() {}
+func (*AssetMetadataByIdRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_26a9f446de1cd73c, []int{20}
+}
+func (m *AssetMetadataByIdRequest) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *AssetMetadataByIdRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_AssetMetadataByIdRequest.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *AssetMetadataByIdRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_AssetMetadataByIdRequest.Merge(m, src)
+}
+func (m *AssetMetadataByIdRequest) XXX_Size() int {
+ return m.Size()
+}
+func (m *AssetMetadataByIdRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_AssetMetadataByIdRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AssetMetadataByIdRequest proto.InternalMessageInfo
+
+func (m *AssetMetadataByIdRequest) GetAssetId() *v12.AssetId {
+ if m != nil {
+ return m.AssetId
+ }
+ return nil
+}
+
+type AssetMetadataByIdResponse struct {
+ // If present, information on the requested asset.
+ //
+ // If the requested asset was unknown, this field will not be present.
+ DenomMetadata *v12.Metadata `protobuf:"bytes,1,opt,name=denom_metadata,json=denomMetadata,proto3" json:"denom_metadata,omitempty"`
+}
+
+func (m *AssetMetadataByIdResponse) Reset() { *m = AssetMetadataByIdResponse{} }
+func (m *AssetMetadataByIdResponse) String() string { return proto.CompactTextString(m) }
+func (*AssetMetadataByIdResponse) ProtoMessage() {}
+func (*AssetMetadataByIdResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_26a9f446de1cd73c, []int{21}
+}
+func (m *AssetMetadataByIdResponse) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *AssetMetadataByIdResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_AssetMetadataByIdResponse.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *AssetMetadataByIdResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_AssetMetadataByIdResponse.Merge(m, src)
+}
+func (m *AssetMetadataByIdResponse) XXX_Size() int {
+ return m.Size()
+}
+func (m *AssetMetadataByIdResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_AssetMetadataByIdResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AssetMetadataByIdResponse proto.InternalMessageInfo
+
+func (m *AssetMetadataByIdResponse) GetDenomMetadata() *v12.Metadata {
+ if m != nil {
+ return m.DenomMetadata
+ }
+ return nil
+}
+
+func init() {
+ proto.RegisterType((*ShieldedPoolParameters)(nil), "penumbra.core.component.shielded_pool.v1.ShieldedPoolParameters")
+ proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.shielded_pool.v1.GenesisContent")
+ proto.RegisterType((*GenesisContent_Allocation)(nil), "penumbra.core.component.shielded_pool.v1.GenesisContent.Allocation")
+ proto.RegisterType((*FmdParameters)(nil), "penumbra.core.component.shielded_pool.v1.FmdParameters")
+ proto.RegisterType((*Note)(nil), "penumbra.core.component.shielded_pool.v1.Note")
+ proto.RegisterType((*NoteView)(nil), "penumbra.core.component.shielded_pool.v1.NoteView")
+ proto.RegisterType((*NoteCiphertext)(nil), "penumbra.core.component.shielded_pool.v1.NoteCiphertext")
+ proto.RegisterType((*NotePayload)(nil), "penumbra.core.component.shielded_pool.v1.NotePayload")
+ proto.RegisterType((*ZKOutputProof)(nil), "penumbra.core.component.shielded_pool.v1.ZKOutputProof")
+ proto.RegisterType((*ZKSpendProof)(nil), "penumbra.core.component.shielded_pool.v1.ZKSpendProof")
+ proto.RegisterType((*ZKNullifierDerivationProof)(nil), "penumbra.core.component.shielded_pool.v1.ZKNullifierDerivationProof")
+ proto.RegisterType((*Spend)(nil), "penumbra.core.component.shielded_pool.v1.Spend")
+ proto.RegisterType((*EventSpend)(nil), "penumbra.core.component.shielded_pool.v1.EventSpend")
+ proto.RegisterType((*EventOutput)(nil), "penumbra.core.component.shielded_pool.v1.EventOutput")
+ proto.RegisterType((*SpendBody)(nil), "penumbra.core.component.shielded_pool.v1.SpendBody")
+ proto.RegisterType((*SpendView)(nil), "penumbra.core.component.shielded_pool.v1.SpendView")
+ proto.RegisterType((*SpendView_Visible)(nil), "penumbra.core.component.shielded_pool.v1.SpendView.Visible")
+ proto.RegisterType((*SpendView_Opaque)(nil), "penumbra.core.component.shielded_pool.v1.SpendView.Opaque")
+ proto.RegisterType((*SpendPlan)(nil), "penumbra.core.component.shielded_pool.v1.SpendPlan")
+ proto.RegisterType((*Output)(nil), "penumbra.core.component.shielded_pool.v1.Output")
+ proto.RegisterType((*OutputBody)(nil), "penumbra.core.component.shielded_pool.v1.OutputBody")
+ proto.RegisterType((*OutputView)(nil), "penumbra.core.component.shielded_pool.v1.OutputView")
+ proto.RegisterType((*OutputView_Visible)(nil), "penumbra.core.component.shielded_pool.v1.OutputView.Visible")
+ proto.RegisterType((*OutputView_Opaque)(nil), "penumbra.core.component.shielded_pool.v1.OutputView.Opaque")
+ proto.RegisterType((*OutputPlan)(nil), "penumbra.core.component.shielded_pool.v1.OutputPlan")
+ proto.RegisterType((*AssetMetadataByIdRequest)(nil), "penumbra.core.component.shielded_pool.v1.AssetMetadataByIdRequest")
+ proto.RegisterType((*AssetMetadataByIdResponse)(nil), "penumbra.core.component.shielded_pool.v1.AssetMetadataByIdResponse")
+}
+
+func init() {
+ proto.RegisterFile("penumbra/core/component/shielded_pool/v1/shielded_pool.proto", fileDescriptor_26a9f446de1cd73c)
+}
+
+var fileDescriptor_26a9f446de1cd73c = []byte{
+ // 1564 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0xcd, 0x6f, 0xdb, 0xc8,
+ 0x15, 0x37, 0xe5, 0xcf, 0x3c, 0x7d, 0x24, 0x19, 0x04, 0x85, 0x2b, 0xb4, 0xaa, 0xcb, 0x36, 0x89,
+ 0x83, 0x14, 0x52, 0x65, 0xbb, 0x75, 0xa0, 0xe4, 0x50, 0x4b, 0x4d, 0xec, 0xc0, 0x4d, 0xac, 0xd2,
+ 0x8d, 0x12, 0x18, 0x06, 0x88, 0x91, 0x38, 0xb2, 0x08, 0x93, 0x1c, 0x86, 0x33, 0x52, 0xa2, 0xf6,
+ 0x12, 0xf4, 0xd0, 0x4b, 0x2f, 0x45, 0x80, 0xa2, 0x3d, 0xec, 0x65, 0xf7, 0xb8, 0xc0, 0xde, 0xf6,
+ 0x8f, 0x58, 0xec, 0x29, 0xc7, 0xbd, 0xed, 0xc2, 0xc1, 0x5e, 0xf6, 0xb2, 0xb7, 0x3d, 0x2f, 0x66,
+ 0x38, 0xa4, 0x44, 0xd9, 0x32, 0x24, 0xc7, 0xc0, 0x5e, 0x12, 0xf2, 0xf1, 0xf7, 0x7e, 0xef, 0x63,
+ 0xde, 0xfc, 0x66, 0x2c, 0x78, 0xe0, 0x13, 0xaf, 0xeb, 0x36, 0x03, 0x5c, 0x6a, 0xd1, 0x80, 0x94,
+ 0x5a, 0xd4, 0xf5, 0xa9, 0x47, 0x3c, 0x5e, 0x62, 0x1d, 0x9b, 0x38, 0x16, 0xb1, 0x4c, 0x9f, 0x52,
+ 0xa7, 0xd4, 0x2b, 0x27, 0x0d, 0x45, 0x3f, 0xa0, 0x9c, 0xa2, 0xd5, 0xc8, 0xbb, 0x28, 0xbc, 0x8b,
+ 0xb1, 0x77, 0x31, 0x09, 0xee, 0x95, 0xf3, 0x7a, 0x32, 0x0e, 0x66, 0x8c, 0x70, 0xc1, 0x2a, 0x1f,
+ 0x42, 0xb6, 0xfc, 0xea, 0xd8, 0x5c, 0x5a, 0x12, 0xcb, 0x5a, 0x11, 0x72, 0x25, 0x89, 0x3c, 0x26,
+ 0x7d, 0x26, 0x00, 0xe2, 0x7f, 0x85, 0x28, 0x24, 0x11, 0x5e, 0xd7, 0x15, 0x00, 0xaf, 0xeb, 0xaa,
+ 0xef, 0x1b, 0x83, 0xef, 0x41, 0xdf, 0xe7, 0xb4, 0x64, 0x91, 0x16, 0x6e, 0xaf, 0x6f, 0x6e, 0x9a,
+ 0x81, 0xc5, 0xb0, 0xc0, 0x26, 0x0c, 0xa7, 0xe3, 0x86, 0x5e, 0x3c, 0xcc, 0x8c, 0x47, 0x99, 0xe9,
+ 0xff, 0x80, 0x9f, 0xed, 0xab, 0xda, 0xeb, 0x94, 0x3a, 0x75, 0x1c, 0x60, 0x97, 0x70, 0x12, 0x30,
+ 0x84, 0xe1, 0x5a, 0xdb, 0x7e, 0x4d, 0x2c, 0xb3, 0xed, 0x5a, 0xa6, 0x2f, 0xec, 0x6c, 0x59, 0x5b,
+ 0xd1, 0x56, 0xd3, 0x6b, 0x9b, 0xc5, 0x49, 0xdb, 0x58, 0x7c, 0xe4, 0x5a, 0x03, 0x4a, 0x23, 0x27,
+ 0x09, 0x23, 0x1b, 0xd3, 0xdf, 0xcc, 0x42, 0x6e, 0x9b, 0x78, 0x84, 0xd9, 0xac, 0x46, 0x3d, 0x4e,
+ 0x3c, 0x8e, 0x02, 0xb8, 0x91, 0x20, 0x49, 0x46, 0xfe, 0xd3, 0xe4, 0x91, 0xcf, 0xae, 0xca, 0x40,
+ 0x6c, 0xd4, 0xce, 0x10, 0x81, 0x34, 0x76, 0x1c, 0xda, 0xc2, 0xdc, 0xa6, 0x1e, 0x5b, 0x9e, 0x5d,
+ 0x99, 0x5d, 0x4d, 0xaf, 0xd5, 0x26, 0x0f, 0x95, 0x2c, 0xa1, 0xb8, 0x15, 0x73, 0x19, 0xc3, 0xbc,
+ 0xf9, 0xb7, 0x1a, 0xc0, 0xe0, 0x1b, 0xda, 0x80, 0x05, 0xec, 0xd2, 0xae, 0xc7, 0x55, 0x6d, 0xbf,
+ 0x18, 0x09, 0x28, 0xd6, 0xbe, 0x57, 0x2e, 0x6e, 0x49, 0x8c, 0xa1, 0xb0, 0xe8, 0x06, 0xcc, 0x5b,
+ 0xc4, 0xa3, 0xee, 0x72, 0x6a, 0x45, 0x5b, 0xbd, 0x62, 0x84, 0x2f, 0xe8, 0x1e, 0x2c, 0x62, 0xcb,
+ 0x0a, 0x08, 0x13, 0xd9, 0x0b, 0xb2, 0xc2, 0x08, 0x99, 0x9c, 0x34, 0xc1, 0x16, 0xa2, 0x8c, 0x08,
+ 0xae, 0xb7, 0x20, 0x9b, 0x58, 0x23, 0x74, 0x13, 0x72, 0x7e, 0x40, 0x5a, 0x36, 0xb3, 0xa9, 0x67,
+ 0x36, 0x6d, 0x1e, 0xb6, 0x3e, 0x6b, 0x64, 0x63, 0x6b, 0xd5, 0xe6, 0x0c, 0xdd, 0x05, 0x84, 0x99,
+ 0x49, 0xdb, 0x66, 0xd3, 0xa1, 0xad, 0x63, 0xb3, 0x43, 0xec, 0xa3, 0x0e, 0x97, 0x49, 0xcd, 0x19,
+ 0x57, 0x31, 0xdb, 0x6b, 0x57, 0x85, 0x7d, 0x47, 0x9a, 0xf5, 0x7f, 0x6b, 0x30, 0xf7, 0x94, 0x72,
+ 0x82, 0xd6, 0x61, 0xbe, 0x87, 0x9d, 0x2e, 0x51, 0x25, 0xff, 0x72, 0x24, 0xcb, 0x70, 0x73, 0xf5,
+ 0xca, 0xc5, 0x86, 0x00, 0x19, 0x21, 0x56, 0x94, 0x1c, 0x30, 0x42, 0x2c, 0xc9, 0x9e, 0x31, 0xc2,
+ 0x97, 0x0f, 0x28, 0xf9, 0x7f, 0x1a, 0x2c, 0x89, 0x6c, 0x1a, 0x36, 0x79, 0x85, 0x36, 0x93, 0x19,
+ 0xfd, 0xfa, 0xdc, 0x8c, 0x84, 0xc7, 0xf9, 0x59, 0x3d, 0x18, 0xcd, 0x4a, 0x3f, 0x3f, 0x2b, 0xc9,
+ 0x18, 0x67, 0x76, 0x0b, 0x72, 0x22, 0xb1, 0x9a, 0xed, 0x77, 0x48, 0xc0, 0xc9, 0x6b, 0xb9, 0xdc,
+ 0xb6, 0xe7, 0x91, 0x40, 0xa6, 0x97, 0x31, 0xc2, 0x17, 0xfd, 0x5b, 0x0d, 0xd2, 0x02, 0x58, 0xc7,
+ 0x7d, 0x87, 0x62, 0x0b, 0xd5, 0xe1, 0xaa, 0x47, 0x39, 0x31, 0x5b, 0xd4, 0x75, 0x6d, 0xee, 0x92,
+ 0x78, 0xa6, 0x6e, 0x0f, 0x45, 0x97, 0x02, 0x50, 0x14, 0x3b, 0x5f, 0xec, 0x0e, 0x8e, 0x39, 0xa9,
+ 0xc5, 0x70, 0x23, 0x27, 0xfc, 0x07, 0xef, 0xe8, 0x37, 0x90, 0x25, 0x7e, 0x87, 0xb8, 0x24, 0xc0,
+ 0x8e, 0x79, 0x4c, 0xfa, 0xaa, 0xca, 0x4c, 0x6c, 0xdc, 0x25, 0x7d, 0x64, 0x42, 0x8e, 0x78, 0x92,
+ 0x97, 0x58, 0xa6, 0x20, 0x50, 0x35, 0xdf, 0x9b, 0x7c, 0xeb, 0x24, 0xcb, 0x35, 0xb2, 0x31, 0x9f,
+ 0xf8, 0xa0, 0xdf, 0x84, 0xec, 0xc1, 0xee, 0x5e, 0x97, 0xfb, 0x5d, 0x5e, 0x0f, 0x28, 0x6d, 0x8f,
+ 0x69, 0xc7, 0x6f, 0x21, 0x73, 0xb0, 0xbb, 0xef, 0x13, 0xcf, 0x3a, 0x0f, 0xb5, 0x06, 0xf9, 0x83,
+ 0xdd, 0xa7, 0x5d, 0xc7, 0xb1, 0xdb, 0x36, 0x09, 0xfe, 0x4c, 0x02, 0xbb, 0x27, 0x37, 0xe2, 0x79,
+ 0x3e, 0xdf, 0x6b, 0x30, 0x2f, 0x89, 0xd1, 0x36, 0xcc, 0x35, 0xa9, 0xd5, 0x57, 0x7d, 0x5d, 0x9f,
+ 0x42, 0x87, 0x84, 0x7b, 0x95, 0x5a, 0x7d, 0x43, 0x12, 0xa0, 0x3d, 0x58, 0xc2, 0x5d, 0xde, 0x31,
+ 0x99, 0x7d, 0x24, 0x9b, 0x9a, 0x5e, 0xdb, 0x38, 0xb5, 0x48, 0x49, 0x29, 0x8f, 0x48, 0xb6, 0xba,
+ 0xbc, 0xb3, 0x6f, 0x1f, 0x79, 0x98, 0x77, 0x03, 0x62, 0x2c, 0xe2, 0xf0, 0x15, 0xfd, 0x05, 0xe6,
+ 0x7d, 0x51, 0x82, 0x6a, 0xfe, 0x1f, 0x27, 0x4f, 0x6d, 0xb8, 0x69, 0x46, 0x48, 0xa2, 0x3f, 0x03,
+ 0x78, 0xd8, 0x23, 0x1e, 0x8f, 0xaa, 0xbe, 0xe2, 0x45, 0x1d, 0x53, 0xa5, 0xdf, 0x19, 0xcf, 0x1f,
+ 0x8e, 0x56, 0xdc, 0x62, 0x63, 0xe0, 0xab, 0x9b, 0x90, 0x96, 0xb4, 0xe1, 0x62, 0x5e, 0xfe, 0xc0,
+ 0xea, 0x3f, 0x68, 0x70, 0x25, 0x6e, 0x35, 0x7a, 0x01, 0xa8, 0x89, 0x1d, 0xec, 0xb5, 0xce, 0x08,
+ 0x71, 0x67, 0xdc, 0x16, 0xaf, 0x86, 0x1e, 0x43, 0x41, 0xae, 0x37, 0x47, 0x4d, 0xc9, 0x8e, 0x2c,
+ 0x5c, 0xbc, 0x23, 0xe8, 0x11, 0xa4, 0x82, 0xe3, 0xe5, 0xb9, 0x53, 0x6b, 0x76, 0xde, 0x04, 0x34,
+ 0x48, 0x60, 0xb7, 0xed, 0xf0, 0xfc, 0xd8, 0x25, 0x7d, 0x23, 0x15, 0x1c, 0xeb, 0x9f, 0xcf, 0xaa,
+ 0xc2, 0xa5, 0x9c, 0x3d, 0x87, 0xc5, 0x9e, 0xcd, 0xec, 0xa6, 0x13, 0x09, 0xda, 0xfd, 0x29, 0x27,
+ 0x55, 0xb0, 0x14, 0x1b, 0x21, 0xc5, 0xce, 0x8c, 0x11, 0xb1, 0xa1, 0xbf, 0xc1, 0x02, 0xf5, 0xf1,
+ 0xcb, 0x2e, 0x51, 0x43, 0x5b, 0xb9, 0x08, 0xef, 0x9e, 0x64, 0xd8, 0x99, 0x31, 0x14, 0x57, 0xfe,
+ 0xff, 0x1a, 0x2c, 0xaa, 0x60, 0xe8, 0x21, 0xcc, 0x33, 0x81, 0x54, 0x89, 0x97, 0xa6, 0x0c, 0x60,
+ 0x84, 0xde, 0xe8, 0x11, 0xcc, 0x49, 0x29, 0x0a, 0xd3, 0x5c, 0x9b, 0x4e, 0x8a, 0xa4, 0x1c, 0x4b,
+ 0xff, 0xfc, 0x1e, 0x2c, 0x84, 0xe9, 0x5e, 0x52, 0x62, 0xd5, 0x0c, 0x80, 0x7c, 0x30, 0x7b, 0x36,
+ 0x79, 0xa5, 0xff, 0x2b, 0xa5, 0x96, 0xad, 0xee, 0x60, 0x0f, 0x55, 0x55, 0xd2, 0x61, 0x84, 0xe2,
+ 0x74, 0x49, 0x87, 0x09, 0xa3, 0x3c, 0x2c, 0xf9, 0x94, 0xd9, 0x62, 0x36, 0xd4, 0x39, 0x1c, 0xbf,
+ 0xa3, 0x02, 0x40, 0x80, 0x3d, 0x8b, 0xba, 0xf6, 0xdf, 0x49, 0x20, 0x85, 0x22, 0x63, 0x0c, 0x59,
+ 0xc4, 0xa1, 0x2f, 0x4f, 0x35, 0xb3, 0xe9, 0xd8, 0x9e, 0x65, 0x7b, 0x47, 0x72, 0x30, 0x33, 0x46,
+ 0x56, 0x5a, 0xab, 0xca, 0x88, 0x56, 0xe1, 0x9a, 0x54, 0x89, 0x18, 0x66, 0x06, 0xcb, 0xf3, 0x12,
+ 0x98, 0x93, 0xf6, 0x08, 0x68, 0x9c, 0x81, 0x64, 0x72, 0xb7, 0x8c, 0x22, 0xf7, 0xf5, 0x8f, 0x35,
+ 0x58, 0x50, 0xaa, 0xb0, 0x93, 0xd0, 0xd8, 0x8d, 0xc9, 0xbb, 0x10, 0xfa, 0x0f, 0x89, 0xec, 0x93,
+ 0x48, 0x13, 0x53, 0xd3, 0x5e, 0x58, 0x13, 0xe7, 0x4d, 0x24, 0x8a, 0x6f, 0x53, 0x00, 0x83, 0x18,
+ 0xe8, 0x05, 0x64, 0xa4, 0x7a, 0xf9, 0xe1, 0xf1, 0xab, 0xf2, 0xfd, 0xc3, 0x74, 0xab, 0xa6, 0xce,
+ 0x6e, 0x23, 0xed, 0x0d, 0x1d, 0xe4, 0x67, 0xeb, 0x56, 0xea, 0x12, 0x74, 0x6b, 0x15, 0xae, 0xbd,
+ 0x0a, 0xb0, 0xef, 0x13, 0xcb, 0x74, 0x89, 0x4b, 0xe5, 0x99, 0x1e, 0xce, 0x41, 0x4e, 0xd9, 0x9f,
+ 0x10, 0x97, 0x8a, 0x53, 0xfd, 0x16, 0x5c, 0xa5, 0xbd, 0x63, 0x33, 0x42, 0x0b, 0xa0, 0x1a, 0x06,
+ 0xda, 0x3b, 0x7e, 0x1e, 0x5a, 0x77, 0x49, 0x5f, 0xff, 0xe7, 0x5c, 0xd4, 0x14, 0xa9, 0x3c, 0x2f,
+ 0x46, 0x95, 0xe7, 0xc1, 0xb4, 0xeb, 0x37, 0x4e, 0x7a, 0x9e, 0x8d, 0x48, 0xcf, 0xfd, 0x0b, 0x11,
+ 0x9f, 0xd2, 0x9e, 0xaf, 0x87, 0xb4, 0x67, 0x07, 0x16, 0xa8, 0x84, 0xaa, 0xdc, 0x7f, 0x3f, 0x6d,
+ 0x08, 0x43, 0xf9, 0x5f, 0x96, 0xfc, 0xa0, 0x2a, 0xa4, 0xd5, 0x78, 0xc5, 0x4b, 0x75, 0xfa, 0x76,
+ 0x1a, 0x5d, 0x26, 0xd5, 0xf8, 0x88, 0x23, 0x01, 0xfc, 0xf8, 0x39, 0x6f, 0xc4, 0x12, 0x76, 0x69,
+ 0xf5, 0x55, 0xb3, 0x90, 0x0e, 0x9f, 0x42, 0x19, 0xfb, 0x6f, 0xbc, 0x33, 0xa4, 0x8e, 0x5d, 0xe8,
+ 0x7e, 0xbf, 0x05, 0x19, 0x8b, 0x30, 0x6e, 0x46, 0x17, 0xe7, 0xd4, 0x44, 0xd7, 0xf9, 0xb4, 0xf0,
+ 0x51, 0x2f, 0x83, 0xcb, 0xf8, 0xec, 0xf0, 0x65, 0xfc, 0x27, 0x54, 0xb5, 0x06, 0x2c, 0x6f, 0x89,
+ 0x62, 0x9f, 0x10, 0x8e, 0x2d, 0xcc, 0x71, 0xb5, 0xff, 0xd8, 0x32, 0xc8, 0xcb, 0x2e, 0x61, 0x1c,
+ 0x55, 0x60, 0x49, 0x36, 0xc2, 0xb4, 0x2d, 0x55, 0xeb, 0xaf, 0xc6, 0xf5, 0x49, 0x72, 0x3c, 0xb6,
+ 0x8c, 0x45, 0x1c, 0x3e, 0xe8, 0x16, 0xfc, 0xfc, 0x0c, 0x5e, 0xe6, 0x53, 0x8f, 0x11, 0xb4, 0x0d,
+ 0x39, 0xf9, 0xe7, 0xa0, 0xe9, 0xaa, 0xaf, 0x6a, 0x19, 0x56, 0xc6, 0xd1, 0x47, 0x2c, 0x46, 0x56,
+ 0xfa, 0x45, 0xaf, 0x6b, 0x9f, 0x69, 0x90, 0xf9, 0x6b, 0x97, 0x04, 0xfd, 0x7d, 0x12, 0xf4, 0xec,
+ 0x16, 0x41, 0x1f, 0x69, 0x70, 0xfd, 0x54, 0x5c, 0x54, 0x9d, 0x7c, 0x8a, 0xc6, 0x35, 0x23, 0x5f,
+ 0xfb, 0x20, 0x8e, 0xb0, 0xf0, 0xea, 0x9b, 0xd9, 0x2f, 0x4e, 0x0a, 0xda, 0xbb, 0x93, 0x82, 0xf6,
+ 0xcd, 0x49, 0x41, 0xfb, 0xcf, 0xfb, 0xc2, 0xcc, 0xbb, 0xf7, 0x85, 0x99, 0xaf, 0xde, 0x17, 0x66,
+ 0xe0, 0x77, 0x2d, 0xea, 0x4e, 0x1c, 0xa2, 0x7a, 0x3d, 0xf1, 0xab, 0x41, 0x40, 0x39, 0xad, 0x6b,
+ 0x07, 0xd6, 0x91, 0xcd, 0x3b, 0xdd, 0xa6, 0xf0, 0x2b, 0xb5, 0x28, 0x73, 0x29, 0x2b, 0x05, 0xc4,
+ 0xc1, 0x7d, 0x12, 0x94, 0x7a, 0x6b, 0xf1, 0x63, 0xab, 0x83, 0x6d, 0x8f, 0x95, 0x26, 0xfd, 0x79,
+ 0xea, 0x7e, 0xc2, 0xd0, 0x2b, 0x7f, 0x92, 0x9a, 0xab, 0xd7, 0x6a, 0xfb, 0x9f, 0xa6, 0x6e, 0xd7,
+ 0xa3, 0x64, 0x6b, 0x22, 0xd9, 0x5a, 0x9c, 0xec, 0x70, 0x6a, 0xc5, 0x46, 0xf9, 0xcb, 0x01, 0xf2,
+ 0x50, 0x20, 0x0f, 0x63, 0xe4, 0xe1, 0x30, 0xf2, 0xb0, 0x51, 0x3e, 0x49, 0xad, 0x4f, 0x88, 0x3c,
+ 0xdc, 0xae, 0x57, 0xa3, 0x06, 0x7f, 0x97, 0xba, 0x1b, 0x79, 0x55, 0x2a, 0xc2, 0x4d, 0xfc, 0xab,
+ 0xfc, 0x2a, 0x95, 0x61, 0xc7, 0x4a, 0xa5, 0x51, 0x6e, 0x2e, 0xc8, 0x9f, 0x93, 0xd6, 0x7f, 0x0c,
+ 0x00, 0x00, 0xff, 0xff, 0x74, 0xe5, 0xc5, 0x77, 0xa0, 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 {
+ AssetMetadataById(ctx context.Context, in *AssetMetadataByIdRequest, opts ...grpc.CallOption) (*AssetMetadataByIdResponse, error)
+}
+
+type queryServiceClient struct {
+ cc grpc1.ClientConn
+}
+
+func NewQueryServiceClient(cc grpc1.ClientConn) QueryServiceClient {
+ return &queryServiceClient{cc}
+}
+
+func (c *queryServiceClient) AssetMetadataById(ctx context.Context, in *AssetMetadataByIdRequest, opts ...grpc.CallOption) (*AssetMetadataByIdResponse, error) {
+ out := new(AssetMetadataByIdResponse)
+ err := c.cc.Invoke(ctx, "/penumbra.core.component.shielded_pool.v1.QueryService/AssetMetadataById", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+// QueryServiceServer is the server API for QueryService service.
+type QueryServiceServer interface {
+ AssetMetadataById(context.Context, *AssetMetadataByIdRequest) (*AssetMetadataByIdResponse, error)
+}
+
+// UnimplementedQueryServiceServer can be embedded to have forward compatible implementations.
+type UnimplementedQueryServiceServer struct {
+}
+
+func (*UnimplementedQueryServiceServer) AssetMetadataById(ctx context.Context, req *AssetMetadataByIdRequest) (*AssetMetadataByIdResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method AssetMetadataById not implemented")
+}
+
+func RegisterQueryServiceServer(s grpc1.Server, srv QueryServiceServer) {
+ s.RegisterService(&_QueryService_serviceDesc, srv)
+}
+
+func _QueryService_AssetMetadataById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(AssetMetadataByIdRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(QueryServiceServer).AssetMetadataById(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/penumbra.core.component.shielded_pool.v1.QueryService/AssetMetadataById",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(QueryServiceServer).AssetMetadataById(ctx, req.(*AssetMetadataByIdRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+var _QueryService_serviceDesc = grpc.ServiceDesc{
+ ServiceName: "penumbra.core.component.shielded_pool.v1.QueryService",
+ HandlerType: (*QueryServiceServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "AssetMetadataById",
+ Handler: _QueryService_AssetMetadataById_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "penumbra/core/component/shielded_pool/v1/shielded_pool.proto",
+}
+
+func (m *ShieldedPoolParameters) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *ShieldedPoolParameters) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ShieldedPoolParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.FixedFmdParams != nil {
+ {
+ size, err := m.FixedFmdParams.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] = 0x1a
+ }
+ }
+ if m.ShieldedPoolParams != nil {
+ {
+ size, err := m.ShieldedPoolParams.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_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 (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 = encodeVarintShieldedPool(dAtA, i, uint64(m.AsOfBlockHeight))
+ i--
+ dAtA[i] = 0x10
+ }
+ if m.PrecisionBits != 0 {
+ i = encodeVarintShieldedPool(dAtA, i, uint64(m.PrecisionBits))
+ i--
+ dAtA[i] = 0x8
+ }
+ 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 = 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 *AssetMetadataByIdRequest) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *AssetMetadataByIdRequest) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AssetMetadataByIdRequest) 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
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *AssetMetadataByIdResponse) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *AssetMetadataByIdResponse) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AssetMetadataByIdResponse) 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 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 *ShieldedPoolParameters) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.FixedFmdParams != nil {
+ l = m.FixedFmdParams.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 m.ShieldedPoolParams != nil {
+ l = m.ShieldedPoolParams.Size()
+ n += 1 + l + sovShieldedPool(uint64(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 (m *FmdParameters) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.PrecisionBits != 0 {
+ n += 1 + sovShieldedPool(uint64(m.PrecisionBits))
+ }
+ if m.AsOfBlockHeight != 0 {
+ n += 1 + sovShieldedPool(uint64(m.AsOfBlockHeight))
+ }
+ 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 + 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 *AssetMetadataByIdRequest) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.AssetId != nil {
+ l = m.AssetId.Size()
+ n += 1 + l + sovShieldedPool(uint64(l))
+ }
+ return n
+}
+
+func (m *AssetMetadataByIdResponse) 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 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 *ShieldedPoolParameters) Unmarshal(dAtA []byte) 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: ShieldedPoolParameters: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ShieldedPoolParameters: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FixedFmdParams", 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.FixedFmdParams == nil {
+ m.FixedFmdParams = &FmdParameters{}
+ }
+ if err := m.FixedFmdParams.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 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ShieldedPoolParams", 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.ShieldedPoolParams == nil {
+ m.ShieldedPoolParams = &ShieldedPoolParameters{}
+ }
+ if err := m.ShieldedPoolParams.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 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 = &v1.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 = &v11.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 *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 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: 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 ErrIntOverflowShieldedPool
+ }
+ 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 ErrIntOverflowShieldedPool
+ }
+ 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 := 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 *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 = &v12.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 = &v11.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 = &v12.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 = &v11.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 = &v13.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 = &v14.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 = &v15.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 = &v13.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 = &v12.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 = &v14.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 = &v15.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 = &v12.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 = &v11.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 = &v12.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 = &v11.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 *AssetMetadataByIdRequest) Unmarshal(dAtA []byte) 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: AssetMetadataByIdRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: AssetMetadataByIdRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ 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 = &v12.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 *AssetMetadataByIdResponse) Unmarshal(dAtA []byte) 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: AssetMetadataByIdResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: AssetMetadataByIdResponse: 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 = &v12.Metadata{}
+ }
+ 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 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/v1/stake.pb.go
similarity index 55%
rename from relayer/chains/penumbra/core/stake/v1alpha1/stake.pb.go
rename to relayer/chains/penumbra/core/component/stake/v1/stake.pb.go
index 690e79f23..41b99cab8 100644
--- a/relayer/chains/penumbra/core/stake/v1alpha1/stake.pb.go
+++ b/relayer/chains/penumbra/core/component/stake/v1/stake.pb.go
@@ -1,12 +1,20 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: penumbra/core/stake/v1alpha1/stake.proto
+// source: penumbra/core/component/stake/v1/stake.proto
-package stakev1alpha1
+package stakev1
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"
+ v13 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/asset/v1"
+ v12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/sct/v1"
+ v1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/keys/v1"
+ v11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/num/v1"
+ 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,36 +59,39 @@ func (x BondingState_BondingStateEnum) String() string {
}
func (BondingState_BondingStateEnum) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_022d012c8e7b3ca5, []int{6, 0}
+ return fileDescriptor_061b0086577193ed, []int{7, 0}
}
type ValidatorState_ValidatorStateEnum int32
const (
ValidatorState_VALIDATOR_STATE_ENUM_UNSPECIFIED ValidatorState_ValidatorStateEnum = 0
- ValidatorState_VALIDATOR_STATE_ENUM_INACTIVE ValidatorState_ValidatorStateEnum = 1
- ValidatorState_VALIDATOR_STATE_ENUM_ACTIVE ValidatorState_ValidatorStateEnum = 2
- ValidatorState_VALIDATOR_STATE_ENUM_JAILED ValidatorState_ValidatorStateEnum = 3
- ValidatorState_VALIDATOR_STATE_ENUM_TOMBSTONED ValidatorState_ValidatorStateEnum = 4
- ValidatorState_VALIDATOR_STATE_ENUM_DISABLED ValidatorState_ValidatorStateEnum = 5
+ ValidatorState_VALIDATOR_STATE_ENUM_DEFINED ValidatorState_ValidatorStateEnum = 1
+ ValidatorState_VALIDATOR_STATE_ENUM_INACTIVE ValidatorState_ValidatorStateEnum = 2
+ ValidatorState_VALIDATOR_STATE_ENUM_ACTIVE ValidatorState_ValidatorStateEnum = 3
+ ValidatorState_VALIDATOR_STATE_ENUM_JAILED ValidatorState_ValidatorStateEnum = 4
+ ValidatorState_VALIDATOR_STATE_ENUM_TOMBSTONED ValidatorState_ValidatorStateEnum = 5
+ ValidatorState_VALIDATOR_STATE_ENUM_DISABLED ValidatorState_ValidatorStateEnum = 6
)
var ValidatorState_ValidatorStateEnum_name = map[int32]string{
0: "VALIDATOR_STATE_ENUM_UNSPECIFIED",
- 1: "VALIDATOR_STATE_ENUM_INACTIVE",
- 2: "VALIDATOR_STATE_ENUM_ACTIVE",
- 3: "VALIDATOR_STATE_ENUM_JAILED",
- 4: "VALIDATOR_STATE_ENUM_TOMBSTONED",
- 5: "VALIDATOR_STATE_ENUM_DISABLED",
+ 1: "VALIDATOR_STATE_ENUM_DEFINED",
+ 2: "VALIDATOR_STATE_ENUM_INACTIVE",
+ 3: "VALIDATOR_STATE_ENUM_ACTIVE",
+ 4: "VALIDATOR_STATE_ENUM_JAILED",
+ 5: "VALIDATOR_STATE_ENUM_TOMBSTONED",
+ 6: "VALIDATOR_STATE_ENUM_DISABLED",
}
var ValidatorState_ValidatorStateEnum_value = map[string]int32{
"VALIDATOR_STATE_ENUM_UNSPECIFIED": 0,
- "VALIDATOR_STATE_ENUM_INACTIVE": 1,
- "VALIDATOR_STATE_ENUM_ACTIVE": 2,
- "VALIDATOR_STATE_ENUM_JAILED": 3,
- "VALIDATOR_STATE_ENUM_TOMBSTONED": 4,
- "VALIDATOR_STATE_ENUM_DISABLED": 5,
+ "VALIDATOR_STATE_ENUM_DEFINED": 1,
+ "VALIDATOR_STATE_ENUM_INACTIVE": 2,
+ "VALIDATOR_STATE_ENUM_ACTIVE": 3,
+ "VALIDATOR_STATE_ENUM_JAILED": 4,
+ "VALIDATOR_STATE_ENUM_TOMBSTONED": 5,
+ "VALIDATOR_STATE_ENUM_DISABLED": 6,
}
func (x ValidatorState_ValidatorStateEnum) String() string {
@@ -88,13 +99,58 @@ func (x ValidatorState_ValidatorStateEnum) String() string {
}
func (ValidatorState_ValidatorStateEnum) EnumDescriptor() ([]byte, []int) {
- return fileDescriptor_022d012c8e7b3ca5, []int{7, 0}
+ return fileDescriptor_061b0086577193ed, []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_061b0086577193ed, []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.
type Validator struct {
// The validator's identity verification key.
- IdentityKey *v1alpha1.IdentityKey `protobuf:"bytes,1,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"`
+ IdentityKey *v1.IdentityKey `protobuf:"bytes,1,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"`
// The validator's consensus pubkey for use in Tendermint (Ed25519).
ConsensusKey []byte `protobuf:"bytes,2,opt,name=consensus_key,json=consensusKey,proto3" json:"consensus_key,omitempty"`
// The validator's (human-readable) name.
@@ -114,14 +170,14 @@ type Validator struct {
// with increasing sequence numbers.
SequenceNumber uint32 `protobuf:"varint,7,opt,name=sequence_number,json=sequenceNumber,proto3" json:"sequence_number,omitempty"`
// The validator's governance key.
- GovernanceKey *v1alpha1.GovernanceKey `protobuf:"bytes,9,opt,name=governance_key,json=governanceKey,proto3" json:"governance_key,omitempty"`
+ GovernanceKey *v1.GovernanceKey `protobuf:"bytes,9,opt,name=governance_key,json=governanceKey,proto3" json:"governance_key,omitempty"`
}
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_061b0086577193ed, []int{1}
}
func (m *Validator) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -150,7 +206,7 @@ func (m *Validator) XXX_DiscardUnknown() {
var xxx_messageInfo_Validator proto.InternalMessageInfo
-func (m *Validator) GetIdentityKey() *v1alpha1.IdentityKey {
+func (m *Validator) GetIdentityKey() *v1.IdentityKey {
if m != nil {
return m.IdentityKey
}
@@ -206,7 +262,7 @@ func (m *Validator) GetSequenceNumber() uint32 {
return 0
}
-func (m *Validator) GetGovernanceKey() *v1alpha1.GovernanceKey {
+func (m *Validator) GetGovernanceKey() *v1.GovernanceKey {
if m != nil {
return m.GovernanceKey
}
@@ -215,14 +271,14 @@ func (m *Validator) GetGovernanceKey() *v1alpha1.GovernanceKey {
// For storing the list of keys of known validators.
type ValidatorList struct {
- ValidatorKeys []*v1alpha1.IdentityKey `protobuf:"bytes,1,rep,name=validator_keys,json=validatorKeys,proto3" json:"validator_keys,omitempty"`
+ ValidatorKeys []*v1.IdentityKey `protobuf:"bytes,1,rep,name=validator_keys,json=validatorKeys,proto3" json:"validator_keys,omitempty"`
}
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_061b0086577193ed, []int{2}
}
func (m *ValidatorList) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -251,7 +307,7 @@ func (m *ValidatorList) XXX_DiscardUnknown() {
var xxx_messageInfo_ValidatorList proto.InternalMessageInfo
-func (m *ValidatorList) GetValidatorKeys() []*v1alpha1.IdentityKey {
+func (m *ValidatorList) GetValidatorKeys() []*v1.IdentityKey {
if m != nil {
return m.ValidatorKeys
}
@@ -263,8 +319,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 +329,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_061b0086577193ed, []int{3}
}
func (m *FundingStream) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -310,12 +367,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 +388,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 +399,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 +415,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_061b0086577193ed, []int{3, 0}
}
func (m *FundingStream_ToAddress) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -401,24 +458,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_061b0086577193ed, []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 +485,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
}
@@ -449,17 +506,21 @@ func (m *FundingStream_ToDao) GetRateBps() uint32 {
// Describes the reward and exchange rates and voting power for a validator in some epoch.
type RateData struct {
- IdentityKey *v1alpha1.IdentityKey `protobuf:"bytes,1,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"`
- EpochIndex uint64 `protobuf:"varint,2,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
- ValidatorRewardRate uint64 `protobuf:"varint,4,opt,name=validator_reward_rate,json=validatorRewardRate,proto3" json:"validator_reward_rate,omitempty"`
- ValidatorExchangeRate uint64 `protobuf:"varint,5,opt,name=validator_exchange_rate,json=validatorExchangeRate,proto3" json:"validator_exchange_rate,omitempty"`
+ IdentityKey *v1.IdentityKey `protobuf:"bytes,1,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"`
+ EpochIndex uint64 `protobuf:"varint,2,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"` // Deprecated: Do not use.
+ ValidatorRewardRate *v11.Amount `protobuf:"bytes,4,opt,name=validator_reward_rate,json=validatorRewardRate,proto3" json:"validator_reward_rate,omitempty"`
+ // The validator exchange rate between delegation tokens and staking tokens.
+ // The rate is expressed in fixed-point representation with a scaling factor
+ // of 10^8. For example, a decimal rate of `1.234` will be represented as
+ // `123400000`
+ ValidatorExchangeRate *v11.Amount `protobuf:"bytes,5,opt,name=validator_exchange_rate,json=validatorExchangeRate,proto3" json:"validator_exchange_rate,omitempty"`
}
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_061b0086577193ed, []int{4}
}
func (m *RateData) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -488,13 +549,14 @@ func (m *RateData) XXX_DiscardUnknown() {
var xxx_messageInfo_RateData proto.InternalMessageInfo
-func (m *RateData) GetIdentityKey() *v1alpha1.IdentityKey {
+func (m *RateData) GetIdentityKey() *v1.IdentityKey {
if m != nil {
return m.IdentityKey
}
return nil
}
+// Deprecated: Do not use.
func (m *RateData) GetEpochIndex() uint64 {
if m != nil {
return m.EpochIndex
@@ -502,32 +564,32 @@ func (m *RateData) GetEpochIndex() uint64 {
return 0
}
-func (m *RateData) GetValidatorRewardRate() uint64 {
+func (m *RateData) GetValidatorRewardRate() *v11.Amount {
if m != nil {
return m.ValidatorRewardRate
}
- return 0
+ return nil
}
-func (m *RateData) GetValidatorExchangeRate() uint64 {
+func (m *RateData) GetValidatorExchangeRate() *v11.Amount {
if m != nil {
return m.ValidatorExchangeRate
}
- return 0
+ return nil
}
// Describes the base reward and exchange rates in some epoch.
type BaseRateData struct {
- EpochIndex uint64 `protobuf:"varint,1,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
- BaseRewardRate uint64 `protobuf:"varint,2,opt,name=base_reward_rate,json=baseRewardRate,proto3" json:"base_reward_rate,omitempty"`
- BaseExchangeRate uint64 `protobuf:"varint,3,opt,name=base_exchange_rate,json=baseExchangeRate,proto3" json:"base_exchange_rate,omitempty"`
+ EpochIndex uint64 `protobuf:"varint,1,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
+ BaseRewardRate *v11.Amount `protobuf:"bytes,2,opt,name=base_reward_rate,json=baseRewardRate,proto3" json:"base_reward_rate,omitempty"`
+ BaseExchangeRate *v11.Amount `protobuf:"bytes,3,opt,name=base_exchange_rate,json=baseExchangeRate,proto3" json:"base_exchange_rate,omitempty"`
}
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_061b0086577193ed, []int{5}
}
func (m *BaseRateData) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -563,33 +625,33 @@ func (m *BaseRateData) GetEpochIndex() uint64 {
return 0
}
-func (m *BaseRateData) GetBaseRewardRate() uint64 {
+func (m *BaseRateData) GetBaseRewardRate() *v11.Amount {
if m != nil {
return m.BaseRewardRate
}
- return 0
+ return nil
}
-func (m *BaseRateData) GetBaseExchangeRate() uint64 {
+func (m *BaseRateData) GetBaseExchangeRate() *v11.Amount {
if m != nil {
return m.BaseExchangeRate
}
- return 0
+ return nil
}
// Describes the current state of a validator on-chain
type ValidatorStatus struct {
- IdentityKey *v1alpha1.IdentityKey `protobuf:"bytes,1,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"`
- State *ValidatorState `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"`
- VotingPower uint64 `protobuf:"varint,3,opt,name=voting_power,json=votingPower,proto3" json:"voting_power,omitempty"`
- BondingState *BondingState `protobuf:"bytes,4,opt,name=bonding_state,json=bondingState,proto3" json:"bonding_state,omitempty"`
+ IdentityKey *v1.IdentityKey `protobuf:"bytes,1,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"`
+ State *ValidatorState `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"`
+ VotingPower *v11.Amount `protobuf:"bytes,3,opt,name=voting_power,json=votingPower,proto3" json:"voting_power,omitempty"`
+ BondingState *BondingState `protobuf:"bytes,4,opt,name=bonding_state,json=bondingState,proto3" json:"bonding_state,omitempty"`
}
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_061b0086577193ed, []int{6}
}
func (m *ValidatorStatus) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -618,7 +680,7 @@ func (m *ValidatorStatus) XXX_DiscardUnknown() {
var xxx_messageInfo_ValidatorStatus proto.InternalMessageInfo
-func (m *ValidatorStatus) GetIdentityKey() *v1alpha1.IdentityKey {
+func (m *ValidatorStatus) GetIdentityKey() *v1.IdentityKey {
if m != nil {
return m.IdentityKey
}
@@ -632,11 +694,11 @@ func (m *ValidatorStatus) GetState() *ValidatorState {
return nil
}
-func (m *ValidatorStatus) GetVotingPower() uint64 {
+func (m *ValidatorStatus) GetVotingPower() *v11.Amount {
if m != nil {
return m.VotingPower
}
- return 0
+ return nil
}
func (m *ValidatorStatus) GetBondingState() *BondingState {
@@ -648,17 +710,16 @@ 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.v1.BondingState_BondingStateEnum" json:"state,omitempty"`
+ UnbondsAtEpoch uint64 `protobuf:"varint,2,opt,name=unbonds_at_epoch,json=unbondsAtEpoch,proto3" json:"unbonds_at_epoch,omitempty"` // Deprecated: Do not use.
+ UnbondsAtHeight uint64 `protobuf:"varint,3,opt,name=unbonds_at_height,json=unbondsAtHeight,proto3" json:"unbonds_at_height,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_061b0086577193ed, []int{7}
}
func (m *BondingState) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -687,25 +748,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
@@ -713,30 +755,31 @@ func (m *BondingState) GetState() BondingState_BondingStateEnum {
return BondingState_BONDING_STATE_ENUM_UNSPECIFIED
}
-func (m *BondingState) GetUnbondingEpoch() uint64 {
- if x, ok := m.GetXUnbondingEpoch().(*BondingState_UnbondingEpoch); ok {
- return x.UnbondingEpoch
+// Deprecated: Do not use.
+func (m *BondingState) GetUnbondsAtEpoch() uint64 {
+ if m != nil {
+ return m.UnbondsAtEpoch
}
return 0
}
-// XXX_OneofWrappers is for the internal use of the proto package.
-func (*BondingState) XXX_OneofWrappers() []interface{} {
- return []interface{}{
- (*BondingState_UnbondingEpoch)(nil),
+func (m *BondingState) GetUnbondsAtHeight() uint64 {
+ if m != nil {
+ return m.UnbondsAtHeight
}
+ return 0
}
// 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.v1.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_061b0086577193ed, []int{8}
}
func (m *ValidatorState) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -783,7 +826,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_061b0086577193ed, []int{9}
}
func (m *ValidatorInfo) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -845,7 +888,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_061b0086577193ed, []int{10}
}
func (m *ValidatorDefinition) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -891,26 +934,26 @@ func (m *ValidatorDefinition) GetAuthSig() []byte {
// A transaction action adding stake to a validator's delegation pool.
type Delegate struct {
// The identity key of the validator to delegate to.
- ValidatorIdentity *v1alpha1.IdentityKey `protobuf:"bytes,1,opt,name=validator_identity,json=validatorIdentity,proto3" json:"validator_identity,omitempty"`
+ ValidatorIdentity *v1.IdentityKey `protobuf:"bytes,1,opt,name=validator_identity,json=validatorIdentity,proto3" json:"validator_identity,omitempty"`
// The index of the epoch in which this delegation was performed.
// The delegation takes effect in the next epoch.
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 *v11.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 *v11.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_061b0086577193ed, []int{11}
}
func (m *Delegate) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -939,7 +982,7 @@ func (m *Delegate) XXX_DiscardUnknown() {
var xxx_messageInfo_Delegate proto.InternalMessageInfo
-func (m *Delegate) GetValidatorIdentity() *v1alpha1.IdentityKey {
+func (m *Delegate) GetValidatorIdentity() *v1.IdentityKey {
if m != nil {
return m.ValidatorIdentity
}
@@ -953,14 +996,14 @@ func (m *Delegate) GetEpochIndex() uint64 {
return 0
}
-func (m *Delegate) GetUnbondedAmount() *v1alpha1.Amount {
+func (m *Delegate) GetUnbondedAmount() *v11.Amount {
if m != nil {
return m.UnbondedAmount
}
return nil
}
-func (m *Delegate) GetDelegationAmount() *v1alpha1.Amount {
+func (m *Delegate) GetDelegationAmount() *v11.Amount {
if m != nil {
return m.DelegationAmount
}
@@ -970,24 +1013,26 @@ func (m *Delegate) GetDelegationAmount() *v1alpha1.Amount {
// A transaction action withdrawing stake from a validator's delegation pool.
type Undelegate struct {
// The identity key of the validator to undelegate from.
- ValidatorIdentity *v1alpha1.IdentityKey `protobuf:"bytes,1,opt,name=validator_identity,json=validatorIdentity,proto3" json:"validator_identity,omitempty"`
+ ValidatorIdentity *v1.IdentityKey `protobuf:"bytes,1,opt,name=validator_identity,json=validatorIdentity,proto3" json:"validator_identity,omitempty"`
// 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"`
+ StartEpochIndex uint64 `protobuf:"varint,2,opt,name=start_epoch_index,json=startEpochIndex,proto3" json:"start_epoch_index,omitempty"` // Deprecated: Do not use.
// 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 *v11.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 *v11.Amount `protobuf:"bytes,4,opt,name=delegation_amount,json=delegationAmount,proto3" json:"delegation_amount,omitempty"`
+ // The epoch in which this delegation was performed.
+ FromEpoch *v12.Epoch `protobuf:"bytes,5,opt,name=from_epoch,json=fromEpoch,proto3" json:"from_epoch,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_061b0086577193ed, []int{12}
}
func (m *Undelegate) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1016,13 +1061,14 @@ func (m *Undelegate) XXX_DiscardUnknown() {
var xxx_messageInfo_Undelegate proto.InternalMessageInfo
-func (m *Undelegate) GetValidatorIdentity() *v1alpha1.IdentityKey {
+func (m *Undelegate) GetValidatorIdentity() *v1.IdentityKey {
if m != nil {
return m.ValidatorIdentity
}
return nil
}
+// Deprecated: Do not use.
func (m *Undelegate) GetStartEpochIndex() uint64 {
if m != nil {
return m.StartEpochIndex
@@ -1030,20 +1076,27 @@ func (m *Undelegate) GetStartEpochIndex() uint64 {
return 0
}
-func (m *Undelegate) GetUnbondedAmount() *v1alpha1.Amount {
+func (m *Undelegate) GetUnbondedAmount() *v11.Amount {
if m != nil {
return m.UnbondedAmount
}
return nil
}
-func (m *Undelegate) GetDelegationAmount() *v1alpha1.Amount {
+func (m *Undelegate) GetDelegationAmount() *v11.Amount {
if m != nil {
return m.DelegationAmount
}
return nil
}
+func (m *Undelegate) GetFromEpoch() *v12.Epoch {
+ if m != nil {
+ return m.FromEpoch
+ }
+ return nil
+}
+
// A transaction action finishing an undelegation, converting (slashable)
// "unbonding tokens" to (unslashable) staking tokens.
type UndelegateClaim struct {
@@ -1055,7 +1108,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_061b0086577193ed, []int{13}
}
func (m *UndelegateClaim) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1100,21 +1153,23 @@ func (m *UndelegateClaim) GetProof() []byte {
type UndelegateClaimBody struct {
// The identity key of the validator to finish undelegating from.
- ValidatorIdentity *v1alpha1.IdentityKey `protobuf:"bytes,1,opt,name=validator_identity,json=validatorIdentity,proto3" json:"validator_identity,omitempty"`
+ ValidatorIdentity *v1.IdentityKey `protobuf:"bytes,1,opt,name=validator_identity,json=validatorIdentity,proto3" json:"validator_identity,omitempty"`
// The epoch in which unbonding began, used to verify the penalty.
- StartEpochIndex uint64 `protobuf:"varint,2,opt,name=start_epoch_index,json=startEpochIndex,proto3" json:"start_epoch_index,omitempty"`
+ StartEpochIndex uint64 `protobuf:"varint,2,opt,name=start_epoch_index,json=startEpochIndex,proto3" json:"start_epoch_index,omitempty"` // Deprecated: Do not use.
// The penalty applied to undelegation, in bps^2 (10e-8).
// 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 *v13.BalanceCommitment `protobuf:"bytes,4,opt,name=balance_commitment,json=balanceCommitment,proto3" json:"balance_commitment,omitempty"`
+ // / The starting height of the epoch during which unbonding began.
+ UnbondingStartHeight uint64 `protobuf:"varint,5,opt,name=unbonding_start_height,json=unbondingStartHeight,proto3" json:"unbonding_start_height,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_061b0086577193ed, []int{14}
}
func (m *UndelegateClaimBody) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1143,13 +1198,14 @@ func (m *UndelegateClaimBody) XXX_DiscardUnknown() {
var xxx_messageInfo_UndelegateClaimBody proto.InternalMessageInfo
-func (m *UndelegateClaimBody) GetValidatorIdentity() *v1alpha1.IdentityKey {
+func (m *UndelegateClaimBody) GetValidatorIdentity() *v1.IdentityKey {
if m != nil {
return m.ValidatorIdentity
}
return nil
}
+// Deprecated: Do not use.
func (m *UndelegateClaimBody) GetStartEpochIndex() uint64 {
if m != nil {
return m.StartEpochIndex
@@ -1164,37 +1220,46 @@ func (m *UndelegateClaimBody) GetPenalty() *Penalty {
return nil
}
-func (m *UndelegateClaimBody) GetBalanceCommitment() *v1alpha1.BalanceCommitment {
+func (m *UndelegateClaimBody) GetBalanceCommitment() *v13.BalanceCommitment {
if m != nil {
return m.BalanceCommitment
}
return nil
}
+func (m *UndelegateClaimBody) GetUnbondingStartHeight() uint64 {
+ if m != nil {
+ return m.UnbondingStartHeight
+ }
+ return 0
+}
+
type UndelegateClaimPlan struct {
// The identity key of the validator to finish undelegating from.
- ValidatorIdentity *v1alpha1.IdentityKey `protobuf:"bytes,1,opt,name=validator_identity,json=validatorIdentity,proto3" json:"validator_identity,omitempty"`
+ ValidatorIdentity *v1.IdentityKey `protobuf:"bytes,1,opt,name=validator_identity,json=validatorIdentity,proto3" json:"validator_identity,omitempty"`
// The epoch in which unbonding began, used to verify the penalty.
- StartEpochIndex uint64 `protobuf:"varint,2,opt,name=start_epoch_index,json=startEpochIndex,proto3" json:"start_epoch_index,omitempty"`
+ StartEpochIndex uint64 `protobuf:"varint,2,opt,name=start_epoch_index,json=startEpochIndex,proto3" json:"start_epoch_index,omitempty"` // Deprecated: Do not use.
// The penalty applied to undelegation, in bps^2 (10e-8).
// In the happy path (no slashing), this is 0.
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 *v11.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.
ProofBlindingR []byte `protobuf:"bytes,7,opt,name=proof_blinding_r,json=proofBlindingR,proto3" json:"proof_blinding_r,omitempty"`
// The second blinding factor to use for the ZK undelegate claim proof.
ProofBlindingS []byte `protobuf:"bytes,8,opt,name=proof_blinding_s,json=proofBlindingS,proto3" json:"proof_blinding_s,omitempty"`
+ // The height during which unbonding began.
+ UnbondingStartHeight uint64 `protobuf:"varint,9,opt,name=unbonding_start_height,json=unbondingStartHeight,proto3" json:"unbonding_start_height,omitempty"`
}
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_061b0086577193ed, []int{15}
}
func (m *UndelegateClaimPlan) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1223,13 +1288,14 @@ func (m *UndelegateClaimPlan) XXX_DiscardUnknown() {
var xxx_messageInfo_UndelegateClaimPlan proto.InternalMessageInfo
-func (m *UndelegateClaimPlan) GetValidatorIdentity() *v1alpha1.IdentityKey {
+func (m *UndelegateClaimPlan) GetValidatorIdentity() *v1.IdentityKey {
if m != nil {
return m.ValidatorIdentity
}
return nil
}
+// Deprecated: Do not use.
func (m *UndelegateClaimPlan) GetStartEpochIndex() uint64 {
if m != nil {
return m.StartEpochIndex
@@ -1244,7 +1310,7 @@ func (m *UndelegateClaimPlan) GetPenalty() *Penalty {
return nil
}
-func (m *UndelegateClaimPlan) GetUnbondingAmount() *v1alpha1.Amount {
+func (m *UndelegateClaimPlan) GetUnbondingAmount() *v11.Amount {
if m != nil {
return m.UnbondingAmount
}
@@ -1272,6 +1338,13 @@ func (m *UndelegateClaimPlan) GetProofBlindingS() []byte {
return nil
}
+func (m *UndelegateClaimPlan) GetUnbondingStartHeight() uint64 {
+ if m != nil {
+ return m.UnbondingStartHeight
+ }
+ return 0
+}
+
// A list of pending delegations and undelegations.
type DelegationChanges struct {
Delegations []*Delegate `protobuf:"bytes,1,rep,name=delegations,proto3" json:"delegations,omitempty"`
@@ -1282,7 +1355,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_061b0086577193ed, []int{16}
}
func (m *DelegationChanges) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1336,7 +1409,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_061b0086577193ed, []int{17}
}
func (m *Uptime) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1389,14 +1462,14 @@ func (m *Uptime) GetBitvec() []byte {
// Tracks our view of Tendermint's view of the validator set, so we can keep it
// from getting confused.
type CurrentConsensusKeys struct {
- ConsensusKeys []*v1alpha1.ConsensusKey `protobuf:"bytes,1,rep,name=consensus_keys,json=consensusKeys,proto3" json:"consensus_keys,omitempty"`
+ ConsensusKeys []*v1.ConsensusKey `protobuf:"bytes,1,rep,name=consensus_keys,json=consensusKeys,proto3" json:"consensus_keys,omitempty"`
}
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_061b0086577193ed, []int{18}
}
func (m *CurrentConsensusKeys) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1425,7 +1498,7 @@ func (m *CurrentConsensusKeys) XXX_DiscardUnknown() {
var xxx_messageInfo_CurrentConsensusKeys proto.InternalMessageInfo
-func (m *CurrentConsensusKeys) GetConsensusKeys() []*v1alpha1.ConsensusKey {
+func (m *CurrentConsensusKeys) GetConsensusKeys() []*v1.ConsensusKey {
if m != nil {
return m.ConsensusKeys
}
@@ -1434,14 +1507,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_061b0086577193ed, []int{19}
}
func (m *Penalty) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1470,819 +1543,994 @@ 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 {
+ // 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_061b0086577193ed, []int{20}
+}
+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
+ }
+}
+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) 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_ValidatorInfoRequest proto.InternalMessageInfo
+
+func (m *ValidatorInfoRequest) GetShowInactive() bool {
+ if m != nil {
+ return m.ShowInactive
}
- return dAtA[:n], nil
+ return false
}
-func (m *Validator) 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 *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))
+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_061b0086577193ed, []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
}
- i--
- dAtA[i] = 0xa
+ 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 *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
+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 *ValidatorList) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
+type ValidatorStatusRequest struct {
+ IdentityKey *v1.IdentityKey `protobuf:"bytes,2,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,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 *ValidatorStatusRequest) Reset() { *m = ValidatorStatusRequest{} }
+func (m *ValidatorStatusRequest) String() string { return proto.CompactTextString(m) }
+func (*ValidatorStatusRequest) ProtoMessage() {}
+func (*ValidatorStatusRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_061b0086577193ed, []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 *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
- }
- return dAtA[:n], 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) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
+var xxx_messageInfo_ValidatorStatusRequest proto.InternalMessageInfo
-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) GetIdentityKey() *v1.IdentityKey {
+ if m != nil {
+ return m.IdentityKey
}
- return len(dAtA) - i, nil
+ return nil
}
-func (m *FundingStream_ToAddress_) 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_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
- }
- return len(dAtA) - i, nil
+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_061b0086577193ed, []int{23}
}
-func (m *FundingStream_ToDao_) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
+func (m *ValidatorStatusResponse) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
}
-
-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) 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
- }
- return dAtA[:n], nil
+func (m *ValidatorStatusResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ValidatorStatusResponse.Merge(m, src)
}
-
-func (m *FundingStream_ToAddress) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
+func (m *ValidatorStatusResponse) XXX_Size() int {
+ return m.Size()
+}
+func (m *ValidatorStatusResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_ValidatorStatusResponse.DiscardUnknown(m)
}
-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
+var xxx_messageInfo_ValidatorStatusResponse proto.InternalMessageInfo
+
+func (m *ValidatorStatusResponse) GetStatus() *ValidatorStatus {
+ if m != nil {
+ return m.Status
}
- return len(dAtA) - i, nil
+ return nil
}
-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
+// Requests the compounded penalty for a validator over a range of epochs.
+type ValidatorPenaltyRequest struct {
+ IdentityKey *v1.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 *ValidatorPenaltyRequest) Reset() { *m = ValidatorPenaltyRequest{} }
+func (m *ValidatorPenaltyRequest) String() string { return proto.CompactTextString(m) }
+func (*ValidatorPenaltyRequest) ProtoMessage() {}
+func (*ValidatorPenaltyRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_061b0086577193ed, []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 dAtA[:n], 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) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
+var xxx_messageInfo_ValidatorPenaltyRequest proto.InternalMessageInfo
+
+func (m *ValidatorPenaltyRequest) GetIdentityKey() *v1.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_061b0086577193ed, []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 {
+ IdentityKey *v1.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
- }
- if m.EpochIndex != 0 {
- i = encodeVarintStake(dAtA, i, uint64(m.EpochIndex))
- i--
- dAtA[i] = 0x8
+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_061b0086577193ed, []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
}
- return len(dAtA) - i, nil
+}
+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)
}
-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
+var xxx_messageInfo_CurrentValidatorRateRequest proto.InternalMessageInfo
+
+func (m *CurrentValidatorRateRequest) GetIdentityKey() *v1.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
- }
- if m.VotingPower != 0 {
- i = encodeVarintStake(dAtA, i, uint64(m.VotingPower))
- i--
- dAtA[i] = 0x18
- }
- 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))
- }
- 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))
+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_061b0086577193ed, []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
}
- i--
- dAtA[i] = 0xa
+ return b[:n], nil
}
- return len(dAtA) - i, nil
+}
+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)
}
-func (m *BondingState) 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_CurrentValidatorRateResponse proto.InternalMessageInfo
+
+func (m *CurrentValidatorRateResponse) GetData() *RateData {
+ if m != nil {
+ return m.Data
}
- return dAtA[:n], nil
+ return nil
}
-func (m *BondingState) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
+// 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"` // Deprecated: Do not use.
+ // 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"`
+ // The minimum amount of stake required for a validator to be indexed by the protocol.
+ MinValidatorStake *v11.Amount `protobuf:"bytes,8,opt,name=min_validator_stake,json=minValidatorStake,proto3" json:"min_validator_stake,omitempty"`
+ // The number of blocks that must elapse before an unbonding note can be claimed.
+ UnbondingDelay uint64 `protobuf:"varint,9,opt,name=unbonding_delay,json=unbondingDelay,proto3" json:"unbonding_delay,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_061b0086577193ed, []int{28}
+}
+func (m *StakeParameters) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
}
-
-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
- }
+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
}
+ return b[:n], nil
}
- if m.State != 0 {
- i = encodeVarintStake(dAtA, i, uint64(m.State))
- i--
- dAtA[i] = 0x8
- }
- return len(dAtA) - i, nil
}
-
-func (m *BondingState_UnbondingEpoch) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
+func (m *StakeParameters) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_StakeParameters.Merge(m, src)
}
-
-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 (m *StakeParameters) XXX_Size() int {
+ return m.Size()
}
-func (m *ValidatorState) 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 *StakeParameters) XXX_DiscardUnknown() {
+ xxx_messageInfo_StakeParameters.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StakeParameters proto.InternalMessageInfo
+
+// Deprecated: Do not use.
+func (m *StakeParameters) GetUnbondingEpochs() uint64 {
+ if m != nil {
+ return m.UnbondingEpochs
}
- return dAtA[:n], nil
+ return 0
}
-func (m *ValidatorState) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
+func (m *StakeParameters) GetActiveValidatorLimit() uint64 {
+ if m != nil {
+ return m.ActiveValidatorLimit
+ }
+ return 0
}
-func (m *ValidatorState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
- var l int
- _ = l
- if m.State != 0 {
- i = encodeVarintStake(dAtA, i, uint64(m.State))
- i--
- dAtA[i] = 0x8
+func (m *StakeParameters) GetBaseRewardRate() uint64 {
+ if m != nil {
+ return m.BaseRewardRate
}
- return len(dAtA) - i, nil
+ return 0
}
-func (m *ValidatorInfo) 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 *StakeParameters) GetSlashingPenaltyMisbehavior() uint64 {
+ if m != nil {
+ return m.SlashingPenaltyMisbehavior
}
- return dAtA[:n], nil
+ return 0
}
-func (m *ValidatorInfo) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
+func (m *StakeParameters) GetSlashingPenaltyDowntime() uint64 {
+ if m != nil {
+ return m.SlashingPenaltyDowntime
+ }
+ return 0
}
-func (m *ValidatorInfo) 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 = encodeVarintStake(dAtA, i, uint64(size))
- }
- i--
- dAtA[i] = 0x1a
+func (m *StakeParameters) GetSignedBlocksWindowLen() uint64 {
+ if m != nil {
+ return m.SignedBlocksWindowLen
}
- 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
+ return 0
+}
+
+func (m *StakeParameters) GetMissedBlocksMaximum() uint64 {
+ if m != nil {
+ return m.MissedBlocksMaximum
}
- 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 0
+}
+
+func (m *StakeParameters) GetMinValidatorStake() *v11.Amount {
+ if m != nil {
+ return m.MinValidatorStake
}
- return len(dAtA) - i, nil
+ return nil
}
-func (m *ValidatorDefinition) 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 *StakeParameters) GetUnbondingDelay() uint64 {
+ if m != nil {
+ return m.UnbondingDelay
}
- return dAtA[:n], nil
+ return 0
}
-func (m *ValidatorDefinition) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
+// 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 *ValidatorDefinition) 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
- }
- i -= size
- i = encodeVarintStake(dAtA, i, uint64(size))
+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_061b0086577193ed, []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 *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
+var xxx_messageInfo_GenesisContent proto.InternalMessageInfo
+
+func (m *GenesisContent) GetStakeParams() *StakeParameters {
+ if m != nil {
+ return m.StakeParams
}
- return dAtA[:n], nil
+ return nil
}
-func (m *Delegate) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
+func (m *GenesisContent) GetValidators() []*Validator {
+ if m != nil {
+ return m.Validators
+ }
+ return nil
}
-func (m *Delegate) 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
+func init() {
+ proto.RegisterEnum("penumbra.core.component.stake.v1.BondingState_BondingStateEnum", BondingState_BondingStateEnum_name, BondingState_BondingStateEnum_value)
+ proto.RegisterEnum("penumbra.core.component.stake.v1.ValidatorState_ValidatorStateEnum", ValidatorState_ValidatorStateEnum_name, ValidatorState_ValidatorStateEnum_value)
+ proto.RegisterType((*ZKUndelegateClaimProof)(nil), "penumbra.core.component.stake.v1.ZKUndelegateClaimProof")
+ proto.RegisterType((*Validator)(nil), "penumbra.core.component.stake.v1.Validator")
+ proto.RegisterType((*ValidatorList)(nil), "penumbra.core.component.stake.v1.ValidatorList")
+ proto.RegisterType((*FundingStream)(nil), "penumbra.core.component.stake.v1.FundingStream")
+ proto.RegisterType((*FundingStream_ToAddress)(nil), "penumbra.core.component.stake.v1.FundingStream.ToAddress")
+ proto.RegisterType((*FundingStream_ToCommunityPool)(nil), "penumbra.core.component.stake.v1.FundingStream.ToCommunityPool")
+ proto.RegisterType((*RateData)(nil), "penumbra.core.component.stake.v1.RateData")
+ proto.RegisterType((*BaseRateData)(nil), "penumbra.core.component.stake.v1.BaseRateData")
+ proto.RegisterType((*ValidatorStatus)(nil), "penumbra.core.component.stake.v1.ValidatorStatus")
+ proto.RegisterType((*BondingState)(nil), "penumbra.core.component.stake.v1.BondingState")
+ proto.RegisterType((*ValidatorState)(nil), "penumbra.core.component.stake.v1.ValidatorState")
+ proto.RegisterType((*ValidatorInfo)(nil), "penumbra.core.component.stake.v1.ValidatorInfo")
+ proto.RegisterType((*ValidatorDefinition)(nil), "penumbra.core.component.stake.v1.ValidatorDefinition")
+ proto.RegisterType((*Delegate)(nil), "penumbra.core.component.stake.v1.Delegate")
+ proto.RegisterType((*Undelegate)(nil), "penumbra.core.component.stake.v1.Undelegate")
+ proto.RegisterType((*UndelegateClaim)(nil), "penumbra.core.component.stake.v1.UndelegateClaim")
+ proto.RegisterType((*UndelegateClaimBody)(nil), "penumbra.core.component.stake.v1.UndelegateClaimBody")
+ proto.RegisterType((*UndelegateClaimPlan)(nil), "penumbra.core.component.stake.v1.UndelegateClaimPlan")
+ proto.RegisterType((*DelegationChanges)(nil), "penumbra.core.component.stake.v1.DelegationChanges")
+ proto.RegisterType((*Uptime)(nil), "penumbra.core.component.stake.v1.Uptime")
+ proto.RegisterType((*CurrentConsensusKeys)(nil), "penumbra.core.component.stake.v1.CurrentConsensusKeys")
+ proto.RegisterType((*Penalty)(nil), "penumbra.core.component.stake.v1.Penalty")
+ proto.RegisterType((*ValidatorInfoRequest)(nil), "penumbra.core.component.stake.v1.ValidatorInfoRequest")
+ proto.RegisterType((*ValidatorInfoResponse)(nil), "penumbra.core.component.stake.v1.ValidatorInfoResponse")
+ proto.RegisterType((*ValidatorStatusRequest)(nil), "penumbra.core.component.stake.v1.ValidatorStatusRequest")
+ proto.RegisterType((*ValidatorStatusResponse)(nil), "penumbra.core.component.stake.v1.ValidatorStatusResponse")
+ proto.RegisterType((*ValidatorPenaltyRequest)(nil), "penumbra.core.component.stake.v1.ValidatorPenaltyRequest")
+ proto.RegisterType((*ValidatorPenaltyResponse)(nil), "penumbra.core.component.stake.v1.ValidatorPenaltyResponse")
+ proto.RegisterType((*CurrentValidatorRateRequest)(nil), "penumbra.core.component.stake.v1.CurrentValidatorRateRequest")
+ proto.RegisterType((*CurrentValidatorRateResponse)(nil), "penumbra.core.component.stake.v1.CurrentValidatorRateResponse")
+ proto.RegisterType((*StakeParameters)(nil), "penumbra.core.component.stake.v1.StakeParameters")
+ proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.stake.v1.GenesisContent")
+}
+
+func init() {
+ proto.RegisterFile("penumbra/core/component/stake/v1/stake.proto", fileDescriptor_061b0086577193ed)
+}
+
+var fileDescriptor_061b0086577193ed = []byte{
+ // 2266 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x59, 0x4b, 0x6c, 0x1b, 0xc9,
+ 0xd1, 0xd6, 0x50, 0xd4, 0x83, 0x25, 0xbe, 0xd4, 0x7e, 0xd1, 0x5a, 0x5b, 0xe6, 0x3f, 0xf6, 0x9f,
+ 0xd5, 0xee, 0x3a, 0xd4, 0x4a, 0x79, 0x6c, 0x56, 0x8b, 0xec, 0xae, 0xf8, 0xb0, 0x4c, 0x5b, 0x96,
+ 0xb9, 0x43, 0x59, 0xd9, 0x18, 0x46, 0x06, 0x43, 0x4e, 0x4b, 0x1a, 0x98, 0xd3, 0xcd, 0x9d, 0x6e,
+ 0x52, 0x16, 0x72, 0xdb, 0x43, 0x80, 0xbd, 0xed, 0x25, 0x40, 0x4e, 0x39, 0xe4, 0x98, 0x5b, 0x90,
+ 0xc7, 0x39, 0x40, 0x10, 0x20, 0xc8, 0x69, 0x6f, 0x09, 0x92, 0x4b, 0x60, 0x1f, 0x02, 0x04, 0x48,
+ 0xae, 0xb9, 0x06, 0xdd, 0xd3, 0x33, 0x9c, 0x21, 0x25, 0x53, 0x54, 0x1c, 0xc0, 0x17, 0x69, 0xba,
+ 0xfa, 0xab, 0xea, 0xaa, 0xea, 0xea, 0xaa, 0xea, 0x26, 0xdc, 0xee, 0x62, 0xd2, 0x73, 0x5b, 0x9e,
+ 0xb5, 0xda, 0xa6, 0x1e, 0x5e, 0x6d, 0x53, 0xb7, 0x4b, 0x09, 0x26, 0x7c, 0x95, 0x71, 0xeb, 0x29,
+ 0x5e, 0xed, 0xaf, 0xf9, 0x1f, 0xa5, 0xae, 0x47, 0x39, 0x45, 0xc5, 0x00, 0x5d, 0x12, 0xe8, 0x52,
+ 0x88, 0x2e, 0xf9, 0xa0, 0xfe, 0xda, 0x92, 0x1e, 0x97, 0x67, 0x31, 0x86, 0xb9, 0x90, 0x22, 0x3f,
+ 0x7c, 0x29, 0x4b, 0x2b, 0xa7, 0xae, 0xd9, 0x96, 0x58, 0xd6, 0x0e, 0x90, 0xc5, 0x38, 0xf2, 0x29,
+ 0x3e, 0x66, 0x02, 0x20, 0xfe, 0x2b, 0xc4, 0x72, 0x1c, 0x41, 0x7a, 0xae, 0x00, 0x90, 0x9e, 0xeb,
+ 0xcf, 0xeb, 0x25, 0xb8, 0xfc, 0xf8, 0xfe, 0x23, 0x62, 0xe3, 0x0e, 0x3e, 0xb0, 0x38, 0xae, 0x74,
+ 0x2c, 0xc7, 0x6d, 0x78, 0x94, 0xee, 0xa3, 0x8b, 0x30, 0xe3, 0x10, 0x82, 0xbd, 0x82, 0x56, 0xd4,
+ 0x56, 0xd2, 0x86, 0x3f, 0xd0, 0x7f, 0x31, 0x0d, 0xa9, 0x3d, 0xab, 0xe3, 0xd8, 0x16, 0xa7, 0x1e,
+ 0xaa, 0x41, 0xda, 0xb1, 0x31, 0xe1, 0x0e, 0x3f, 0x36, 0x9f, 0xe2, 0x63, 0x09, 0x5d, 0x58, 0xd7,
+ 0x4b, 0x71, 0x37, 0x48, 0x75, 0xfa, 0x6b, 0xa5, 0xba, 0x82, 0xde, 0xc7, 0xc7, 0xc6, 0x82, 0x33,
+ 0x18, 0xa0, 0x9b, 0x90, 0x69, 0x53, 0xc2, 0x30, 0x61, 0x3d, 0x26, 0xe5, 0x24, 0xe4, 0x92, 0xe9,
+ 0x90, 0x28, 0x40, 0x08, 0x92, 0xc4, 0x72, 0x71, 0x61, 0xba, 0xa8, 0xad, 0xa4, 0x0c, 0xf9, 0x8d,
+ 0x0a, 0x30, 0x77, 0x84, 0x5b, 0xcc, 0xe1, 0xb8, 0x90, 0x94, 0xe4, 0x60, 0x88, 0x8a, 0xb0, 0x60,
+ 0x63, 0xd6, 0xf6, 0x9c, 0x2e, 0x77, 0x28, 0x29, 0xcc, 0xc8, 0xd9, 0x28, 0x49, 0xf0, 0x62, 0x62,
+ 0xb5, 0x3a, 0xd8, 0x2e, 0xcc, 0x17, 0xb5, 0x95, 0x79, 0x23, 0x18, 0xa2, 0x4f, 0x21, 0xb7, 0xdf,
+ 0x23, 0xb6, 0x43, 0x0e, 0x4c, 0xc6, 0x3d, 0x6c, 0xb9, 0xac, 0x30, 0x5b, 0x9c, 0x5e, 0x59, 0x58,
+ 0x5f, 0x2d, 0x8d, 0xdb, 0xdf, 0xd2, 0x1d, 0x9f, 0xb1, 0x29, 0xf9, 0x8c, 0xec, 0x7e, 0x74, 0xc8,
+ 0xd0, 0x9b, 0x90, 0x63, 0xf8, 0xb3, 0x1e, 0x26, 0x6d, 0x6c, 0x0a, 0x41, 0xd8, 0x2b, 0xcc, 0x15,
+ 0xb5, 0x95, 0x8c, 0x91, 0x0d, 0xc8, 0x3b, 0x92, 0x8a, 0xee, 0x43, 0xf6, 0x80, 0xf6, 0xb1, 0x47,
+ 0x2c, 0x01, 0x15, 0x2e, 0x49, 0x49, 0xd7, 0xde, 0x3a, 0xc5, 0xb5, 0x5b, 0x21, 0x58, 0x38, 0x37,
+ 0x73, 0x10, 0x1d, 0xea, 0x8f, 0x21, 0x13, 0x6e, 0xd9, 0xb6, 0xc3, 0x38, 0xaa, 0x43, 0xb6, 0x1f,
+ 0x10, 0x84, 0x70, 0x56, 0xd0, 0xa4, 0x7d, 0x67, 0xd9, 0xb8, 0x4c, 0xc8, 0x79, 0x1f, 0x1f, 0x33,
+ 0xfd, 0x4f, 0x09, 0xc8, 0xc4, 0x6c, 0x46, 0x8f, 0x01, 0x38, 0x35, 0x2d, 0xdb, 0xf6, 0x30, 0x63,
+ 0x2a, 0x22, 0xde, 0x9f, 0xd0, 0x71, 0xa5, 0x5d, 0xba, 0xe9, 0x0b, 0xb8, 0x3b, 0x65, 0xa4, 0x78,
+ 0x30, 0x40, 0x2e, 0x2c, 0x72, 0x6a, 0xb6, 0xa9, 0xeb, 0xf6, 0x88, 0x88, 0xb9, 0x2e, 0xa5, 0x1d,
+ 0x19, 0x2c, 0x0b, 0xeb, 0x1f, 0x4d, 0xbe, 0x44, 0x25, 0x90, 0xd3, 0xa0, 0xb4, 0x73, 0x77, 0xca,
+ 0xc8, 0xf1, 0x38, 0x69, 0xe9, 0x63, 0x48, 0x85, 0x8a, 0x88, 0x78, 0x89, 0x1a, 0x95, 0x32, 0x82,
+ 0x21, 0xba, 0x0a, 0xf3, 0x9e, 0xc5, 0xb1, 0xd9, 0xea, 0x32, 0xa9, 0x4c, 0xc6, 0x98, 0x13, 0xe3,
+ 0x72, 0x97, 0x2d, 0xdd, 0x86, 0xdc, 0xd0, 0x3a, 0x2f, 0x41, 0x97, 0x17, 0x20, 0xe5, 0xe1, 0xb6,
+ 0xd3, 0x75, 0x30, 0xe1, 0xfa, 0x4f, 0x13, 0x30, 0x6f, 0x58, 0x1c, 0x57, 0x2d, 0x6e, 0xbd, 0xba,
+ 0x83, 0xb6, 0x80, 0xbb, 0xb4, 0x7d, 0x68, 0x3a, 0xc4, 0xc6, 0xcf, 0xe4, 0xf2, 0xc9, 0x72, 0xa2,
+ 0xa0, 0x19, 0x20, 0xc9, 0x75, 0x41, 0x45, 0x0d, 0xb8, 0x34, 0x88, 0x0e, 0x0f, 0x1f, 0x59, 0x9e,
+ 0x6d, 0x0a, 0x0d, 0xe5, 0x11, 0x5b, 0x58, 0xbf, 0x36, 0xb4, 0xa8, 0xc8, 0x25, 0xfd, 0xb5, 0xd2,
+ 0xa6, 0x4b, 0x7b, 0x84, 0x1b, 0x17, 0x42, 0x56, 0x43, 0x72, 0x0a, 0x0b, 0xd0, 0x2e, 0x5c, 0x19,
+ 0x48, 0xc4, 0xcf, 0xda, 0x87, 0x16, 0x39, 0xc0, 0xbe, 0xcc, 0x99, 0x33, 0xc8, 0x1c, 0xa8, 0x53,
+ 0x53, 0xbc, 0x42, 0xaa, 0xfe, 0x3b, 0x0d, 0xd2, 0x65, 0x8b, 0xe1, 0xd0, 0x49, 0x37, 0xe2, 0xd6,
+ 0x09, 0x1f, 0x25, 0x63, 0x96, 0xdd, 0x81, 0x7c, 0xcb, 0x62, 0x38, 0x66, 0x54, 0xe2, 0x0c, 0x0a,
+ 0x64, 0x05, 0x57, 0xc4, 0x9e, 0x7b, 0x80, 0xa4, 0x9c, 0xb8, 0x29, 0xd3, 0x67, 0x90, 0x24, 0xd7,
+ 0x8f, 0x59, 0xf1, 0x9b, 0x04, 0xe4, 0xc2, 0xd3, 0xd9, 0xe4, 0x16, 0xef, 0xb1, 0x57, 0xb5, 0xdb,
+ 0x77, 0x60, 0x86, 0xf1, 0x81, 0x8d, 0xef, 0x8e, 0x3f, 0x21, 0x31, 0x45, 0xb0, 0xe1, 0xb3, 0xa3,
+ 0x8f, 0x20, 0xdd, 0xa7, 0x5c, 0xa4, 0xc3, 0x2e, 0x3d, 0xc2, 0xde, 0x99, 0x0c, 0x5d, 0xf0, 0x39,
+ 0x1a, 0x82, 0x01, 0x35, 0x21, 0xd3, 0xa2, 0x41, 0x42, 0x1d, 0x44, 0x52, 0x69, 0xbc, 0x42, 0x65,
+ 0xaa, 0x8e, 0xac, 0x50, 0x27, 0xdd, 0x8a, 0x8c, 0xf4, 0xbf, 0x24, 0x20, 0x1d, 0x9d, 0x46, 0x8f,
+ 0x02, 0x73, 0x85, 0xbb, 0xb2, 0x67, 0x49, 0x08, 0x51, 0xf6, 0xd8, 0xa0, 0x46, 0x7a, 0x6e, 0x60,
+ 0xfd, 0x6d, 0xc8, 0xf7, 0x88, 0x58, 0x99, 0x99, 0x16, 0x37, 0x65, 0x34, 0x45, 0x0e, 0x4e, 0x56,
+ 0xcd, 0x6d, 0xf2, 0x9a, 0x98, 0x41, 0x6f, 0xc3, 0x62, 0x04, 0x7d, 0x88, 0x9d, 0x83, 0x43, 0x2e,
+ 0x1d, 0x96, 0x34, 0x72, 0x21, 0xf4, 0xae, 0x24, 0xeb, 0x3f, 0xd1, 0x20, 0x3f, 0xbc, 0x2a, 0xd2,
+ 0x61, 0xb9, 0xfc, 0x70, 0xa7, 0x5a, 0xdf, 0xd9, 0x32, 0x9b, 0xbb, 0x9b, 0xbb, 0x35, 0xb3, 0xb6,
+ 0xf3, 0xe8, 0x81, 0xf9, 0x68, 0xa7, 0xd9, 0xa8, 0x55, 0xea, 0x77, 0xea, 0xb5, 0x6a, 0x7e, 0x0a,
+ 0x5d, 0x87, 0xab, 0x27, 0x60, 0x04, 0xa9, 0x56, 0xcd, 0x6b, 0xa8, 0x08, 0xd7, 0x4e, 0x14, 0xa1,
+ 0x88, 0xf9, 0x04, 0xba, 0x01, 0x6f, 0x9c, 0x8a, 0xa8, 0x55, 0xf3, 0xd3, 0xfa, 0xbf, 0x13, 0x90,
+ 0x8d, 0x07, 0x03, 0xfa, 0x7e, 0xdc, 0xbd, 0x95, 0x49, 0xa3, 0x69, 0x68, 0x18, 0x71, 0xb1, 0xfe,
+ 0x45, 0x02, 0xd0, 0xe8, 0x2c, 0xba, 0x05, 0xc5, 0xbd, 0xcd, 0xed, 0x7a, 0x75, 0x73, 0xf7, 0xa1,
+ 0x71, 0xba, 0x33, 0x8a, 0x70, 0xed, 0x44, 0x54, 0xb5, 0x76, 0xa7, 0xbe, 0x23, 0xfd, 0xf1, 0x7f,
+ 0x70, 0xfd, 0x44, 0x44, 0x7d, 0x67, 0xb3, 0xb2, 0x5b, 0xdf, 0xab, 0xf9, 0x0e, 0x39, 0x11, 0xa2,
+ 0x00, 0xd3, 0xa7, 0x02, 0xee, 0x6d, 0xd6, 0xb7, 0x6b, 0xd5, 0x7c, 0x12, 0xdd, 0x84, 0x1b, 0x27,
+ 0x02, 0x76, 0x1f, 0x3e, 0x28, 0x37, 0x77, 0x1f, 0x0a, 0x4d, 0x66, 0x4e, 0xd5, 0xa4, 0x5a, 0x6f,
+ 0x6e, 0x96, 0x85, 0x9c, 0x59, 0xfd, 0x5f, 0x5a, 0xa4, 0x5a, 0xd7, 0xc9, 0x3e, 0x45, 0x75, 0x48,
+ 0x85, 0x09, 0x50, 0xa5, 0x82, 0x77, 0x26, 0x70, 0xbe, 0x31, 0xe0, 0x46, 0x75, 0x98, 0x65, 0x32,
+ 0xc5, 0xa8, 0x94, 0xb0, 0x36, 0xe1, 0x26, 0xf6, 0x98, 0xa1, 0x04, 0xa0, 0x2d, 0x48, 0xc9, 0x32,
+ 0x66, 0x5b, 0xdc, 0x52, 0x19, 0xe1, 0xed, 0xf1, 0xd2, 0x82, 0x5c, 0x6d, 0xc8, 0x1a, 0x28, 0xbe,
+ 0xf4, 0x1f, 0xc2, 0x85, 0x70, 0x8d, 0x2a, 0xde, 0x77, 0x88, 0x23, 0xdb, 0xb3, 0x57, 0x68, 0xf5,
+ 0x55, 0x98, 0xb7, 0x7a, 0xfc, 0xd0, 0x64, 0xce, 0x81, 0xea, 0x2c, 0xe7, 0xc4, 0xb8, 0xe9, 0x1c,
+ 0xe8, 0x5f, 0x26, 0x60, 0xbe, 0xaa, 0x7a, 0x5f, 0xf4, 0x09, 0xa0, 0x41, 0x99, 0x0a, 0x12, 0xe9,
+ 0x04, 0xc9, 0x77, 0x31, 0xe4, 0x0e, 0xa8, 0xc3, 0x25, 0x29, 0x31, 0x52, 0x92, 0x6a, 0xa0, 0xd2,
+ 0x02, 0xb6, 0x4d, 0x4b, 0xa6, 0xce, 0x33, 0xa5, 0xd7, 0x6c, 0xc0, 0xe4, 0x8f, 0x51, 0x1d, 0x16,
+ 0x55, 0x0b, 0xef, 0x50, 0x12, 0x08, 0x3a, 0x4b, 0xbd, 0xce, 0x0f, 0xd8, 0x7c, 0x8a, 0xfe, 0xf7,
+ 0x04, 0xc0, 0xe0, 0x42, 0xf0, 0xbf, 0x70, 0x4a, 0x09, 0x16, 0x19, 0xb7, 0x3c, 0x95, 0x4c, 0x47,
+ 0x7a, 0x91, 0x9c, 0x9c, 0xac, 0xbd, 0xc6, 0x3e, 0x42, 0x55, 0x80, 0x7d, 0x8f, 0xba, 0xaa, 0x1a,
+ 0xf8, 0x3d, 0xcc, 0xff, 0x9f, 0x1e, 0x9d, 0x6d, 0x2e, 0xa4, 0x49, 0x8b, 0x8c, 0x94, 0x60, 0x94,
+ 0x9f, 0xba, 0x07, 0xb9, 0xa1, 0x9b, 0x17, 0xaa, 0x43, 0xb2, 0x45, 0xed, 0xc0, 0xbf, 0xdf, 0x1a,
+ 0x1f, 0xf0, 0x43, 0x02, 0xca, 0xd4, 0x3e, 0x36, 0xa4, 0x08, 0x71, 0x7f, 0xeb, 0x8a, 0x8b, 0x9c,
+ 0x0a, 0x79, 0x7f, 0xa0, 0xff, 0x33, 0x01, 0x17, 0x4e, 0xe0, 0x79, 0x1d, 0xb6, 0xb9, 0x02, 0x73,
+ 0x5d, 0x4c, 0xac, 0x0e, 0x3f, 0x56, 0xdb, 0xfb, 0xd6, 0x78, 0xf3, 0x1b, 0x3e, 0x83, 0x11, 0x70,
+ 0xa2, 0x4f, 0x45, 0x6b, 0xd6, 0x91, 0xb7, 0x26, 0x71, 0x4d, 0x70, 0xb8, 0x8b, 0xc3, 0x5d, 0x1e,
+ 0x96, 0xe7, 0xdf, 0xb9, 0x45, 0x1f, 0xe0, 0x73, 0x54, 0x42, 0x06, 0x63, 0xb1, 0x35, 0x4c, 0x42,
+ 0xdf, 0x84, 0xcb, 0x7e, 0x40, 0xa9, 0x36, 0xc6, 0x0b, 0xcb, 0xfb, 0x8c, 0x3c, 0xd5, 0x17, 0xc3,
+ 0xd9, 0xa6, 0x98, 0x54, 0x35, 0xfe, 0xaf, 0xd3, 0x23, 0xfe, 0x6e, 0x74, 0x2c, 0xf2, 0x9a, 0xf9,
+ 0x3b, 0x79, 0x6e, 0x7f, 0x6f, 0x05, 0xdd, 0x91, 0xf0, 0x8a, 0x3a, 0x53, 0x67, 0xe9, 0xe9, 0x73,
+ 0x21, 0x97, 0x3a, 0x52, 0x6f, 0x89, 0xde, 0xdc, 0xdf, 0xb8, 0x56, 0xc7, 0x91, 0x33, 0x85, 0x59,
+ 0x19, 0xb9, 0x39, 0x45, 0x2f, 0x2b, 0x32, 0x5a, 0x81, 0xbc, 0x0c, 0xe6, 0x10, 0x68, 0xfa, 0xd7,
+ 0xe8, 0xb4, 0x91, 0x95, 0xf4, 0x00, 0x68, 0x9c, 0x80, 0x64, 0xf2, 0xb2, 0x3f, 0x8c, 0x6c, 0xbe,
+ 0x64, 0x77, 0x53, 0x2f, 0xd9, 0xdd, 0x5f, 0x6b, 0xb0, 0x58, 0x0d, 0x93, 0x43, 0x45, 0x76, 0xf5,
+ 0x0c, 0x6d, 0xc3, 0xc2, 0x20, 0x63, 0x04, 0x77, 0xeb, 0x33, 0x14, 0xc7, 0xa0, 0x10, 0x19, 0x51,
+ 0x76, 0x64, 0x40, 0xa6, 0x47, 0xa2, 0xf2, 0x12, 0x52, 0xde, 0xed, 0x49, 0x72, 0x83, 0x11, 0x17,
+ 0xa1, 0x77, 0x60, 0xf6, 0x51, 0x97, 0x3b, 0x2e, 0x46, 0xef, 0x00, 0xb2, 0x98, 0x29, 0x3d, 0x44,
+ 0xdb, 0x4f, 0x03, 0x9b, 0xfd, 0xab, 0x53, 0xce, 0x62, 0x0f, 0xf7, 0xcb, 0x82, 0xee, 0x9b, 0x8b,
+ 0xae, 0x03, 0x1c, 0x39, 0xc4, 0xa6, 0x47, 0x66, 0x07, 0x13, 0x75, 0x79, 0x4d, 0xf9, 0x94, 0x6d,
+ 0x4c, 0xd0, 0x65, 0x98, 0x6d, 0x39, 0xbc, 0x8f, 0xdb, 0xf2, 0xfc, 0xa6, 0x0d, 0x35, 0xd2, 0x5b,
+ 0x70, 0xb1, 0xd2, 0xf3, 0x3c, 0x4c, 0x78, 0x25, 0xf2, 0xa0, 0xc3, 0xd0, 0x3d, 0xc8, 0xc6, 0x9e,
+ 0x7d, 0x02, 0x57, 0xdd, 0x3c, 0x25, 0xfe, 0xa3, 0xdc, 0x46, 0x26, 0xfa, 0x38, 0xc4, 0xf4, 0x1b,
+ 0x30, 0xa7, 0x62, 0xf3, 0x94, 0x87, 0xab, 0x0f, 0xe0, 0x62, 0xac, 0xad, 0x32, 0xf0, 0x67, 0x3d,
+ 0xcc, 0x38, 0xba, 0x09, 0x19, 0x76, 0x48, 0x8f, 0x4c, 0x87, 0x58, 0x6d, 0xee, 0xf4, 0xfd, 0xcb,
+ 0xd2, 0xbc, 0x91, 0x16, 0xc4, 0xba, 0xa2, 0xe9, 0x14, 0x2e, 0x0d, 0x31, 0xb3, 0xae, 0x58, 0x1e,
+ 0xed, 0x45, 0x5f, 0x52, 0x1c, 0xb2, 0x4f, 0xd5, 0x11, 0x5e, 0x9d, 0xa0, 0x55, 0x91, 0x02, 0x07,
+ 0xcf, 0x2a, 0x62, 0xa8, 0x9b, 0x70, 0x79, 0xb8, 0xf1, 0x52, 0xfa, 0x0e, 0xdf, 0x0d, 0x13, 0xe7,
+ 0xba, 0x1b, 0xea, 0x36, 0x5c, 0x19, 0x59, 0x40, 0xd9, 0x34, 0x68, 0x12, 0xb5, 0xff, 0xb2, 0x49,
+ 0xd4, 0x7f, 0xa5, 0x45, 0x96, 0x09, 0x72, 0xc7, 0x2b, 0x35, 0x44, 0x5c, 0xb8, 0x46, 0xb3, 0x9e,
+ 0xba, 0x70, 0x0d, 0x67, 0xbc, 0xaf, 0x41, 0x0e, 0x13, 0x3b, 0x86, 0x4c, 0x4a, 0x64, 0x06, 0x13,
+ 0x7b, 0x80, 0xd3, 0x4d, 0x28, 0x8c, 0x6a, 0xad, 0xbc, 0x13, 0xc9, 0x9a, 0xda, 0x79, 0xb3, 0xa6,
+ 0x6e, 0xc3, 0x1b, 0xea, 0x44, 0x0c, 0x1a, 0x56, 0x71, 0x4c, 0x5f, 0xed, 0x1e, 0xff, 0x00, 0xae,
+ 0x9d, 0xbc, 0x8a, 0x32, 0xe5, 0x43, 0x48, 0xca, 0xee, 0x5d, 0x9b, 0xb8, 0x7b, 0x97, 0x7c, 0xfa,
+ 0xe7, 0x49, 0xc8, 0x35, 0xc5, 0x5c, 0xc3, 0xf2, 0x2c, 0x17, 0x73, 0xec, 0x31, 0xf4, 0xf5, 0x68,
+ 0x3d, 0x90, 0x8e, 0xf6, 0xc3, 0x48, 0xd5, 0xa0, 0x70, 0x4e, 0x7a, 0x9b, 0x89, 0xb4, 0xeb, 0x1f,
+ 0x31, 0x73, 0x70, 0x8c, 0x3a, 0x8e, 0xeb, 0x70, 0xd5, 0x2a, 0x5f, 0xf4, 0x67, 0x23, 0xcf, 0x97,
+ 0xae, 0xc3, 0x45, 0x5a, 0x1f, 0x79, 0xc7, 0xf1, 0xb7, 0x7c, 0xf8, 0xa5, 0xe6, 0x63, 0xb8, 0xc6,
+ 0x3a, 0x16, 0x3b, 0x94, 0x8f, 0x17, 0xbe, 0xf3, 0x4d, 0xd7, 0x61, 0x2d, 0x7c, 0x68, 0xf5, 0x1d,
+ 0xea, 0xa9, 0xed, 0x5f, 0x0a, 0x30, 0x6a, 0xa3, 0x1e, 0x0c, 0x10, 0x68, 0x03, 0xae, 0x8e, 0x48,
+ 0xb0, 0xe9, 0x11, 0x11, 0xd9, 0x53, 0x55, 0xfe, 0x2b, 0x43, 0xec, 0x55, 0x35, 0x8d, 0xde, 0x83,
+ 0x02, 0x73, 0x0e, 0x08, 0xb6, 0xfd, 0xec, 0xca, 0xcc, 0x48, 0xf6, 0x9c, 0x95, 0xac, 0x97, 0xfc,
+ 0x79, 0x99, 0x64, 0xd9, 0xf7, 0xc2, 0x4c, 0xba, 0x0e, 0x97, 0x5c, 0x87, 0xb1, 0x01, 0xa3, 0x6b,
+ 0x3d, 0x73, 0xdc, 0x9e, 0x2b, 0xcb, 0x5c, 0xd2, 0xb8, 0xe0, 0x4f, 0xfa, 0x5c, 0x0f, 0xfc, 0x29,
+ 0xb4, 0x0d, 0x17, 0x5c, 0x87, 0x44, 0xfc, 0x28, 0xb7, 0x4d, 0x96, 0xbb, 0x71, 0xc5, 0x78, 0xd1,
+ 0x75, 0x48, 0xf4, 0x08, 0x3f, 0xc5, 0xe8, 0x4d, 0x18, 0xec, 0x95, 0x69, 0xe3, 0x8e, 0x75, 0xac,
+ 0x0a, 0x61, 0x36, 0x24, 0x57, 0x05, 0x55, 0xff, 0xa5, 0x06, 0xd9, 0x2d, 0x4c, 0x30, 0x73, 0x58,
+ 0x85, 0x12, 0x2e, 0x3a, 0xa5, 0x5d, 0x48, 0xcb, 0xb5, 0xcd, 0xae, 0x88, 0x8b, 0x09, 0xd2, 0xc8,
+ 0x50, 0x30, 0x19, 0x0b, 0x2c, 0x24, 0x30, 0x74, 0x1f, 0x20, 0xb4, 0x2d, 0x28, 0x82, 0x13, 0xdd,
+ 0x08, 0x23, 0xec, 0xeb, 0xbf, 0x4d, 0x42, 0xfa, 0x93, 0x1e, 0xf6, 0x8e, 0x9b, 0xd8, 0xeb, 0x3b,
+ 0x6d, 0x8c, 0x3e, 0x1f, 0xb9, 0x76, 0x7f, 0x7b, 0xd2, 0x14, 0xee, 0x1f, 0xde, 0xa5, 0xf7, 0x26,
+ 0xe6, 0xf3, 0x8f, 0xe3, 0xbb, 0x1a, 0xfa, 0x91, 0x36, 0xfa, 0x16, 0xf8, 0x9d, 0xc9, 0xb3, 0xaf,
+ 0x52, 0xe4, 0xfd, 0x73, 0x70, 0xaa, 0xcc, 0xf0, 0x85, 0x06, 0xf9, 0xe1, 0x0c, 0x88, 0x26, 0x91,
+ 0x17, 0xcf, 0xf5, 0x4b, 0x1b, 0xe7, 0x61, 0x55, 0xba, 0xfc, 0x58, 0x0b, 0xdb, 0x87, 0x58, 0x1a,
+ 0x43, 0xdf, 0x1d, 0x2f, 0xf4, 0x25, 0x49, 0x76, 0xe9, 0xc3, 0xf3, 0xb2, 0xfb, 0x7a, 0x95, 0x7f,
+ 0x9f, 0xf8, 0xc3, 0xf3, 0x65, 0xed, 0xab, 0xe7, 0xcb, 0xda, 0xdf, 0x9e, 0x2f, 0x6b, 0x5f, 0xbe,
+ 0x58, 0x9e, 0xfa, 0xea, 0xc5, 0xf2, 0xd4, 0x9f, 0x5f, 0x2c, 0x4f, 0xc1, 0xad, 0x36, 0x75, 0xc7,
+ 0x4a, 0x2f, 0x83, 0x1f, 0xee, 0x1e, 0xe5, 0xb4, 0xa1, 0x3d, 0xde, 0x3d, 0x70, 0xf8, 0x61, 0xaf,
+ 0x25, 0x80, 0xab, 0x6d, 0xca, 0x5c, 0xca, 0x56, 0x3d, 0x71, 0xc0, 0xb0, 0xb7, 0xda, 0x5f, 0x0f,
+ 0x3f, 0xdb, 0x87, 0x96, 0x43, 0xd8, 0xea, 0xb8, 0x1f, 0x25, 0x3f, 0x90, 0x1f, 0xfd, 0xb5, 0x9f,
+ 0x25, 0x92, 0x8d, 0x4a, 0xa5, 0xf9, 0xf3, 0x44, 0xb1, 0x11, 0x68, 0x53, 0x11, 0xda, 0x54, 0x42,
+ 0x6d, 0xa4, 0x0e, 0xa5, 0xbd, 0xb5, 0x3f, 0x0e, 0x20, 0x4f, 0x04, 0xe4, 0x49, 0x08, 0x79, 0x22,
+ 0x21, 0x4f, 0xf6, 0xd6, 0x9e, 0x27, 0x6e, 0x8f, 0x83, 0x3c, 0xd9, 0x6a, 0x94, 0x1f, 0x60, 0x6e,
+ 0x89, 0xf2, 0xf0, 0x8f, 0xc4, 0xad, 0x00, 0xbe, 0xb1, 0x21, 0xf0, 0xe2, 0xaf, 0x62, 0xd8, 0xd8,
+ 0x90, 0x1c, 0x1b, 0x1b, 0x7b, 0x6b, 0xad, 0x59, 0xf9, 0x43, 0xe4, 0x37, 0xfe, 0x13, 0x00, 0x00,
+ 0xff, 0xff, 0xd4, 0x41, 0xd8, 0xcb, 0x6a, 0x1d, 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.v1.QueryService/ValidatorInfo", opts...)
+ if err != nil {
+ return nil, err
}
- 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
+ x := &queryServiceValidatorInfoClient{stream}
+ if err := x.ClientStream.SendMsg(in); err != nil {
+ return nil, err
}
- if m.EpochIndex != 0 {
- i = encodeVarintStake(dAtA, i, uint64(m.EpochIndex))
- i--
- dAtA[i] = 0x10
+ if err := x.ClientStream.CloseSend(); err != nil {
+ return nil, err
}
- if m.ValidatorIdentity != nil {
+ return x, nil
+}
+
+type QueryService_ValidatorInfoClient interface {
+ Recv() (*ValidatorInfoResponse, error)
+ grpc.ClientStream
+}
+
+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
+ }
+ 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.v1.QueryService/ValidatorStatus", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+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.v1.QueryService/ValidatorPenalty", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, 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.v1.QueryService/CurrentValidatorRate", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+// 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.v1.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.v1.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.v1.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.v1.QueryService",
+ HandlerType: (*QueryServiceServer)(nil),
+ Methods: []grpc.MethodDesc{
{
- size, err := m.ValidatorIdentity.MarshalToSizedBuffer(dAtA[:i])
- if err != nil {
- return 0, err
- }
- i -= size
- i = encodeVarintStake(dAtA, i, uint64(size))
- }
+ 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/v1/stake.proto",
+}
+
+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 = encodeVarintStake(dAtA, i, uint64(len(m.Inner)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
-func (m *Undelegate) 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])
@@ -2292,19 +2540,19 @@ func (m *Undelegate) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *Undelegate) MarshalTo(dAtA []byte) (int, error) {
+func (m *Validator) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *Undelegate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Validator) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
- if m.DelegationAmount != nil {
+ if m.GovernanceKey != nil {
{
- size, err := m.DelegationAmount.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.GovernanceKey.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -2312,28 +2560,68 @@ func (m *Undelegate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i = encodeVarintStake(dAtA, i, uint64(size))
}
i--
- dAtA[i] = 0x22
+ dAtA[i] = 0x4a
}
- if m.UnbondedAmount != nil {
- {
- size, err := m.UnbondedAmount.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 m.StartEpochIndex != 0 {
- i = encodeVarintStake(dAtA, i, uint64(m.StartEpochIndex))
+ 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] = 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
}
@@ -2346,7 +2634,7 @@ func (m *Undelegate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
-func (m *UndelegateClaim) 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])
@@ -2356,39 +2644,34 @@ func (m *UndelegateClaim) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *UndelegateClaim) MarshalTo(dAtA []byte) (int, error) {
+func (m *ValidatorList) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *UndelegateClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *ValidatorList) 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
+ 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 *UndelegateClaimBody) 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])
@@ -2398,31 +2681,38 @@ func (m *UndelegateClaimBody) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *UndelegateClaimBody) MarshalTo(dAtA []byte) (int, error) {
+func (m *FundingStream) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *UndelegateClaimBody) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *FundingStream) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
- if m.BalanceCommitment != nil {
+ if m.Recipient != nil {
{
- size, err := m.BalanceCommitment.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.Penalty != 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.Penalty.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.ToAddress.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -2430,16 +2720,20 @@ func (m *UndelegateClaimBody) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i = encodeVarintStake(dAtA, i, uint64(size))
}
i--
- dAtA[i] = 0x1a
- }
- if m.StartEpochIndex != 0 {
- i = encodeVarintStake(dAtA, i, uint64(m.StartEpochIndex))
- 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
}
@@ -2447,12 +2741,11 @@ func (m *UndelegateClaimBody) 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 *UndelegateClaimPlan) 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])
@@ -2462,40 +2755,82 @@ func (m *UndelegateClaimPlan) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *UndelegateClaimPlan) MarshalTo(dAtA []byte) (int, error) {
+func (m *FundingStream_ToAddress) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *UndelegateClaimPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *FundingStream_ToAddress) 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.RateBps != 0 {
+ i = encodeVarintStake(dAtA, i, uint64(m.RateBps))
i--
- dAtA[i] = 0x42
+ dAtA[i] = 0x10
}
- if len(m.ProofBlindingR) > 0 {
- i -= len(m.ProofBlindingR)
- copy(dAtA[i:], m.ProofBlindingR)
- i = encodeVarintStake(dAtA, i, uint64(len(m.ProofBlindingR)))
+ 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] = 0x3a
+ dAtA[i] = 0xa
}
- if len(m.BalanceBlinding) > 0 {
- i -= len(m.BalanceBlinding)
- copy(dAtA[i:], m.BalanceBlinding)
- i = encodeVarintStake(dAtA, i, uint64(len(m.BalanceBlinding)))
+ return len(dAtA) - i, nil
+}
+
+func (m *FundingStream_ToCommunityPool) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], 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)
+ _ = i
+ var l int
+ _ = l
+ if m.RateBps != 0 {
+ i = encodeVarintStake(dAtA, i, uint64(m.RateBps))
i--
- dAtA[i] = 0x32
+ dAtA[i] = 0x10
}
- if m.UnbondingAmount != nil {
+ return len(dAtA) - i, nil
+}
+
+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
+ }
+ return dAtA[:n], nil
+}
+
+func (m *RateData) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *RateData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.ValidatorExchangeRate != nil {
{
- size, err := m.UnbondingAmount.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.ValidatorExchangeRate.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -2505,9 +2840,9 @@ func (m *UndelegateClaimPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x2a
}
- if m.Penalty != nil {
+ if m.ValidatorRewardRate != nil {
{
- size, err := m.Penalty.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.ValidatorRewardRate.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -2517,14 +2852,14 @@ func (m *UndelegateClaimPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x22
}
- 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
}
@@ -2537,7 +2872,7 @@ func (m *UndelegateClaimPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
-func (m *DelegationChanges) 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])
@@ -2547,48 +2882,49 @@ func (m *DelegationChanges) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *DelegationChanges) MarshalTo(dAtA []byte) (int, error) {
+func (m *BaseRateData) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *DelegationChanges) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *BaseRateData) 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))
+ if m.BaseExchangeRate != nil {
+ {
+ size, err := m.BaseExchangeRate.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
}
- i--
- dAtA[i] = 0x12
+ i -= size
+ i = encodeVarintStake(dAtA, i, uint64(size))
}
+ i--
+ dAtA[i] = 0x1a
}
- 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))
+ if m.BaseRewardRate != nil {
+ {
+ size, err := m.BaseRewardRate.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
}
- i--
- dAtA[i] = 0xa
+ i -= size
+ i = encodeVarintStake(dAtA, i, uint64(size))
}
+ i--
+ dAtA[i] = 0x12
+ }
+ if m.EpochIndex != 0 {
+ i = encodeVarintStake(dAtA, i, uint64(m.EpochIndex))
+ i--
+ dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
-func (m *Uptime) Marshal() (dAtA []byte, err error) {
+func (m *ValidatorStatus) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -2598,37 +2934,68 @@ func (m *Uptime) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *Uptime) MarshalTo(dAtA []byte) (int, error) {
+func (m *ValidatorStatus) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *Uptime) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *ValidatorStatus) 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)))
+ 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
+ }
+ if m.VotingPower != nil {
+ {
+ size, err := m.VotingPower.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintStake(dAtA, i, uint64(size))
+ }
i--
dAtA[i] = 0x1a
}
- if m.WindowLen != 0 {
- i = encodeVarintStake(dAtA, i, uint64(m.WindowLen))
+ 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))
+ }
i--
- dAtA[i] = 0x10
+ dAtA[i] = 0x12
}
- if m.AsOfBlockHeight != 0 {
- i = encodeVarintStake(dAtA, i, uint64(m.AsOfBlockHeight))
+ 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] = 0x8
+ dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
-func (m *CurrentConsensusKeys) 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])
@@ -2638,34 +3005,35 @@ func (m *CurrentConsensusKeys) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *CurrentConsensusKeys) MarshalTo(dAtA []byte) (int, error) {
+func (m *BondingState) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *CurrentConsensusKeys) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *BondingState) 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
- }
+ if m.UnbondsAtHeight != 0 {
+ i = encodeVarintStake(dAtA, i, uint64(m.UnbondsAtHeight))
+ i--
+ dAtA[i] = 0x18
+ }
+ if m.UnbondsAtEpoch != 0 {
+ i = encodeVarintStake(dAtA, i, uint64(m.UnbondsAtEpoch))
+ i--
+ dAtA[i] = 0x10
+ }
+ if m.State != 0 {
+ i = encodeVarintStake(dAtA, i, uint64(m.State))
+ i--
+ dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
-func (m *Penalty) 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])
@@ -2675,496 +3043,2479 @@ func (m *Penalty) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *Penalty) MarshalTo(dAtA []byte) (int, error) {
+func (m *ValidatorState) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *Penalty) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *ValidatorState) 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 m.State != 0 {
+ i = encodeVarintStake(dAtA, i, uint64(m.State))
i--
dAtA[i] = 0x8
}
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 *ValidatorInfo) 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 *ValidatorInfo) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ValidatorInfo) 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))
- }
- 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.RateData != nil {
+ {
+ size, err := m.RateData.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.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.GovernanceKey != nil {
- l = m.GovernanceKey.Size()
- n += 1 + l + sovStake(uint64(l))
+ 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 n
+ return len(dAtA) - i, nil
}
-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))
- }
+func (m *ValidatorDefinition) Marshal() (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) Size() (n int) {
- if m == nil {
- return 0
- }
- var l int
- _ = l
- if m.Recipient != nil {
- n += m.Recipient.Size()
- }
- return n
+func (m *ValidatorDefinition) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *FundingStream_ToAddress_) Size() (n int) {
- if m == nil {
- return 0
- }
+func (m *ValidatorDefinition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
var l int
_ = l
- if m.ToAddress != nil {
- l = m.ToAddress.Size()
- n += 1 + l + sovStake(uint64(l))
- }
- return n
-}
-func (m *FundingStream_ToDao_) Size() (n int) {
- if m == nil {
- return 0
+ 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
}
- var l int
- _ = l
- if m.ToDao != nil {
- l = m.ToDao.Size()
- n += 1 + l + sovStake(uint64(l))
+ 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 n
+ return len(dAtA) - i, nil
}
-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))
+
+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
}
- return n
+ return dAtA[:n], 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))
- }
- return n
+func (m *Delegate) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *RateData) Size() (n int) {
- if m == nil {
- return 0
- }
+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.EpochIndex != 0 {
- n += 1 + sovStake(uint64(m.EpochIndex))
+ 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.ValidatorRewardRate != 0 {
- n += 1 + sovStake(uint64(m.ValidatorRewardRate))
+ 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.ValidatorExchangeRate != 0 {
- n += 1 + sovStake(uint64(m.ValidatorExchangeRate))
+ if m.EpochIndex != 0 {
+ i = encodeVarintStake(dAtA, i, uint64(m.EpochIndex))
+ i--
+ dAtA[i] = 0x10
}
- return n
+ 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 len(dAtA) - i, nil
}
-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))
+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 *ValidatorStatus) Size() (n int) {
- if m == nil {
- return 0
- }
+func (m *Undelegate) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Undelegate) 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.FromEpoch != nil {
+ {
+ size, err := m.FromEpoch.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintStake(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x2a
}
- if m.State != nil {
- l = m.State.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
}
- if m.VotingPower != 0 {
- n += 1 + sovStake(uint64(m.VotingPower))
+ 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.BondingState != nil {
- l = m.BondingState.Size()
- n += 1 + l + sovStake(uint64(l))
+ if m.StartEpochIndex != 0 {
+ i = encodeVarintStake(dAtA, i, uint64(m.StartEpochIndex))
+ i--
+ dAtA[i] = 0x10
}
- return n
+ 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 len(dAtA) - i, nil
}
-func (m *BondingState) Size() (n int) {
- if m == nil {
- return 0
+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 dAtA[:n], nil
+}
+
+func (m *UndelegateClaim) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *UndelegateClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
var l int
_ = l
- if m.State != 0 {
- n += 1 + sovStake(uint64(m.State))
+ 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.XUnbondingEpoch != nil {
- n += m.XUnbondingEpoch.Size()
+ 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 *BondingState_UnbondingEpoch) Size() (n int) {
- if m == nil {
- return 0
+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
}
- var l int
- _ = l
- n += 1 + sovStake(uint64(m.UnbondingEpoch))
- return n
+ return dAtA[:n], nil
}
-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 *UndelegateClaimBody) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *ValidatorInfo) 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.Validator != nil {
- l = m.Validator.Size()
- n += 1 + l + sovStake(uint64(l))
+ if m.UnbondingStartHeight != 0 {
+ i = encodeVarintStake(dAtA, i, uint64(m.UnbondingStartHeight))
+ i--
+ dAtA[i] = 0x28
}
- if m.Status != nil {
- l = m.Status.Size()
- n += 1 + l + sovStake(uint64(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))
+ }
+ i--
+ dAtA[i] = 0x22
}
- if m.RateData != nil {
- l = m.RateData.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
}
- return n
+ if m.StartEpochIndex != 0 {
+ i = encodeVarintStake(dAtA, i, uint64(m.StartEpochIndex))
+ 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))
+ }
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
}
-func (m *ValidatorDefinition) Size() (n int) {
- if m == nil {
- return 0
+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 dAtA[:n], nil
+}
+
+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.Validator != nil {
- l = m.Validator.Size()
- n += 1 + l + sovStake(uint64(l))
+ if m.UnbondingStartHeight != 0 {
+ i = encodeVarintStake(dAtA, i, uint64(m.UnbondingStartHeight))
+ i--
+ dAtA[i] = 0x48
}
- l = len(m.AuthSig)
- if l > 0 {
- n += 1 + l + sovStake(uint64(l))
+ 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
}
- return n
-}
-
-func (m *Delegate) Size() (n int) {
- if m == nil {
- return 0
+ 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
}
- var l int
- _ = l
- if m.ValidatorIdentity != nil {
- l = m.ValidatorIdentity.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
}
- if m.EpochIndex != 0 {
- n += 1 + sovStake(uint64(m.EpochIndex))
+ 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
}
- if m.UnbondedAmount != nil {
- l = m.UnbondedAmount.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.DelegationAmount != nil {
- l = m.DelegationAmount.Size()
- n += 1 + l + sovStake(uint64(l))
+ if m.StartEpochIndex != 0 {
+ i = encodeVarintStake(dAtA, i, uint64(m.StartEpochIndex))
+ i--
+ dAtA[i] = 0x10
}
- return n
+ 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 len(dAtA) - i, nil
}
-func (m *Undelegate) Size() (n int) {
- if m == nil {
- return 0
+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 dAtA[:n], nil
+}
+
+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 m.UnbondedAmount != nil {
- l = m.UnbondedAmount.Size()
- n += 1 + l + sovStake(uint64(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.DelegationAmount != nil {
- l = m.DelegationAmount.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 *UndelegateClaim) 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.Body != nil {
- l = m.Body.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
}
- l = len(m.Proof)
- if l > 0 {
- n += 1 + l + sovStake(uint64(l))
+ if m.WindowLen != 0 {
+ i = encodeVarintStake(dAtA, i, uint64(m.WindowLen))
+ i--
+ dAtA[i] = 0x10
}
- return n
+ if m.AsOfBlockHeight != 0 {
+ i = encodeVarintStake(dAtA, i, uint64(m.AsOfBlockHeight))
+ i--
+ dAtA[i] = 0x8
+ }
+ return len(dAtA) - i, nil
}
-func (m *UndelegateClaimBody) Size() (n int) {
- if m == nil {
- return 0
+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
}
+ 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 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))
+ 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
+ }
}
- return n
+ return len(dAtA) - i, nil
}
-func (m *UndelegateClaimPlan) Size() (n int) {
- if m == nil {
- return 0
+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
}
+ 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 m.ValidatorIdentity != nil {
- l = m.ValidatorIdentity.Size()
- n += 1 + l + sovStake(uint64(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
}
- 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))
+ return len(dAtA) - i, nil
+}
+
+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
}
- l = len(m.BalanceBlinding)
- if l > 0 {
- n += 1 + l + sovStake(uint64(l))
+ 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 m.ShowInactive {
+ i--
+ if m.ShowInactive {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
+ }
+ i--
+ dAtA[i] = 0x10
}
- l = len(m.ProofBlindingR)
- if l > 0 {
- n += 1 + l + sovStake(uint64(l))
+ return len(dAtA) - i, nil
+}
+
+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
}
- l = len(m.ProofBlindingS)
- if l > 0 {
- n += 1 + l + sovStake(uint64(l))
+ 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.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 *DelegationChanges) 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.Delegations) > 0 {
- for _, e := range m.Delegations {
- 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
}
- if len(m.Undelegations) > 0 {
- for _, e := range m.Undelegations {
- l = e.Size()
- n += 1 + l + sovStake(uint64(l))
+ return len(dAtA) - i, nil
+}
+
+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
+ }
+ 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 n
+ return len(dAtA) - i, nil
}
-func (m *Uptime) Size() (n int) {
- if m == nil {
- return 0
+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.AsOfBlockHeight != 0 {
- n += 1 + sovStake(uint64(m.AsOfBlockHeight))
+ if m.EndEpochIndex != 0 {
+ i = encodeVarintStake(dAtA, i, uint64(m.EndEpochIndex))
+ i--
+ dAtA[i] = 0x20
}
- if m.WindowLen != 0 {
- n += 1 + sovStake(uint64(m.WindowLen))
+ if m.StartEpochIndex != 0 {
+ i = encodeVarintStake(dAtA, i, uint64(m.StartEpochIndex))
+ i--
+ dAtA[i] = 0x18
}
- l = len(m.Bitvec)
- if l > 0 {
- 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
+ return len(dAtA) - i, nil
}
-func (m *CurrentConsensusKeys) Size() (n int) {
- if m == nil {
- return 0
+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 len(m.ConsensusKeys) > 0 {
- for _, e := range m.ConsensusKeys {
- l = e.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] = 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
+ }
+ 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.UnbondingDelay != 0 {
+ i = encodeVarintStake(dAtA, i, uint64(m.UnbondingDelay))
+ i--
+ dAtA[i] = 0x48
+ }
+ if m.MinValidatorStake != nil {
+ {
+ size, err := m.MinValidatorStake.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintStake(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x42
+ }
+ 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 != nil {
+ l = m.ValidatorRewardRate.Size()
+ n += 1 + l + sovStake(uint64(l))
+ }
+ if m.ValidatorExchangeRate != nil {
+ l = m.ValidatorExchangeRate.Size()
+ n += 1 + l + sovStake(uint64(l))
+ }
+ 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 != nil {
+ l = m.BaseRewardRate.Size()
+ n += 1 + l + sovStake(uint64(l))
+ }
+ if m.BaseExchangeRate != nil {
+ l = m.BaseExchangeRate.Size()
+ n += 1 + l + sovStake(uint64(l))
+ }
+ 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 != nil {
+ l = m.VotingPower.Size()
+ n += 1 + l + sovStake(uint64(l))
+ }
+ 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.UnbondsAtEpoch != 0 {
+ n += 1 + sovStake(uint64(m.UnbondsAtEpoch))
+ }
+ if m.UnbondsAtHeight != 0 {
+ n += 1 + sovStake(uint64(m.UnbondsAtHeight))
+ }
+ 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))
+ }
+ if m.FromEpoch != nil {
+ l = m.FromEpoch.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))
+ }
+ if m.UnbondingStartHeight != 0 {
+ n += 1 + sovStake(uint64(m.UnbondingStartHeight))
+ }
+ 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))
+ }
+ if m.UnbondingStartHeight != 0 {
+ n += 1 + sovStake(uint64(m.UnbondingStartHeight))
+ }
+ 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
+ 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
+ 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
+ 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
+ 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))
+ }
+ if m.MinValidatorStake != nil {
+ l = m.MinValidatorStake.Size()
+ n += 1 + l + sovStake(uint64(l))
+ }
+ if m.UnbondingDelay != 0 {
+ n += 1 + sovStake(uint64(m.UnbondingDelay))
+ }
+ 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 = &v1.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 = &v1.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, &v1.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 (m *Penalty) Size() (n int) {
- if m == nil {
- return 0
- }
- var l int
- _ = l
- if m.Inner != 0 {
- n += 1 + sovStake(uint64(m.Inner))
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
}
- 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))))
+ 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 +5538,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:
@@ -3223,17 +5574,36 @@ func (m *Validator) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.IdentityKey == nil {
- m.IdentityKey = &v1alpha1.IdentityKey{}
+ m.IdentityKey = &v1.IdentityKey{}
}
if err := m.IdentityKey.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)
+ }
+ 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 4:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field ConsensusKey", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field ValidatorRewardRate", wireType)
}
- var byteLen int
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowStake
@@ -3243,31 +5613,260 @@ func (m *Validator) 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
+ }
+ if m.ValidatorRewardRate == nil {
+ m.ValidatorRewardRate = &v11.Amount{}
+ }
+ if err := m.ValidatorRewardRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ValidatorExchangeRate", 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.ValidatorExchangeRate == nil {
+ m.ValidatorExchangeRate = &v11.Amount{}
+ }
+ if err := m.ValidatorExchangeRate.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 *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 != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field BaseRewardRate", 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.BaseRewardRate == nil {
+ m.BaseRewardRate = &v11.Amount{}
+ }
+ if err := m.BaseRewardRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field BaseExchangeRate", 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 {
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.BaseExchangeRate == nil {
+ m.BaseExchangeRate = &v11.Amount{}
+ }
+ if err := m.BaseExchangeRate.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 *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
}
- m.ConsensusKey = append(m.ConsensusKey[:0], dAtA[iNdEx:postIndex]...)
- if m.ConsensusKey == nil {
- m.ConsensusKey = []byte{}
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
}
- iNdEx = postIndex
- case 3:
+ }
+ 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 +5876,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 = &v1.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 +5912,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:
+ case 3:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field VotingPower", wireType)
}
- var stringLen uint64
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowStake
@@ -3341,27 +5948,31 @@ 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.Description = string(dAtA[iNdEx:postIndex])
+ if m.VotingPower == nil {
+ m.VotingPower = &v11.Amount{}
+ }
+ if err := m.VotingPower.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
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 +5999,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 +6070,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 UnbondsAtEpoch", wireType)
}
- var v int
+ m.UnbondsAtEpoch = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowStake
@@ -3426,17 +6089,16 @@ func (m *Validator) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- v |= int(b&0x7F) << shift
+ m.UnbondsAtEpoch |= 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)
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field UnbondsAtHeight", wireType)
}
- var msglen int
+ m.UnbondsAtHeight = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowStake
@@ -3446,28 +6108,11 @@ func (m *Validator) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- msglen |= int(b&0x7F) << shift
+ m.UnbondsAtHeight |= uint64(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 +6134,7 @@ func (m *Validator) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *ValidatorList) Unmarshal(dAtA []byte) error {
+func (m *ValidatorState) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -3512,17 +6157,17 @@ func (m *ValidatorList) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: ValidatorList: wiretype end group for non-group")
+ return fmt.Errorf("proto: ValidatorState: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: ValidatorList: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: ValidatorState: 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)
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
}
- var msglen int
+ m.State = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowStake
@@ -3532,26 +6177,11 @@ func (m *ValidatorList) 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
- }
- 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:])
@@ -3573,7 +6203,7 @@ func (m *ValidatorList) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *FundingStream) Unmarshal(dAtA []byte) error {
+func (m *ValidatorInfo) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -3596,15 +6226,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: ValidatorInfo: 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: 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 ToAddress", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -3631,15 +6261,52 @@ 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
+ }
+ 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
+ }
+ if m.Status == nil {
+ m.Status = &ValidatorStatus{}
+ }
+ if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.Recipient = &FundingStream_ToAddress_{v}
iNdEx = postIndex
- case 2:
+ case 3:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field ToDao", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field RateData", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -3666,11 +6333,12 @@ func (m *FundingStream) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &FundingStream_ToDao{}
- if err := v.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
}
- m.Recipient = &FundingStream_ToDao_{v}
iNdEx = postIndex
default:
iNdEx = preIndex
@@ -3693,7 +6361,7 @@ func (m *FundingStream) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *FundingStream_ToAddress) Unmarshal(dAtA []byte) error {
+func (m *ValidatorDefinition) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -3716,17 +6384,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: ValidatorDefinition: 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: 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 Address", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType)
}
- var stringLen uint64
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowStake
@@ -3736,29 +6404,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.Validator == nil {
+ m.Validator = &Validator{}
+ }
+ if err := m.Validator.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)
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field AuthSig", wireType)
}
- m.RateBps = 0
+ var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowStake
@@ -3768,80 +6440,26 @@ func (m *FundingStream_ToAddress) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- m.RateBps |= uint32(b&0x7F) << shift
+ byteLen |= int(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 {
+ if byteLen < 0 {
return ErrInvalidLengthStake
}
- if (iNdEx + skippy) > l {
- return io.ErrUnexpectedEOF
- }
- 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 + byteLen
+ 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
- }
- }
- 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)
- }
- 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
- }
+ m.AuthSig = append(m.AuthSig[:0], dAtA[iNdEx:postIndex]...)
+ if m.AuthSig == nil {
+ m.AuthSig = []byte{}
}
+ iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipStake(dAtA[iNdEx:])
@@ -3863,7 +6481,7 @@ func (m *FundingStream_ToDao) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *RateData) Unmarshal(dAtA []byte) error {
+func (m *Delegate) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -3886,15 +6504,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: Delegate: 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: 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 IdentityKey", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIdentity", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -3921,10 +6539,10 @@ 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 = &v1.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
@@ -3947,30 +6565,11 @@ func (m *RateData) Unmarshal(dAtA []byte) error {
break
}
}
- case 4:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field ValidatorRewardRate", wireType)
- }
- 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)
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field UnbondedAmount", wireType)
}
- m.ValidatorExchangeRate = 0
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowStake
@@ -3980,66 +6579,33 @@ func (m *RateData) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- m.ValidatorExchangeRate |= uint64(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 *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
+ if m.UnbondedAmount == nil {
+ m.UnbondedAmount = &v11.Amount{}
}
- b := dAtA[iNdEx]
- iNdEx++
- wire |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
+ if err := m.UnbondedAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
}
- }
- 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)
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DelegationAmount", wireType)
}
- m.EpochIndex = 0
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowStake
@@ -4049,49 +6615,28 @@ 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
}
}
- case 2:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field BaseRewardRate", wireType)
+ if msglen < 0 {
+ return ErrInvalidLengthStake
}
- 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
- }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthStake
}
- case 3:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field BaseExchangeRate", wireType)
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
}
- 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
- }
+ if m.DelegationAmount == nil {
+ m.DelegationAmount = &v11.Amount{}
+ }
+ if err := m.DelegationAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
}
+ iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipStake(dAtA[iNdEx:])
@@ -4113,7 +6658,7 @@ func (m *BaseRateData) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *ValidatorStatus) Unmarshal(dAtA []byte) error {
+func (m *Undelegate) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -4136,15 +6681,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: Undelegate: 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: 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 {
@@ -4171,16 +6716,35 @@ 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 = &v1.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 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 State", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field UnbondedAmount", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -4207,18 +6771,18 @@ func (m *ValidatorStatus) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.State == nil {
- m.State = &ValidatorState{}
+ if m.UnbondedAmount == nil {
+ m.UnbondedAmount = &v11.Amount{}
}
- if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.UnbondedAmount.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)
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DelegationAmount", wireType)
}
- m.VotingPower = 0
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowStake
@@ -4228,14 +6792,31 @@ func (m *ValidatorStatus) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- m.VotingPower |= uint64(b&0x7F) << shift
+ msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
- case 4:
+ 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 = &v11.Amount{}
+ }
+ if err := m.DelegationAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 5:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field BondingState", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field FromEpoch", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -4262,10 +6843,10 @@ func (m *ValidatorStatus) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.BondingState == nil {
- m.BondingState = &BondingState{}
+ if m.FromEpoch == nil {
+ m.FromEpoch = &v12.Epoch{}
}
- if err := m.BondingState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.FromEpoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@@ -4290,7 +6871,7 @@ func (m *ValidatorStatus) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *BondingState) Unmarshal(dAtA []byte) error {
+func (m *UndelegateClaim) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -4313,17 +6894,17 @@ func (m *BondingState) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: BondingState: wiretype end group for non-group")
+ return fmt.Errorf("proto: UndelegateClaim: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: BondingState: 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 State", wireType)
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
}
- m.State = 0
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowStake
@@ -4333,16 +6914,33 @@ 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
}
}
+ 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 UnbondingEpoch", wireType)
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
}
- var v uint64
+ var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowStake
@@ -4352,12 +6950,26 @@ func (m *BondingState) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- v |= uint64(b&0x7F) << shift
+ byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
- m.XUnbondingEpoch = &BondingState_UnbondingEpoch{v}
+ 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:])
@@ -4379,7 +6991,7 @@ func (m *BondingState) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *ValidatorState) Unmarshal(dAtA []byte) error {
+func (m *UndelegateClaimBody) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -4392,27 +7004,154 @@ func (m *ValidatorState) Unmarshal(dAtA []byte) error {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
- b := dAtA[iNdEx]
- iNdEx++
- wire |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: UndelegateClaimBody: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ 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 ValidatorIdentity", 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.ValidatorIdentity == nil {
+ m.ValidatorIdentity = &v1.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 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)
+ }
+ 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.Penalty == nil {
+ m.Penalty = &Penalty{}
+ }
+ if err := m.Penalty.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ 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 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.BalanceCommitment == nil {
+ m.BalanceCommitment = &v13.BalanceCommitment{}
+ }
+ if err := m.BalanceCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
}
- }
- 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:
+ iNdEx = postIndex
+ case 5:
if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field UnbondingStartHeight", wireType)
}
- m.State = 0
+ m.UnbondingStartHeight = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowStake
@@ -4422,7 +7161,7 @@ func (m *ValidatorState) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- m.State |= ValidatorState_ValidatorStateEnum(b&0x7F) << shift
+ m.UnbondingStartHeight |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
@@ -4448,7 +7187,7 @@ func (m *ValidatorState) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *ValidatorInfo) Unmarshal(dAtA []byte) error {
+func (m *UndelegateClaimPlan) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -4471,15 +7210,15 @@ func (m *ValidatorInfo) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: ValidatorInfo: wiretype end group for non-group")
+ return fmt.Errorf("proto: UndelegateClaimPlan: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: ValidatorInfo: 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 != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIdentity", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -4506,16 +7245,35 @@ func (m *ValidatorInfo) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Validator == nil {
- m.Validator = &Validator{}
+ if m.ValidatorIdentity == nil {
+ m.ValidatorIdentity = &v1.IdentityKey{}
}
- if err := m.Validator.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 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 4:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Penalty", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -4542,16 +7300,16 @@ func (m *ValidatorInfo) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Status == nil {
- m.Status = &ValidatorStatus{}
+ if m.Penalty == nil {
+ m.Penalty = &Penalty{}
}
- if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.Penalty.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
- case 3:
+ case 5:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field RateData", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field UnbondingAmount", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -4578,68 +7336,52 @@ func (m *ValidatorInfo) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.RateData == nil {
- m.RateData = &RateData{}
+ if m.UnbondingAmount == nil {
+ m.UnbondingAmount = &v11.Amount{}
}
- if err := m.RateData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.UnbondingAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
- default:
- iNdEx = preIndex
- skippy, err := skipStake(dAtA[iNdEx:])
- if err != nil {
- return err
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field BalanceBlinding", wireType)
}
- if (skippy < 0) || (iNdEx+skippy) < 0 {
- return ErrInvalidLengthStake
+ 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 (iNdEx + skippy) > l {
- return io.ErrUnexpectedEOF
+ if byteLen < 0 {
+ return ErrInvalidLengthStake
}
- iNdEx += skippy
- }
- }
-
- if iNdEx > l {
- return io.ErrUnexpectedEOF
- }
- return nil
-}
-func (m *ValidatorDefinition) Unmarshal(dAtA []byte) 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 + byteLen
+ 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
+ m.BalanceBlinding = append(m.BalanceBlinding[:0], dAtA[iNdEx:postIndex]...)
+ if m.BalanceBlinding == nil {
+ m.BalanceBlinding = []byte{}
}
- }
- fieldNum := int32(wire >> 3)
- wireType := int(wire & 0x7)
- if wireType == 4 {
- return fmt.Errorf("proto: ValidatorDefinition: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: ValidatorDefinition: illegal tag %d (wire type %d)", fieldNum, wire)
- }
- switch fieldNum {
- case 1:
+ iNdEx = postIndex
+ case 7:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingR", wireType)
}
- var msglen int
+ var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowStake
@@ -4649,31 +7391,29 @@ func (m *ValidatorDefinition) 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.Validator == nil {
- m.Validator = &Validator{}
- }
- if err := m.Validator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
+ m.ProofBlindingR = append(m.ProofBlindingR[:0], dAtA[iNdEx:postIndex]...)
+ if m.ProofBlindingR == nil {
+ m.ProofBlindingR = []byte{}
}
iNdEx = postIndex
- case 2:
+ case 8:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field AuthSig", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingS", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
@@ -4700,11 +7440,30 @@ func (m *ValidatorDefinition) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- m.AuthSig = append(m.AuthSig[:0], dAtA[iNdEx:postIndex]...)
- if m.AuthSig == nil {
- m.AuthSig = []byte{}
+ m.ProofBlindingS = append(m.ProofBlindingS[:0], dAtA[iNdEx:postIndex]...)
+ if m.ProofBlindingS == nil {
+ m.ProofBlindingS = []byte{}
}
iNdEx = postIndex
+ case 9:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field UnbondingStartHeight", wireType)
+ }
+ m.UnbondingStartHeight = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowStake
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.UnbondingStartHeight |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
default:
iNdEx = preIndex
skippy, err := skipStake(dAtA[iNdEx:])
@@ -4726,7 +7485,7 @@ func (m *ValidatorDefinition) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *Delegate) Unmarshal(dAtA []byte) error {
+func (m *DelegationChanges) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -4749,70 +7508,15 @@ 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: DelegationChanges: 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: 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 ValidatorIdentity", 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.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 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 3:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field UnbondedAmount", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Delegations", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -4839,16 +7543,14 @@ func (m *Delegate) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.UnbondedAmount == nil {
- m.UnbondedAmount = &v1alpha1.Amount{}
- }
- if err := m.UnbondedAmount.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 4:
+ case 2:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field DelegationAmount", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Undelegations", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -4875,10 +7577,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.Undelegations = append(m.Undelegations, &Undelegate{})
+ if err := m.Undelegations[len(m.Undelegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@@ -4903,7 +7603,7 @@ func (m *Delegate) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *Undelegate) Unmarshal(dAtA []byte) error {
+func (m *Uptime) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -4926,17 +7626,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: Uptime: 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: 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
@@ -4946,33 +7646,16 @@ func (m *Undelegate) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- msglen |= int(b&0x7F) << shift
+ m.AsOfBlockHeight |= uint64(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 = postIndex
case 2:
if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field StartEpochIndex", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field WindowLen", wireType)
}
- m.StartEpochIndex = 0
+ m.WindowLen = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowStake
@@ -4982,16 +7665,16 @@ func (m *Undelegate) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- m.StartEpochIndex |= 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
@@ -5001,31 +7684,79 @@ 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.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 {
@@ -5052,10 +7783,8 @@ func (m *Undelegate) 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, &v1.ConsensusKey{})
+ if err := m.ConsensusKeys[len(m.ConsensusKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@@ -5080,7 +7809,7 @@ func (m *Undelegate) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *UndelegateClaim) Unmarshal(dAtA []byte) error {
+func (m *Penalty) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -5103,17 +7832,17 @@ 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: Penalty: 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: 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 Body", 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
@@ -5123,33 +7852,81 @@ func (m *UndelegateClaim) 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.Body == nil {
- m.Body = &UndelegateClaimBody{}
+ m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...)
+ if m.Inner == nil {
+ m.Inner = []byte{}
}
- if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipStake(dAtA[iNdEx:])
+ if err != nil {
return err
}
- iNdEx = postIndex
+ 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 *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 2:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ShowInactive", wireType)
}
- var byteLen int
+ var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowStake
@@ -5159,26 +7936,12 @@ func (m *UndelegateClaim) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- byteLen |= int(b&0x7F) << shift
+ v |= 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
+ m.ShowInactive = bool(v != 0)
default:
iNdEx = preIndex
skippy, err := skipStake(dAtA[iNdEx:])
@@ -5200,7 +7963,7 @@ func (m *UndelegateClaim) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *UndelegateClaimBody) Unmarshal(dAtA []byte) error {
+func (m *ValidatorInfoResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -5223,15 +7986,15 @@ 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: ValidatorInfoResponse: 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: 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 ValidatorIdentity", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field ValidatorInfo", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -5258,35 +8021,66 @@ func (m *UndelegateClaimBody) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.ValidatorIdentity == nil {
- m.ValidatorIdentity = &v1alpha1.IdentityKey{}
+ if m.ValidatorInfo == nil {
+ m.ValidatorInfo = &ValidatorInfo{}
}
- if err := m.ValidatorIdentity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.ValidatorInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
- case 2:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field StartEpochIndex", wireType)
+ default:
+ iNdEx = preIndex
+ skippy, err := skipStake(dAtA[iNdEx:])
+ if err != nil {
+ return err
}
- 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 (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 *ValidatorStatusRequest) Unmarshal(dAtA []byte) 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
}
- case 3:
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: ValidatorStatusRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ValidatorStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 2:
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 +8107,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 = &v1.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 +8193,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 +8221,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 +8244,15 @@ 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:
+ case 2:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIdentity", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -5435,14 +8279,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 = &v1.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 +8306,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 +8319,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,86 +8403,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 = 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
+ 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 postIndex > l {
+ if iNdEx >= l {
return io.ErrUnexpectedEOF
}
- m.ProofBlindingR = append(m.ProofBlindingR[:0], dAtA[iNdEx:postIndex]...)
- if m.ProofBlindingR == nil {
- m.ProofBlindingR = []byte{}
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
}
- iNdEx = postIndex
- case 8:
+ }
+ 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 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 +8474,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 = &v1.IdentityKey{}
+ }
+ if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
}
iNdEx = postIndex
default:
@@ -5656,7 +8517,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 +8540,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 +8575,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 +8603,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 +8626,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 +8646,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 +8665,111 @@ 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 != 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
+ }
+ }
+ case 4:
+ 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 ErrIntOverflowStake
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.SlashingPenaltyMisbehavior |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 5:
+ 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 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
+ }
+ }
+ case 8:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Bitvec", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field MinValidatorStake", wireType)
}
- var byteLen int
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowStake
@@ -5855,26 +8779,47 @@ func (m *Uptime) 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.Bitvec = append(m.Bitvec[:0], dAtA[iNdEx:postIndex]...)
- if m.Bitvec == nil {
- m.Bitvec = []byte{}
+ if m.MinValidatorStake == nil {
+ m.MinValidatorStake = &v11.Amount{}
+ }
+ if err := m.MinValidatorStake.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
}
iNdEx = postIndex
+ case 9:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field UnbondingDelay", wireType)
+ }
+ m.UnbondingDelay = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowStake
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.UnbondingDelay |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
default:
iNdEx = preIndex
skippy, err := skipStake(dAtA[iNdEx:])
@@ -5896,7 +8841,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 +8864,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 +8899,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 +8920,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/v1/keys.pb.go b/relayer/chains/penumbra/core/keys/v1/keys.pb.go
new file mode 100644
index 000000000..9f539fcc5
--- /dev/null
+++ b/relayer/chains/penumbra/core/keys/v1/keys.pb.go
@@ -0,0 +1,2787 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: penumbra/core/keys/v1/keys.proto
+
+package keysv1
+
+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_171d3f5d66e6613e, []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_Decoded_
+ // *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_171d3f5d66e6613e, []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_Decoded_ struct {
+ Decoded *AddressView_Decoded `protobuf:"bytes,1,opt,name=decoded,proto3,oneof" json:"decoded,omitempty"`
+}
+type AddressView_Opaque_ struct {
+ Opaque *AddressView_Opaque `protobuf:"bytes,2,opt,name=opaque,proto3,oneof" json:"opaque,omitempty"`
+}
+
+func (*AddressView_Decoded_) isAddressView_AddressView() {}
+func (*AddressView_Opaque_) isAddressView_AddressView() {}
+
+func (m *AddressView) GetAddressView() isAddressView_AddressView {
+ if m != nil {
+ return m.AddressView
+ }
+ return nil
+}
+
+func (m *AddressView) GetDecoded() *AddressView_Decoded {
+ if x, ok := m.GetAddressView().(*AddressView_Decoded_); ok {
+ return x.Decoded
+ }
+ 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_Decoded_)(nil),
+ (*AddressView_Opaque_)(nil),
+ }
+}
+
+// A decoded address, with information about the address index and wallet ID visible.
+type AddressView_Decoded 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_Decoded) Reset() { *m = AddressView_Decoded{} }
+func (m *AddressView_Decoded) String() string { return proto.CompactTextString(m) }
+func (*AddressView_Decoded) ProtoMessage() {}
+func (*AddressView_Decoded) Descriptor() ([]byte, []int) {
+ return fileDescriptor_171d3f5d66e6613e, []int{1, 0}
+}
+func (m *AddressView_Decoded) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *AddressView_Decoded) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_AddressView_Decoded.Marshal(b, 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_Decoded) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_AddressView_Decoded.Merge(m, src)
+}
+func (m *AddressView_Decoded) XXX_Size() int {
+ return m.Size()
+}
+func (m *AddressView_Decoded) XXX_DiscardUnknown() {
+ xxx_messageInfo_AddressView_Decoded.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AddressView_Decoded proto.InternalMessageInfo
+
+func (m *AddressView_Decoded) GetAddress() *Address {
+ if m != nil {
+ return m.Address
+ }
+ return nil
+}
+
+func (m *AddressView_Decoded) GetIndex() *AddressIndex {
+ if m != nil {
+ return m.Index
+ }
+ return nil
+}
+
+func (m *AddressView_Decoded) GetWalletId() *WalletId {
+ if m != nil {
+ return m.WalletId
+ }
+ return nil
+}
+
+// An opaque address, with no information about the address index or wallet ID visible.
+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_171d3f5d66e6613e, []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_171d3f5d66e6613e, []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_171d3f5d66e6613e, []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_171d3f5d66e6613e, []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_171d3f5d66e6613e, []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_171d3f5d66e6613e, []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_171d3f5d66e6613e, []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_171d3f5d66e6613e, []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_171d3f5d66e6613e, []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_171d3f5d66e6613e, []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.v1.Address")
+ proto.RegisterType((*AddressView)(nil), "penumbra.core.keys.v1.AddressView")
+ proto.RegisterType((*AddressView_Decoded)(nil), "penumbra.core.keys.v1.AddressView.Decoded")
+ proto.RegisterType((*AddressView_Opaque)(nil), "penumbra.core.keys.v1.AddressView.Opaque")
+ proto.RegisterType((*PayloadKey)(nil), "penumbra.core.keys.v1.PayloadKey")
+ proto.RegisterType((*SpendKey)(nil), "penumbra.core.keys.v1.SpendKey")
+ proto.RegisterType((*FullViewingKey)(nil), "penumbra.core.keys.v1.FullViewingKey")
+ proto.RegisterType((*WalletId)(nil), "penumbra.core.keys.v1.WalletId")
+ proto.RegisterType((*Diversifier)(nil), "penumbra.core.keys.v1.Diversifier")
+ proto.RegisterType((*AddressIndex)(nil), "penumbra.core.keys.v1.AddressIndex")
+ proto.RegisterType((*IdentityKey)(nil), "penumbra.core.keys.v1.IdentityKey")
+ proto.RegisterType((*GovernanceKey)(nil), "penumbra.core.keys.v1.GovernanceKey")
+ proto.RegisterType((*ConsensusKey)(nil), "penumbra.core.keys.v1.ConsensusKey")
+}
+
+func init() { proto.RegisterFile("penumbra/core/keys/v1/keys.proto", fileDescriptor_171d3f5d66e6613e) }
+
+var fileDescriptor_171d3f5d66e6613e = []byte{
+ // 586 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x94, 0xcf, 0x6e, 0xd3, 0x4e,
+ 0x10, 0xc7, 0x63, 0x57, 0xbf, 0xa6, 0x9d, 0xa4, 0x3d, 0x58, 0xbf, 0x4a, 0xa1, 0x12, 0x6e, 0x70,
+ 0x11, 0x2a, 0x1c, 0x6c, 0x25, 0xbd, 0x40, 0xe0, 0x00, 0x49, 0xd5, 0xa6, 0xaa, 0x10, 0x91, 0x91,
+ 0x82, 0x84, 0x22, 0x55, 0x1b, 0xef, 0x90, 0xae, 0xe2, 0xec, 0x86, 0xf5, 0x9f, 0x60, 0x9e, 0x82,
+ 0x67, 0xe0, 0x88, 0xc4, 0x1b, 0xf0, 0x00, 0x88, 0x53, 0x8f, 0x1c, 0x51, 0x7a, 0xe3, 0x25, 0x40,
+ 0xeb, 0x3f, 0xa5, 0x87, 0x24, 0x42, 0x9c, 0x76, 0x77, 0xfc, 0xf9, 0xce, 0x77, 0x76, 0x46, 0x6b,
+ 0xa8, 0x4f, 0x91, 0x47, 0x93, 0xa1, 0x24, 0x8e, 0x27, 0x24, 0x3a, 0x63, 0x4c, 0x02, 0x27, 0x6e,
+ 0xa4, 0xab, 0x3d, 0x95, 0x22, 0x14, 0xc6, 0x4e, 0x41, 0xd8, 0x8a, 0xb0, 0xd3, 0x2f, 0x71, 0xc3,
+ 0x7a, 0x0a, 0xe5, 0x67, 0x94, 0x4a, 0x0c, 0x02, 0xe3, 0x7f, 0xf8, 0x8f, 0x71, 0x8e, 0xb2, 0xa6,
+ 0xd5, 0xb5, 0x83, 0xaa, 0x9b, 0x1d, 0x8c, 0x3d, 0xa8, 0x10, 0x3f, 0x3c, 0x1f, 0xa2, 0x77, 0x71,
+ 0xd8, 0x9c, 0xd4, 0xf4, 0xba, 0x76, 0xb0, 0xe9, 0x02, 0xf1, 0xc3, 0x76, 0x16, 0xb1, 0x3e, 0xaf,
+ 0x41, 0x25, 0x4f, 0xd1, 0x67, 0x38, 0x33, 0x8e, 0xa1, 0x4c, 0xd1, 0x13, 0x14, 0x69, 0x9a, 0xa8,
+ 0xd2, 0x7c, 0x60, 0x2f, 0xb4, 0xb6, 0x6f, 0x88, 0xec, 0xa3, 0x4c, 0xd1, 0x2d, 0xb9, 0x85, 0xd8,
+ 0xe8, 0xc0, 0xba, 0x98, 0x92, 0xb7, 0x11, 0xa6, 0x9e, 0x95, 0xe6, 0xfd, 0xbf, 0x48, 0xf3, 0x22,
+ 0x15, 0x74, 0x4b, 0x6e, 0x2e, 0xdd, 0xfd, 0xa2, 0x41, 0x39, 0xcf, 0x6d, 0x3c, 0x84, 0x32, 0xc9,
+ 0xd8, 0xbc, 0x30, 0x73, 0x75, 0x46, 0xb7, 0xc0, 0x8d, 0x47, 0xaa, 0x33, 0x14, 0xdf, 0xe5, 0x95,
+ 0xec, 0xaf, 0xd6, 0x9d, 0x2a, 0xd4, 0xcd, 0x14, 0xc6, 0x13, 0xd8, 0x9c, 0x11, 0xdf, 0xc7, 0xf0,
+ 0x9c, 0xd1, 0xda, 0x5a, 0x2a, 0xdf, 0x5b, 0x22, 0x7f, 0x95, 0x72, 0xa7, 0xd4, 0xdd, 0x98, 0xe5,
+ 0xbb, 0xdd, 0x36, 0xac, 0x67, 0x57, 0xfa, 0xf7, 0xe2, 0xdb, 0xdb, 0x50, 0xcd, 0xb7, 0xe7, 0x31,
+ 0xc3, 0x99, 0x65, 0x01, 0xf4, 0x48, 0xe2, 0x0b, 0x42, 0xcf, 0x30, 0x59, 0x3c, 0x74, 0xab, 0x0e,
+ 0x1b, 0x2f, 0xa7, 0xc8, 0x57, 0x10, 0xf7, 0x60, 0xfb, 0x38, 0xf2, 0x7d, 0xd5, 0x75, 0xc6, 0x47,
+ 0x2b, 0x33, 0x15, 0xf7, 0x5a, 0x42, 0xec, 0x43, 0xe5, 0x88, 0xc5, 0x28, 0x03, 0xf6, 0x86, 0xa1,
+ 0x5c, 0x02, 0x75, 0xa1, 0x7a, 0xb3, 0xbb, 0x46, 0x0d, 0xca, 0xc4, 0xf3, 0x44, 0xc4, 0xc3, 0x74,
+ 0x26, 0x5b, 0x6e, 0x71, 0x34, 0x4c, 0x00, 0x49, 0x38, 0x15, 0x13, 0xf6, 0x1e, 0x65, 0xda, 0xf1,
+ 0xaa, 0x7b, 0x23, 0x62, 0xdd, 0x86, 0xca, 0x29, 0x45, 0x1e, 0xb2, 0x30, 0x51, 0x55, 0x6f, 0x83,
+ 0xce, 0xc6, 0xb9, 0x97, 0xce, 0xc6, 0xd6, 0x1e, 0x6c, 0x9d, 0x88, 0x18, 0x25, 0x27, 0xdc, 0xc3,
+ 0x1c, 0x18, 0x5d, 0x03, 0xa3, 0xb1, 0x75, 0x17, 0xaa, 0x1d, 0xc1, 0x03, 0xe4, 0x41, 0x14, 0x2c,
+ 0xbd, 0x76, 0xfb, 0x97, 0xf6, 0x75, 0x6e, 0x6a, 0x97, 0x73, 0x53, 0xfb, 0x31, 0x37, 0xb5, 0x0f,
+ 0x57, 0x66, 0xe9, 0xf2, 0xca, 0x2c, 0x7d, 0xbf, 0x32, 0x4b, 0x70, 0xcb, 0x13, 0x93, 0xc5, 0xb3,
+ 0x6b, 0x6f, 0x9e, 0x61, 0x12, 0xf4, 0xd4, 0x73, 0xed, 0x69, 0xaf, 0xbb, 0x23, 0x16, 0x5e, 0x44,
+ 0x43, 0xdb, 0x13, 0x13, 0xc7, 0x13, 0xc1, 0x44, 0x04, 0x8e, 0x44, 0x9f, 0x24, 0x28, 0x9d, 0xb8,
+ 0x79, 0xbd, 0xf5, 0x2e, 0x08, 0xe3, 0x81, 0xb3, 0xf0, 0xf9, 0x3f, 0x56, 0x6b, 0xdc, 0xf8, 0xa8,
+ 0xaf, 0xf5, 0x3a, 0x67, 0x9f, 0xf4, 0x9d, 0x5e, 0x61, 0xda, 0x51, 0xa6, 0xca, 0xcb, 0xee, 0x37,
+ 0xbe, 0xfd, 0x89, 0x0f, 0x54, 0x7c, 0xa0, 0xe2, 0x83, 0x7e, 0x63, 0xae, 0xdf, 0x59, 0x18, 0x1f,
+ 0x9c, 0xf4, 0xda, 0xcf, 0x31, 0x24, 0x94, 0x84, 0xe4, 0xa7, 0x5e, 0x2b, 0x98, 0x56, 0x4b, 0x41,
+ 0xad, 0x96, 0xa2, 0x5a, 0xad, 0x7e, 0x63, 0xb8, 0x9e, 0xfe, 0x76, 0x0e, 0x7f, 0x07, 0x00, 0x00,
+ 0xff, 0xff, 0xae, 0xfb, 0x78, 0x03, 0x9a, 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_Decoded_) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AddressView_Decoded_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ if m.Decoded != nil {
+ {
+ size, err := m.Decoded.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_Decoded) Marshal() (dAtA []byte, err error) {
+ size := 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_Decoded) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AddressView_Decoded) 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_Decoded_) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.Decoded != nil {
+ l = m.Decoded.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_Decoded) 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 Decoded", 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_Decoded{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ m.AddressView = &AddressView_Decoded_{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_Decoded) Unmarshal(dAtA []byte) 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: Decoded: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Decoded: 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/v1/num.pb.go b/relayer/chains/penumbra/core/num/v1/num.pb.go
new file mode 100644
index 000000000..461b62775
--- /dev/null
+++ b/relayer/chains/penumbra/core/num/v1/num.pb.go
@@ -0,0 +1,345 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: penumbra/core/num/v1/num.proto
+
+package numv1
+
+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_660cebd44e5047eb, []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.v1.Amount")
+}
+
+func init() { proto.RegisterFile("penumbra/core/num/v1/num.proto", fileDescriptor_660cebd44e5047eb) }
+
+var fileDescriptor_660cebd44e5047eb = []byte{
+ // 270 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2b, 0x48, 0xcd, 0x2b,
+ 0xcd, 0x4d, 0x2a, 0x4a, 0xd4, 0x4f, 0xce, 0x2f, 0x4a, 0xd5, 0xcf, 0x2b, 0xcd, 0xd5, 0x2f, 0x33,
+ 0x04, 0x51, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, 0x22, 0x30, 0x79, 0x3d, 0x90, 0xbc, 0x1e,
+ 0x48, 0xa2, 0xcc, 0x50, 0x49, 0x83, 0x8b, 0xcd, 0x31, 0x37, 0xbf, 0x34, 0xaf, 0x44, 0x88, 0x8f,
+ 0x8b, 0x29, 0x27, 0x5f, 0x82, 0x51, 0x81, 0x51, 0x83, 0x25, 0x88, 0x29, 0x27, 0x1f, 0xc4, 0xcf,
+ 0xc8, 0x94, 0x60, 0x82, 0xf0, 0x33, 0x32, 0x9d, 0xbe, 0x33, 0x9e, 0x78, 0x24, 0xc7, 0x78, 0xe1,
+ 0x91, 0x1c, 0xe3, 0x83, 0x47, 0x72, 0x8c, 0x13, 0x1e, 0xcb, 0x31, 0x5c, 0x78, 0x2c, 0xc7, 0x70,
+ 0xe3, 0xb1, 0x1c, 0x03, 0x97, 0x44, 0x72, 0x7e, 0xae, 0x1e, 0x36, 0xe3, 0x9d, 0x38, 0xfc, 0x4a,
+ 0x73, 0x03, 0x40, 0xd6, 0x07, 0x30, 0x46, 0xb9, 0xa5, 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, 0xd8, 0x3c, 0x63,
+ 0x9d, 0x57, 0x9a, 0x5b, 0x66, 0xb8, 0x88, 0x89, 0x39, 0xc0, 0xd9, 0x6f, 0x15, 0x93, 0x48, 0x00,
+ 0xcc, 0x42, 0x67, 0x90, 0x85, 0x7e, 0xa5, 0xb9, 0x7a, 0x61, 0x86, 0xa7, 0x10, 0xc2, 0x31, 0x20,
+ 0xe1, 0x18, 0xbf, 0xd2, 0xdc, 0x98, 0x30, 0xc3, 0x47, 0x4c, 0x0a, 0xd8, 0x84, 0x63, 0xdc, 0x03,
+ 0x9c, 0x7c, 0x53, 0x4b, 0x12, 0x53, 0x12, 0x4b, 0x12, 0x5f, 0x31, 0x89, 0xc3, 0x94, 0x58, 0x59,
+ 0x81, 0xd4, 0x58, 0x59, 0xf9, 0x95, 0xe6, 0x5a, 0x59, 0x85, 0x19, 0x26, 0xb1, 0x81, 0x03, 0xd0,
+ 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x2c, 0x3e, 0x53, 0x90, 0x62, 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/v1/transaction.pb.go
similarity index 62%
rename from relayer/chains/penumbra/core/transaction/v1alpha1/transaction.pb.go
rename to relayer/chains/penumbra/core/transaction/v1/transaction.pb.go
index c22d6f2ae..a4e41fadc 100644
--- a/relayer/chains/penumbra/core/transaction/v1alpha1/transaction.pb.go
+++ b/relayer/chains/penumbra/core/transaction/v1/transaction.pb.go
@@ -1,16 +1,25 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: penumbra/core/transaction/v1alpha1/transaction.proto
+// source: penumbra/core/transaction/v1/transaction.proto
-package transactionv1alpha1
+package transactionv1
import (
fmt "fmt"
+ types "github.com/cosmos/cosmos-sdk/codec/types"
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"
+ v110 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/asset/v1"
+ v15 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/dex/v1"
+ v12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/fee/v1"
+ v18 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/governance/v1"
+ v17 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/ibc/v1"
+ v112 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/sct/v1"
+ v14 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/shielded_pool/v1"
+ v16 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/stake/v1"
+ v19 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/keys/v1"
+ v111 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/txhash/v1"
+ v13 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/decaf377_fmd/v1"
+ v1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/decaf377_rdsa/v1"
+ v11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/tct/v1"
io "io"
math "math"
math_bits "math/bits"
@@ -31,17 +40,17 @@ 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 *v1.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 *v11.MerkleRoot `protobuf:"bytes,3,opt,name=anchor,proto3" json:"anchor,omitempty"`
}
func (m *Transaction) Reset() { *m = Transaction{} }
func (m *Transaction) String() string { return proto.CompactTextString(m) }
func (*Transaction) ProtoMessage() {}
func (*Transaction) Descriptor() ([]byte, []int) {
- return fileDescriptor_cd20ea79758052c4, []int{0}
+ return fileDescriptor_8b6c2b29a42813c9, []int{0}
}
func (m *Transaction) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -77,128 +86,39 @@ func (m *Transaction) GetBody() *TransactionBody {
return nil
}
-func (m *Transaction) GetBindingSig() []byte {
+func (m *Transaction) GetBindingSig() *v1.BindingSignature {
if m != nil {
return m.BindingSig
}
return nil
}
-func (m *Transaction) GetAnchor() *v1alpha1.MerkleRoot {
+func (m *Transaction) GetAnchor() *v11.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_8b6c2b29a42813c9, []int{1}
}
func (m *TransactionBody) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -241,13 +161,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 +168,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 +184,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 *v12.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_8b6c2b29a42813c9, []int{2}
}
func (m *TransactionParameters) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -393,17 +235,24 @@ func (m *TransactionParameters) GetChainId() string {
return ""
}
+func (m *TransactionParameters) GetFee() *v12.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 []*v13.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_8b6c2b29a42813c9, []int{3}
}
func (m *DetectionData) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -432,7 +281,7 @@ func (m *DetectionData) XXX_DiscardUnknown() {
var xxx_messageInfo_DetectionData proto.InternalMessageInfo
-func (m *DetectionData) GetFmdClues() []*v1alpha1.Clue {
+func (m *DetectionData) GetFmdClues() []*v13.Clue {
if m != nil {
return m.FmdClues
}
@@ -447,7 +296,7 @@ type Action struct {
// *Action_Swap
// *Action_SwapClaim
// *Action_ValidatorDefinition
- // *Action_IbcAction
+ // *Action_IbcRelayAction
// *Action_ProposalSubmit
// *Action_ProposalWithdraw
// *Action_ValidatorVote
@@ -460,9 +309,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 +320,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_8b6c2b29a42813c9, []int{4}
}
func (m *Action) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -507,70 +356,70 @@ type isAction_Action interface {
}
type Action_Spend struct {
- Spend *Spend `protobuf:"bytes,1,opt,name=spend,proto3,oneof" json:"spend,omitempty"`
+ Spend *v14.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 *v14.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 *v15.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 *v15.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 *v16.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 *v17.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 *v18.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 *v18.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 *v18.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 *v18.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 *v18.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 *v15.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 *v15.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 *v15.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 *v15.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 *v16.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 *v16.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 *v16.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 *v18.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 *v18.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 *v18.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 *v17.Ics20Withdrawal `protobuf:"bytes,200,opt,name=ics20_withdrawal,json=ics20Withdrawal,proto3,oneof" json:"ics20_withdrawal,omitempty"`
}
func (*Action_Spend) isAction_Action() {}
@@ -578,7 +427,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 +440,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 +452,155 @@ func (m *Action) GetAction() isAction_Action {
return nil
}
-func (m *Action) GetSpend() *Spend {
+func (m *Action) GetSpend() *v14.Spend {
if x, ok := m.GetAction().(*Action_Spend); ok {
return x.Spend
}
return nil
}
-func (m *Action) GetOutput() *Output {
+func (m *Action) GetOutput() *v14.Output {
if x, ok := m.GetAction().(*Action_Output); ok {
return x.Output
}
return nil
}
-func (m *Action) GetSwap() *v1alpha11.Swap {
+func (m *Action) GetSwap() *v15.Swap {
if x, ok := m.GetAction().(*Action_Swap); ok {
return x.Swap
}
return nil
}
-func (m *Action) GetSwapClaim() *v1alpha11.SwapClaim {
+func (m *Action) GetSwapClaim() *v15.SwapClaim {
if x, ok := m.GetAction().(*Action_SwapClaim); ok {
return x.SwapClaim
}
return nil
}
-func (m *Action) GetValidatorDefinition() *v1alpha12.ValidatorDefinition {
+func (m *Action) GetValidatorDefinition() *v16.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() *v17.IbcRelay {
+ if x, ok := m.GetAction().(*Action_IbcRelayAction); ok {
+ return x.IbcRelayAction
}
return nil
}
-func (m *Action) GetProposalSubmit() *v1alpha14.ProposalSubmit {
+func (m *Action) GetProposalSubmit() *v18.ProposalSubmit {
if x, ok := m.GetAction().(*Action_ProposalSubmit); ok {
return x.ProposalSubmit
}
return nil
}
-func (m *Action) GetProposalWithdraw() *v1alpha14.ProposalWithdraw {
+func (m *Action) GetProposalWithdraw() *v18.ProposalWithdraw {
if x, ok := m.GetAction().(*Action_ProposalWithdraw); ok {
return x.ProposalWithdraw
}
return nil
}
-func (m *Action) GetValidatorVote() *v1alpha14.ValidatorVote {
+func (m *Action) GetValidatorVote() *v18.ValidatorVote {
if x, ok := m.GetAction().(*Action_ValidatorVote); ok {
return x.ValidatorVote
}
return nil
}
-func (m *Action) GetDelegatorVote() *v1alpha14.DelegatorVote {
+func (m *Action) GetDelegatorVote() *v18.DelegatorVote {
if x, ok := m.GetAction().(*Action_DelegatorVote); ok {
return x.DelegatorVote
}
return nil
}
-func (m *Action) GetProposalDepositClaim() *v1alpha14.ProposalDepositClaim {
+func (m *Action) GetProposalDepositClaim() *v18.ProposalDepositClaim {
if x, ok := m.GetAction().(*Action_ProposalDepositClaim); ok {
return x.ProposalDepositClaim
}
return nil
}
-func (m *Action) GetPositionOpen() *v1alpha11.PositionOpen {
+func (m *Action) GetPositionOpen() *v15.PositionOpen {
if x, ok := m.GetAction().(*Action_PositionOpen); ok {
return x.PositionOpen
}
return nil
}
-func (m *Action) GetPositionClose() *v1alpha11.PositionClose {
+func (m *Action) GetPositionClose() *v15.PositionClose {
if x, ok := m.GetAction().(*Action_PositionClose); ok {
return x.PositionClose
}
return nil
}
-func (m *Action) GetPositionWithdraw() *v1alpha11.PositionWithdraw {
+func (m *Action) GetPositionWithdraw() *v15.PositionWithdraw {
if x, ok := m.GetAction().(*Action_PositionWithdraw); ok {
return x.PositionWithdraw
}
return nil
}
-func (m *Action) GetPositionRewardClaim() *v1alpha11.PositionRewardClaim {
+// Deprecated: Do not use.
+func (m *Action) GetPositionRewardClaim() *v15.PositionRewardClaim {
if x, ok := m.GetAction().(*Action_PositionRewardClaim); ok {
return x.PositionRewardClaim
}
return nil
}
-func (m *Action) GetDelegate() *v1alpha12.Delegate {
+func (m *Action) GetDelegate() *v16.Delegate {
if x, ok := m.GetAction().(*Action_Delegate); ok {
return x.Delegate
}
return nil
}
-func (m *Action) GetUndelegate() *v1alpha12.Undelegate {
+func (m *Action) GetUndelegate() *v16.Undelegate {
if x, ok := m.GetAction().(*Action_Undelegate); ok {
return x.Undelegate
}
return nil
}
-func (m *Action) GetUndelegateClaim() *v1alpha12.UndelegateClaim {
+func (m *Action) GetUndelegateClaim() *v16.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() *v18.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() *v18.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() *v18.CommunityPoolDeposit {
+ if x, ok := m.GetAction().(*Action_CommunityPoolDeposit); ok {
+ return x.CommunityPoolDeposit
}
return nil
}
-func (m *Action) GetIcs20Withdrawal() *v1alpha13.Ics20Withdrawal {
+func (m *Action) GetIcs20Withdrawal() *v17.Ics20Withdrawal {
if x, ok := m.GetAction().(*Action_Ics20Withdrawal); ok {
return x.Ics20Withdrawal
}
@@ -765,7 +615,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 +628,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 +642,30 @@ 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 []*v14.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 []*v19.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 []*v110.Metadata `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 *v111.TransactionId `protobuf:"bytes,6,opt,name=transaction_id,json=transactionId,proto3" json:"transaction_id,omitempty"`
+ // Any relevant estimated prices
+ Prices []*v110.EstimatedPrice `protobuf:"bytes,20,rep,name=prices,proto3" json:"prices,omitempty"`
+ // Any relevant extended metadata, indexed by asset id.
+ ExtendedMetadata []*TransactionPerspective_ExtendedMetadataById `protobuf:"bytes,30,rep,name=extended_metadata,json=extendedMetadata,proto3" json:"extended_metadata,omitempty"`
+ CreationTransactionIdsByNullifier []*TransactionPerspective_CreationTransactionIdByNullifier `protobuf:"bytes,40,rep,name=creation_transaction_ids_by_nullifier,json=creationTransactionIdsByNullifier,proto3" json:"creation_transaction_ids_by_nullifier,omitempty"`
+ NullificationTransactionIdsByCommitment []*TransactionPerspective_NullificationTransactionIdByCommitment `protobuf:"bytes,50,rep,name=nullification_transaction_ids_by_commitment,json=nullificationTransactionIdsByCommitment,proto3" json:"nullification_transaction_ids_by_commitment,omitempty"`
+ // Any relevant BatchSwapOutputData to the transaction.
+ //
+ // This can be used to fill in information about swap outputs.
+ BatchSwapOutputData []*v15.BatchSwapOutputData `protobuf:"bytes,60,rep,name=batch_swap_output_data,json=batchSwapOutputData,proto3" json:"batch_swap_output_data,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_8b6c2b29a42813c9, []int{5}
}
func (m *TransactionPerspective) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -848,50 +708,90 @@ func (m *TransactionPerspective) GetSpendNullifiers() []*NullifierWithNote {
return nil
}
-func (m *TransactionPerspective) GetAdviceNotes() []*v1alpha1.Note {
+func (m *TransactionPerspective) GetAdviceNotes() []*v14.Note {
if m != nil {
return m.AdviceNotes
}
return nil
}
-func (m *TransactionPerspective) GetAddressViews() []*v1alpha1.AddressView {
+func (m *TransactionPerspective) GetAddressViews() []*v19.AddressView {
if m != nil {
return m.AddressViews
}
return nil
}
-func (m *TransactionPerspective) GetDenoms() []*v1alpha1.DenomMetadata {
+func (m *TransactionPerspective) GetDenoms() []*v110.Metadata {
if m != nil {
return m.Denoms
}
return nil
}
-func (m *TransactionPerspective) GetTransactionId() *Id {
+func (m *TransactionPerspective) GetTransactionId() *v111.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 *TransactionPerspective) GetPrices() []*v110.EstimatedPrice {
+ if m != nil {
+ return m.Prices
+ }
+ return nil
+}
+
+func (m *TransactionPerspective) GetExtendedMetadata() []*TransactionPerspective_ExtendedMetadataById {
+ if m != nil {
+ return m.ExtendedMetadata
+ }
+ return nil
+}
+
+func (m *TransactionPerspective) GetCreationTransactionIdsByNullifier() []*TransactionPerspective_CreationTransactionIdByNullifier {
+ if m != nil {
+ return m.CreationTransactionIdsByNullifier
+ }
+ return nil
+}
+
+func (m *TransactionPerspective) GetNullificationTransactionIdsByCommitment() []*TransactionPerspective_NullificationTransactionIdByCommitment {
+ if m != nil {
+ return m.NullificationTransactionIdsByCommitment
+ }
+ return nil
+}
+
+func (m *TransactionPerspective) GetBatchSwapOutputData() []*v15.BatchSwapOutputData {
+ if m != nil {
+ return m.BatchSwapOutputData
+ }
+ return nil
}
-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}
+type TransactionPerspective_ExtendedMetadataById struct {
+ AssetId *v110.AssetId `protobuf:"bytes,1,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"`
+ ExtendedMetadata *types.Any `protobuf:"bytes,2,opt,name=extended_metadata,json=extendedMetadata,proto3" json:"extended_metadata,omitempty"`
}
-func (m *PayloadKey) XXX_Unmarshal(b []byte) error {
+
+func (m *TransactionPerspective_ExtendedMetadataById) Reset() {
+ *m = TransactionPerspective_ExtendedMetadataById{}
+}
+func (m *TransactionPerspective_ExtendedMetadataById) String() string {
+ return proto.CompactTextString(m)
+}
+func (*TransactionPerspective_ExtendedMetadataById) ProtoMessage() {}
+func (*TransactionPerspective_ExtendedMetadataById) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8b6c2b29a42813c9, []int{5, 0}
+}
+func (m *TransactionPerspective_ExtendedMetadataById) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
-func (m *PayloadKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *TransactionPerspective_ExtendedMetadataById) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
- return xxx_messageInfo_PayloadKey.Marshal(b, m, deterministic)
+ return xxx_messageInfo_TransactionPerspective_ExtendedMetadataById.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
@@ -901,35 +801,162 @@ func (m *PayloadKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return b[:n], nil
}
}
-func (m *PayloadKey) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PayloadKey.Merge(m, src)
+func (m *TransactionPerspective_ExtendedMetadataById) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_TransactionPerspective_ExtendedMetadataById.Merge(m, src)
}
-func (m *PayloadKey) XXX_Size() int {
+func (m *TransactionPerspective_ExtendedMetadataById) XXX_Size() int {
return m.Size()
}
-func (m *PayloadKey) XXX_DiscardUnknown() {
- xxx_messageInfo_PayloadKey.DiscardUnknown(m)
+func (m *TransactionPerspective_ExtendedMetadataById) XXX_DiscardUnknown() {
+ xxx_messageInfo_TransactionPerspective_ExtendedMetadataById.DiscardUnknown(m)
}
-var xxx_messageInfo_PayloadKey proto.InternalMessageInfo
+var xxx_messageInfo_TransactionPerspective_ExtendedMetadataById proto.InternalMessageInfo
-func (m *PayloadKey) GetInner() []byte {
+func (m *TransactionPerspective_ExtendedMetadataById) GetAssetId() *v110.AssetId {
if m != nil {
- return m.Inner
+ return m.AssetId
+ }
+ return nil
+}
+
+func (m *TransactionPerspective_ExtendedMetadataById) GetExtendedMetadata() *types.Any {
+ if m != nil {
+ return m.ExtendedMetadata
+ }
+ return nil
+}
+
+// Associates a nullifier with the transaction ID that created the nullified state commitment.
+//
+// Note: this is _not_ the transaction ID that revealed the nullifier.
+//
+// Allows walking backwards from a spend to the transaction that created the note.
+type TransactionPerspective_CreationTransactionIdByNullifier struct {
+ Nullifier *v112.Nullifier `protobuf:"bytes,1,opt,name=nullifier,proto3" json:"nullifier,omitempty"`
+ TransactionId *v111.TransactionId `protobuf:"bytes,2,opt,name=transaction_id,json=transactionId,proto3" json:"transaction_id,omitempty"`
+}
+
+func (m *TransactionPerspective_CreationTransactionIdByNullifier) Reset() {
+ *m = TransactionPerspective_CreationTransactionIdByNullifier{}
+}
+func (m *TransactionPerspective_CreationTransactionIdByNullifier) String() string {
+ return proto.CompactTextString(m)
+}
+func (*TransactionPerspective_CreationTransactionIdByNullifier) ProtoMessage() {}
+func (*TransactionPerspective_CreationTransactionIdByNullifier) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8b6c2b29a42813c9, []int{5, 1}
+}
+func (m *TransactionPerspective_CreationTransactionIdByNullifier) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *TransactionPerspective_CreationTransactionIdByNullifier) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_TransactionPerspective_CreationTransactionIdByNullifier.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *TransactionPerspective_CreationTransactionIdByNullifier) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_TransactionPerspective_CreationTransactionIdByNullifier.Merge(m, src)
+}
+func (m *TransactionPerspective_CreationTransactionIdByNullifier) XXX_Size() int {
+ return m.Size()
+}
+func (m *TransactionPerspective_CreationTransactionIdByNullifier) XXX_DiscardUnknown() {
+ xxx_messageInfo_TransactionPerspective_CreationTransactionIdByNullifier.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TransactionPerspective_CreationTransactionIdByNullifier proto.InternalMessageInfo
+
+func (m *TransactionPerspective_CreationTransactionIdByNullifier) GetNullifier() *v112.Nullifier {
+ if m != nil {
+ return m.Nullifier
+ }
+ return nil
+}
+
+func (m *TransactionPerspective_CreationTransactionIdByNullifier) GetTransactionId() *v111.TransactionId {
+ if m != nil {
+ return m.TransactionId
+ }
+ return nil
+}
+
+// Associates a commitment with the transaction ID that eventually nullified it.
+//
+// Allows walking forwards from an output to the transaction that spent the note.
+type TransactionPerspective_NullificationTransactionIdByCommitment struct {
+ Commitment *v11.StateCommitment `protobuf:"bytes,1,opt,name=commitment,proto3" json:"commitment,omitempty"`
+ TransactionId *v111.TransactionId `protobuf:"bytes,2,opt,name=transaction_id,json=transactionId,proto3" json:"transaction_id,omitempty"`
+}
+
+func (m *TransactionPerspective_NullificationTransactionIdByCommitment) Reset() {
+ *m = TransactionPerspective_NullificationTransactionIdByCommitment{}
+}
+func (m *TransactionPerspective_NullificationTransactionIdByCommitment) String() string {
+ return proto.CompactTextString(m)
+}
+func (*TransactionPerspective_NullificationTransactionIdByCommitment) ProtoMessage() {}
+func (*TransactionPerspective_NullificationTransactionIdByCommitment) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8b6c2b29a42813c9, []int{5, 2}
+}
+func (m *TransactionPerspective_NullificationTransactionIdByCommitment) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *TransactionPerspective_NullificationTransactionIdByCommitment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_TransactionPerspective_NullificationTransactionIdByCommitment.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *TransactionPerspective_NullificationTransactionIdByCommitment) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_TransactionPerspective_NullificationTransactionIdByCommitment.Merge(m, src)
+}
+func (m *TransactionPerspective_NullificationTransactionIdByCommitment) XXX_Size() int {
+ return m.Size()
+}
+func (m *TransactionPerspective_NullificationTransactionIdByCommitment) XXX_DiscardUnknown() {
+ xxx_messageInfo_TransactionPerspective_NullificationTransactionIdByCommitment.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TransactionPerspective_NullificationTransactionIdByCommitment proto.InternalMessageInfo
+
+func (m *TransactionPerspective_NullificationTransactionIdByCommitment) GetCommitment() *v11.StateCommitment {
+ if m != nil {
+ return m.Commitment
+ }
+ return nil
+}
+
+func (m *TransactionPerspective_NullificationTransactionIdByCommitment) GetTransactionId() *v111.TransactionId {
+ if m != nil {
+ return m.TransactionId
}
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 *v19.PayloadKey `protobuf:"bytes,1,opt,name=payload_key,json=payloadKey,proto3" json:"payload_key,omitempty"`
+ Commitment *v11.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_8b6c2b29a42813c9, []int{6}
}
func (m *PayloadKeyWithCommitment) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -958,14 +985,14 @@ func (m *PayloadKeyWithCommitment) XXX_DiscardUnknown() {
var xxx_messageInfo_PayloadKeyWithCommitment proto.InternalMessageInfo
-func (m *PayloadKeyWithCommitment) GetPayloadKey() *PayloadKey {
+func (m *PayloadKeyWithCommitment) GetPayloadKey() *v19.PayloadKey {
if m != nil {
return m.PayloadKey
}
return nil
}
-func (m *PayloadKeyWithCommitment) GetCommitment() *v1alpha1.StateCommitment {
+func (m *PayloadKeyWithCommitment) GetCommitment() *v11.StateCommitment {
if m != nil {
return m.Commitment
}
@@ -973,15 +1000,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 *v112.Nullifier `protobuf:"bytes,1,opt,name=nullifier,proto3" json:"nullifier,omitempty"`
+ Note *v14.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_8b6c2b29a42813c9, []int{7}
}
func (m *NullifierWithNote) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1010,14 +1037,14 @@ func (m *NullifierWithNote) XXX_DiscardUnknown() {
var xxx_messageInfo_NullifierWithNote proto.InternalMessageInfo
-func (m *NullifierWithNote) GetNullifier() *v1alpha1.Nullifier {
+func (m *NullifierWithNote) GetNullifier() *v112.Nullifier {
if m != nil {
return m.Nullifier
}
return nil
}
-func (m *NullifierWithNote) GetNote() *v1alpha1.Note {
+func (m *NullifierWithNote) GetNote() *v14.Note {
if m != nil {
return m.Note
}
@@ -1029,17 +1056,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 *v1.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 *v11.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_8b6c2b29a42813c9, []int{8}
}
func (m *TransactionView) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1075,14 +1102,14 @@ func (m *TransactionView) GetBodyView() *TransactionBodyView {
return nil
}
-func (m *TransactionView) GetBindingSig() []byte {
+func (m *TransactionView) GetBindingSig() *v1.BindingSignature {
if m != nil {
return m.BindingSig
}
return nil
}
-func (m *TransactionView) GetAnchor() *v1alpha1.MerkleRoot {
+func (m *TransactionView) GetAnchor() *v11.MerkleRoot {
if m != nil {
return m.Anchor
}
@@ -1094,23 +1121,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_8b6c2b29a42813c9, []int{9}
}
func (m *TransactionBodyView) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1139,40 +1162,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 +1176,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 +1210,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 +1222,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_8b6c2b29a42813c9, []int{10}
}
func (m *ActionView) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1285,70 +1258,70 @@ type isActionView_ActionView interface {
}
type ActionView_Spend struct {
- Spend *SpendView `protobuf:"bytes,1,opt,name=spend,proto3,oneof" json:"spend,omitempty"`
+ Spend *v14.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 *v14.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 *v15.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 *v15.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 *v16.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 *v17.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 *v18.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 *v18.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 *v18.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 *v18.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 *v18.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 *v15.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 *v15.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 *v15.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 *v15.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 *v16.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 *v16.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 *v18.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 *v18.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 *v18.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 *v16.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 *v17.Ics20Withdrawal `protobuf:"bytes,200,opt,name=ics20_withdrawal,json=ics20Withdrawal,proto3,oneof" json:"ics20_withdrawal,omitempty"`
}
func (*ActionView_Spend) isActionView_ActionView() {}
@@ -1356,7 +1329,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 +1341,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 +1354,155 @@ func (m *ActionView) GetActionView() isActionView_ActionView {
return nil
}
-func (m *ActionView) GetSpend() *SpendView {
+func (m *ActionView) GetSpend() *v14.SpendView {
if x, ok := m.GetActionView().(*ActionView_Spend); ok {
return x.Spend
}
return nil
}
-func (m *ActionView) GetOutput() *OutputView {
+func (m *ActionView) GetOutput() *v14.OutputView {
if x, ok := m.GetActionView().(*ActionView_Output); ok {
return x.Output
}
return nil
}
-func (m *ActionView) GetSwap() *v1alpha11.SwapView {
+func (m *ActionView) GetSwap() *v15.SwapView {
if x, ok := m.GetActionView().(*ActionView_Swap); ok {
return x.Swap
}
return nil
}
-func (m *ActionView) GetSwapClaim() *v1alpha11.SwapClaimView {
+func (m *ActionView) GetSwapClaim() *v15.SwapClaimView {
if x, ok := m.GetActionView().(*ActionView_SwapClaim); ok {
return x.SwapClaim
}
return nil
}
-func (m *ActionView) GetValidatorDefinition() *v1alpha12.ValidatorDefinition {
+func (m *ActionView) GetValidatorDefinition() *v16.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() *v17.IbcRelay {
+ if x, ok := m.GetActionView().(*ActionView_IbcRelayAction); ok {
+ return x.IbcRelayAction
}
return nil
}
-func (m *ActionView) GetProposalSubmit() *v1alpha14.ProposalSubmit {
+func (m *ActionView) GetProposalSubmit() *v18.ProposalSubmit {
if x, ok := m.GetActionView().(*ActionView_ProposalSubmit); ok {
return x.ProposalSubmit
}
return nil
}
-func (m *ActionView) GetProposalWithdraw() *v1alpha14.ProposalWithdraw {
+func (m *ActionView) GetProposalWithdraw() *v18.ProposalWithdraw {
if x, ok := m.GetActionView().(*ActionView_ProposalWithdraw); ok {
return x.ProposalWithdraw
}
return nil
}
-func (m *ActionView) GetValidatorVote() *v1alpha14.ValidatorVote {
+func (m *ActionView) GetValidatorVote() *v18.ValidatorVote {
if x, ok := m.GetActionView().(*ActionView_ValidatorVote); ok {
return x.ValidatorVote
}
return nil
}
-func (m *ActionView) GetDelegatorVote() *DelegatorVoteView {
+func (m *ActionView) GetDelegatorVote() *v18.DelegatorVoteView {
if x, ok := m.GetActionView().(*ActionView_DelegatorVote); ok {
return x.DelegatorVote
}
return nil
}
-func (m *ActionView) GetProposalDepositClaim() *v1alpha14.ProposalDepositClaim {
+func (m *ActionView) GetProposalDepositClaim() *v18.ProposalDepositClaim {
if x, ok := m.GetActionView().(*ActionView_ProposalDepositClaim); ok {
return x.ProposalDepositClaim
}
return nil
}
-func (m *ActionView) GetPositionOpen() *v1alpha11.PositionOpen {
+func (m *ActionView) GetPositionOpen() *v15.PositionOpen {
if x, ok := m.GetActionView().(*ActionView_PositionOpen); ok {
return x.PositionOpen
}
return nil
}
-func (m *ActionView) GetPositionClose() *v1alpha11.PositionClose {
+func (m *ActionView) GetPositionClose() *v15.PositionClose {
if x, ok := m.GetActionView().(*ActionView_PositionClose); ok {
return x.PositionClose
}
return nil
}
-func (m *ActionView) GetPositionWithdraw() *v1alpha11.PositionWithdraw {
+func (m *ActionView) GetPositionWithdraw() *v15.PositionWithdraw {
if x, ok := m.GetActionView().(*ActionView_PositionWithdraw); ok {
return x.PositionWithdraw
}
return nil
}
-func (m *ActionView) GetPositionRewardClaim() *v1alpha11.PositionRewardClaim {
+// Deprecated: Do not use.
+func (m *ActionView) GetPositionRewardClaim() *v15.PositionRewardClaim {
if x, ok := m.GetActionView().(*ActionView_PositionRewardClaim); ok {
return x.PositionRewardClaim
}
return nil
}
-func (m *ActionView) GetDelegate() *v1alpha12.Delegate {
+func (m *ActionView) GetDelegate() *v16.Delegate {
if x, ok := m.GetActionView().(*ActionView_Delegate); ok {
return x.Delegate
}
return nil
}
-func (m *ActionView) GetUndelegate() *v1alpha12.Undelegate {
+func (m *ActionView) GetUndelegate() *v16.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() *v18.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() *v18.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() *v18.CommunityPoolDeposit {
+ if x, ok := m.GetActionView().(*ActionView_CommunityPoolDeposit); ok {
+ return x.CommunityPoolDeposit
}
return nil
}
-func (m *ActionView) GetUndelegateClaim() *v1alpha12.UndelegateClaim {
+func (m *ActionView) GetUndelegateClaim() *v16.UndelegateClaim {
if x, ok := m.GetActionView().(*ActionView_UndelegateClaim); ok {
return x.UndelegateClaim
}
return nil
}
-func (m *ActionView) GetIcs20Withdrawal() *v1alpha13.Ics20Withdrawal {
+func (m *ActionView) GetIcs20Withdrawal() *v17.Ics20Withdrawal {
if x, ok := m.GetActionView().(*ActionView_Ics20Withdrawal); ok {
return x.Ics20Withdrawal
}
@@ -1543,7 +1517,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 +1529,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 *v111.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 []*v1.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 []*v1.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_8b6c2b29a42813c9, []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 +1570,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() *v111.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() []*v1.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() []*v1.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 *v11.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 []*v11.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 *WitnessData) Reset() { *m = WitnessData{} }
+func (m *WitnessData) String() string { return proto.CompactTextString(m) }
+func (*WitnessData) ProtoMessage() {}
+func (*WitnessData) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8b6c2b29a42813c9, []int{12}
}
-func (m *SpendView_Visible) XXX_Unmarshal(b []byte) error {
+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 +1633,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() *v11.MerkleRoot {
if m != nil {
- return m.Spend
+ return m.Anchor
}
return nil
}
-func (m *SpendView_Visible) GetNote() *v1alpha1.NoteView {
+func (m *WitnessData) GetStateCommitmentProofs() []*v11.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_8b6c2b29a42813c9, []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 +1696,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_8b6c2b29a42813c9, []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 +1761,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_Ics20Withdrawal
+ // *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_8b6c2b29a42813c9, []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,237 +1833,326 @@ 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 *v14.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 *v14.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 *v15.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 *v15.SwapClaimPlan `protobuf:"bytes,4,opt,name=swap_claim,json=swapClaim,proto3,oneof" json:"swap_claim,omitempty"`
+}
+type ActionPlan_ValidatorDefinition struct {
+ ValidatorDefinition *v16.ValidatorDefinition `protobuf:"bytes,16,opt,name=validator_definition,json=validatorDefinition,proto3,oneof" json:"validator_definition,omitempty"`
}
-func (m *OutputView) XXX_Merge(src proto.Message) {
- xxx_messageInfo_OutputView.Merge(m, src)
+type ActionPlan_IbcRelayAction struct {
+ IbcRelayAction *v17.IbcRelay `protobuf:"bytes,17,opt,name=ibc_relay_action,json=ibcRelayAction,proto3,oneof" json:"ibc_relay_action,omitempty"`
}
-func (m *OutputView) XXX_Size() int {
- return m.Size()
+type ActionPlan_ProposalSubmit struct {
+ ProposalSubmit *v18.ProposalSubmit `protobuf:"bytes,18,opt,name=proposal_submit,json=proposalSubmit,proto3,oneof" json:"proposal_submit,omitempty"`
}
-func (m *OutputView) XXX_DiscardUnknown() {
- xxx_messageInfo_OutputView.DiscardUnknown(m)
+type ActionPlan_ProposalWithdraw struct {
+ ProposalWithdraw *v18.ProposalWithdraw `protobuf:"bytes,19,opt,name=proposal_withdraw,json=proposalWithdraw,proto3,oneof" json:"proposal_withdraw,omitempty"`
}
-
-var xxx_messageInfo_OutputView proto.InternalMessageInfo
-
-type isOutputView_OutputView interface {
- isOutputView_OutputView()
- MarshalTo([]byte) (int, error)
- Size() int
+type ActionPlan_ValidatorVote struct {
+ ValidatorVote *v18.ValidatorVote `protobuf:"bytes,20,opt,name=validator_vote,json=validatorVote,proto3,oneof" json:"validator_vote,omitempty"`
}
-
-type OutputView_Visible_ struct {
- Visible *OutputView_Visible `protobuf:"bytes,1,opt,name=visible,proto3,oneof" json:"visible,omitempty"`
+type ActionPlan_DelegatorVote struct {
+ DelegatorVote *v18.DelegatorVotePlan `protobuf:"bytes,21,opt,name=delegator_vote,json=delegatorVote,proto3,oneof" json:"delegator_vote,omitempty"`
+}
+type ActionPlan_ProposalDepositClaim struct {
+ ProposalDepositClaim *v18.ProposalDepositClaim `protobuf:"bytes,22,opt,name=proposal_deposit_claim,json=proposalDepositClaim,proto3,oneof" json:"proposal_deposit_claim,omitempty"`
+}
+type ActionPlan_Ics20Withdrawal struct {
+ Ics20Withdrawal *v17.Ics20Withdrawal `protobuf:"bytes,200,opt,name=ics20_withdrawal,json=ics20Withdrawal,proto3,oneof" json:"ics20_withdrawal,omitempty"`
+}
+type ActionPlan_PositionOpen struct {
+ PositionOpen *v15.PositionOpen `protobuf:"bytes,30,opt,name=position_open,json=positionOpen,proto3,oneof" json:"position_open,omitempty"`
+}
+type ActionPlan_PositionClose struct {
+ PositionClose *v15.PositionClose `protobuf:"bytes,31,opt,name=position_close,json=positionClose,proto3,oneof" json:"position_close,omitempty"`
+}
+type ActionPlan_PositionWithdraw struct {
+ PositionWithdraw *v15.PositionWithdrawPlan `protobuf:"bytes,32,opt,name=position_withdraw,json=positionWithdraw,proto3,oneof" json:"position_withdraw,omitempty"`
+}
+type ActionPlan_PositionRewardClaim struct {
+ PositionRewardClaim *v15.PositionRewardClaimPlan `protobuf:"bytes,34,opt,name=position_reward_claim,json=positionRewardClaim,proto3,oneof" json:"position_reward_claim,omitempty"`
+}
+type ActionPlan_Delegate struct {
+ Delegate *v16.Delegate `protobuf:"bytes,40,opt,name=delegate,proto3,oneof" json:"delegate,omitempty"`
+}
+type ActionPlan_Undelegate struct {
+ Undelegate *v16.Undelegate `protobuf:"bytes,41,opt,name=undelegate,proto3,oneof" json:"undelegate,omitempty"`
}
-type OutputView_Opaque_ struct {
- Opaque *OutputView_Opaque `protobuf:"bytes,2,opt,name=opaque,proto3,oneof" json:"opaque,omitempty"`
+type ActionPlan_UndelegateClaim struct {
+ UndelegateClaim *v16.UndelegateClaimPlan `protobuf:"bytes,42,opt,name=undelegate_claim,json=undelegateClaim,proto3,oneof" json:"undelegate_claim,omitempty"`
+}
+type ActionPlan_CommunityPoolSpend struct {
+ CommunityPoolSpend *v18.CommunityPoolSpend `protobuf:"bytes,50,opt,name=community_pool_spend,json=communityPoolSpend,proto3,oneof" json:"community_pool_spend,omitempty"`
+}
+type ActionPlan_CommunityPoolOutput struct {
+ CommunityPoolOutput *v18.CommunityPoolOutput `protobuf:"bytes,51,opt,name=community_pool_output,json=communityPoolOutput,proto3,oneof" json:"community_pool_output,omitempty"`
+}
+type ActionPlan_CommunityPoolDeposit struct {
+ CommunityPoolDeposit *v18.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_Ics20Withdrawal) 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() *v14.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() *v14.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() *v15.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() *v15.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 *ActionPlan) GetValidatorDefinition() *v16.ValidatorDefinition {
+ if x, ok := m.GetAction().(*ActionPlan_ValidatorDefinition); ok {
+ return x.ValidatorDefinition
+ }
+ return nil
}
-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) GetIbcRelayAction() *v17.IbcRelay {
+ if x, ok := m.GetAction().(*ActionPlan_IbcRelayAction); ok {
+ return x.IbcRelayAction
}
+ return nil
}
-func (m *OutputView_Visible) XXX_Merge(src proto.Message) {
- xxx_messageInfo_OutputView_Visible.Merge(m, src)
+
+func (m *ActionPlan) GetProposalSubmit() *v18.ProposalSubmit {
+ if x, ok := m.GetAction().(*ActionPlan_ProposalSubmit); ok {
+ return x.ProposalSubmit
+ }
+ return nil
}
-func (m *OutputView_Visible) XXX_Size() int {
- return m.Size()
+
+func (m *ActionPlan) GetProposalWithdraw() *v18.ProposalWithdraw {
+ if x, ok := m.GetAction().(*ActionPlan_ProposalWithdraw); ok {
+ return x.ProposalWithdraw
+ }
+ return nil
}
-func (m *OutputView_Visible) XXX_DiscardUnknown() {
- xxx_messageInfo_OutputView_Visible.DiscardUnknown(m)
+
+func (m *ActionPlan) GetValidatorVote() *v18.ValidatorVote {
+ if x, ok := m.GetAction().(*ActionPlan_ValidatorVote); ok {
+ return x.ValidatorVote
+ }
+ return nil
}
-var xxx_messageInfo_OutputView_Visible proto.InternalMessageInfo
+func (m *ActionPlan) GetDelegatorVote() *v18.DelegatorVotePlan {
+ if x, ok := m.GetAction().(*ActionPlan_DelegatorVote); ok {
+ return x.DelegatorVote
+ }
+ return nil
+}
-func (m *OutputView_Visible) GetOutput() *Output {
- if m != nil {
- return m.Output
+func (m *ActionPlan) GetProposalDepositClaim() *v18.ProposalDepositClaim {
+ if x, ok := m.GetAction().(*ActionPlan_ProposalDepositClaim); ok {
+ return x.ProposalDepositClaim
}
return nil
}
-func (m *OutputView_Visible) GetNote() *v1alpha1.NoteView {
- if m != nil {
- return m.Note
+func (m *ActionPlan) GetIcs20Withdrawal() *v17.Ics20Withdrawal {
+ if x, ok := m.GetAction().(*ActionPlan_Ics20Withdrawal); ok {
+ return x.Ics20Withdrawal
}
return nil
}
-func (m *OutputView_Visible) GetPayloadKey() *PayloadKey {
- if m != nil {
- return m.PayloadKey
+func (m *ActionPlan) GetPositionOpen() *v15.PositionOpen {
+ if x, ok := m.GetAction().(*ActionPlan_PositionOpen); ok {
+ return x.PositionOpen
}
return nil
}
-type OutputView_Opaque struct {
- Output *Output `protobuf:"bytes,1,opt,name=output,proto3" json:"output,omitempty"`
+func (m *ActionPlan) GetPositionClose() *v15.PositionClose {
+ if x, ok := m.GetAction().(*ActionPlan_PositionClose); ok {
+ return x.PositionClose
+ }
+ 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 *ActionPlan) GetPositionWithdraw() *v15.PositionWithdrawPlan {
+ if x, ok := m.GetAction().(*ActionPlan_PositionWithdraw); ok {
+ return x.PositionWithdraw
+ }
+ return nil
}
-func (m *OutputView_Opaque) XXX_Unmarshal(b []byte) error {
- return m.Unmarshal(b)
+
+// Deprecated: Do not use.
+func (m *ActionPlan) GetPositionRewardClaim() *v15.PositionRewardClaimPlan {
+ if x, ok := m.GetAction().(*ActionPlan_PositionRewardClaim); ok {
+ return x.PositionRewardClaim
+ }
+ return nil
}
-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) GetDelegate() *v16.Delegate {
+ if x, ok := m.GetAction().(*ActionPlan_Delegate); ok {
+ return x.Delegate
}
+ return nil
}
-func (m *OutputView_Opaque) XXX_Merge(src proto.Message) {
- xxx_messageInfo_OutputView_Opaque.Merge(m, src)
+
+func (m *ActionPlan) GetUndelegate() *v16.Undelegate {
+ if x, ok := m.GetAction().(*ActionPlan_Undelegate); ok {
+ return x.Undelegate
+ }
+ return nil
}
-func (m *OutputView_Opaque) XXX_Size() int {
- return m.Size()
+
+func (m *ActionPlan) GetUndelegateClaim() *v16.UndelegateClaimPlan {
+ if x, ok := m.GetAction().(*ActionPlan_UndelegateClaim); ok {
+ return x.UndelegateClaim
+ }
+ return nil
}
-func (m *OutputView_Opaque) XXX_DiscardUnknown() {
- xxx_messageInfo_OutputView_Opaque.DiscardUnknown(m)
+
+func (m *ActionPlan) GetCommunityPoolSpend() *v18.CommunityPoolSpend {
+ if x, ok := m.GetAction().(*ActionPlan_CommunityPoolSpend); ok {
+ return x.CommunityPoolSpend
+ }
+ return nil
}
-var xxx_messageInfo_OutputView_Opaque proto.InternalMessageInfo
+func (m *ActionPlan) GetCommunityPoolOutput() *v18.CommunityPoolOutput {
+ if x, ok := m.GetAction().(*ActionPlan_CommunityPoolOutput); ok {
+ return x.CommunityPoolOutput
+ }
+ return nil
+}
-func (m *OutputView_Opaque) GetOutput() *Output {
- if m != nil {
- return m.Output
+func (m *ActionPlan) GetCommunityPoolDeposit() *v18.CommunityPoolDeposit {
+ if x, ok := m.GetAction().(*ActionPlan_CommunityPoolDeposit); ok {
+ return x.CommunityPoolDeposit
}
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"`
+// 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_Ics20Withdrawal)(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),
+ }
+}
+
+// Describes a plan for forming a `Clue`.
+type CluePlan struct {
+ // The address.
+ Address *v19.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 *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 *CluePlan) Reset() { *m = CluePlan{} }
+func (m *CluePlan) String() string { return proto.CompactTextString(m) }
+func (*CluePlan) ProtoMessage() {}
+func (*CluePlan) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8b6c2b29a42813c9, []int{16}
}
-func (m *Spend) XXX_Unmarshal(b []byte) error {
+func (m *CluePlan) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
-func (m *Spend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *CluePlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
- return xxx_messageInfo_Spend.Marshal(b, m, deterministic)
+ return xxx_messageInfo_CluePlan.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
@@ -2148,63 +2162,59 @@ func (m *Spend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return b[:n], nil
}
}
-func (m *Spend) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Spend.Merge(m, src)
+func (m *CluePlan) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_CluePlan.Merge(m, src)
}
-func (m *Spend) XXX_Size() int {
+func (m *CluePlan) XXX_Size() int {
return m.Size()
}
-func (m *Spend) XXX_DiscardUnknown() {
- xxx_messageInfo_Spend.DiscardUnknown(m)
+func (m *CluePlan) XXX_DiscardUnknown() {
+ xxx_messageInfo_CluePlan.DiscardUnknown(m)
}
-var xxx_messageInfo_Spend proto.InternalMessageInfo
+var xxx_messageInfo_CluePlan proto.InternalMessageInfo
-func (m *Spend) GetBody() *SpendBody {
+func (m *CluePlan) GetAddress() *v19.Address {
if m != nil {
- return m.Body
+ return m.Address
}
return nil
}
-func (m *Spend) GetAuthSig() *v1alpha1.SpendAuthSignature {
+func (m *CluePlan) GetRseed() []byte {
if m != nil {
- return m.AuthSig
+ return m.Rseed
}
return nil
}
-func (m *Spend) GetProof() *v1alpha1.ZKSpendProof {
+func (m *CluePlan) GetPrecisionBits() uint64 {
if m != nil {
- return m.Proof
+ return m.PrecisionBits
}
- return nil
+ return 0
}
-// 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"`
+// 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 *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}
+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_8b6c2b29a42813c9, []int{17}
}
-func (m *SpendBody) XXX_Unmarshal(b []byte) error {
+func (m *MemoPlan) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
-func (m *SpendBody) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *MemoPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
- return xxx_messageInfo_SpendBody.Marshal(b, m, deterministic)
+ return xxx_messageInfo_MemoPlan.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
@@ -2214,59 +2224,50 @@ 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 *MemoPlan) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MemoPlan.Merge(m, src)
}
-func (m *SpendBody) XXX_Size() int {
+func (m *MemoPlan) XXX_Size() int {
return m.Size()
}
-func (m *SpendBody) XXX_DiscardUnknown() {
- xxx_messageInfo_SpendBody.DiscardUnknown(m)
+func (m *MemoPlan) XXX_DiscardUnknown() {
+ xxx_messageInfo_MemoPlan.DiscardUnknown(m)
}
-var xxx_messageInfo_SpendBody proto.InternalMessageInfo
-
-func (m *SpendBody) GetBalanceCommitment() *v1alpha1.BalanceCommitment {
- if m != nil {
- return m.BalanceCommitment
- }
- return nil
-}
+var xxx_messageInfo_MemoPlan proto.InternalMessageInfo
-func (m *SpendBody) GetNullifier() []byte {
+func (m *MemoPlan) GetPlaintext() *MemoPlaintext {
if m != nil {
- return m.Nullifier
+ return m.Plaintext
}
return nil
}
-func (m *SpendBody) GetRk() []byte {
+func (m *MemoPlan) GetKey() []byte {
if m != nil {
- return m.Rk
+ return m.Key
}
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 *v1alpha1.ZKOutputProof `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"`
+// 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 *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 *MemoCiphertext) Reset() { *m = MemoCiphertext{} }
+func (m *MemoCiphertext) String() string { return proto.CompactTextString(m) }
+func (*MemoCiphertext) ProtoMessage() {}
+func (*MemoCiphertext) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8b6c2b29a42813c9, []int{18}
}
-func (m *Output) XXX_Unmarshal(b []byte) error {
+func (m *MemoCiphertext) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
-func (m *Output) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *MemoCiphertext) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
- return xxx_messageInfo_Output.Marshal(b, m, deterministic)
+ return xxx_messageInfo_MemoCiphertext.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
@@ -2276,59 +2277,48 @@ 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 *MemoCiphertext) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MemoCiphertext.Merge(m, src)
}
-func (m *Output) XXX_Size() int {
+func (m *MemoCiphertext) XXX_Size() int {
return m.Size()
}
-func (m *Output) XXX_DiscardUnknown() {
- xxx_messageInfo_Output.DiscardUnknown(m)
+func (m *MemoCiphertext) XXX_DiscardUnknown() {
+ xxx_messageInfo_MemoCiphertext.DiscardUnknown(m)
}
-var xxx_messageInfo_Output proto.InternalMessageInfo
+var xxx_messageInfo_MemoCiphertext proto.InternalMessageInfo
-func (m *Output) GetBody() *OutputBody {
+func (m *MemoCiphertext) GetInner() []byte {
if m != nil {
- return m.Body
+ return m.Inner
}
return nil
}
-func (m *Output) GetProof() *v1alpha1.ZKOutputProof {
- if m != nil {
- return m.Proof
- }
- return nil
+// 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 *v19.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"`
}
-// 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}
-}
-func (m *OutputBody) XXX_Unmarshal(b []byte) error {
+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_8b6c2b29a42813c9, []int{19}
+}
+func (m *MemoPlaintext) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
-func (m *OutputBody) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *MemoPlaintext) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
- return xxx_messageInfo_OutputBody.Marshal(b, m, deterministic)
+ return xxx_messageInfo_MemoPlaintext.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
@@ -2338,70 +2328,49 @@ 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 *MemoPlaintext) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MemoPlaintext.Merge(m, src)
}
-func (m *OutputBody) XXX_Size() int {
+func (m *MemoPlaintext) 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 *MemoPlaintext) XXX_DiscardUnknown() {
+ xxx_messageInfo_MemoPlaintext.DiscardUnknown(m)
}
-func (m *OutputBody) GetBalanceCommitment() *v1alpha1.BalanceCommitment {
- if m != nil {
- return m.BalanceCommitment
- }
- return nil
-}
+var xxx_messageInfo_MemoPlaintext proto.InternalMessageInfo
-func (m *OutputBody) GetWrappedMemoKey() []byte {
+func (m *MemoPlaintext) GetReturnAddress() *v19.Address {
if m != nil {
- return m.WrappedMemoKey
+ return m.ReturnAddress
}
return nil
}
-func (m *OutputBody) GetOvkWrappedKey() []byte {
+func (m *MemoPlaintext) GetText() string {
if m != nil {
- return m.OvkWrappedKey
+ return m.Text
}
- return nil
+ return ""
}
-// 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"`
+type MemoPlaintextView struct {
+ ReturnAddress *v19.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 *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 *MemoPlaintextView) Reset() { *m = MemoPlaintextView{} }
+func (m *MemoPlaintextView) String() string { return proto.CompactTextString(m) }
+func (*MemoPlaintextView) ProtoMessage() {}
+func (*MemoPlaintextView) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8b6c2b29a42813c9, []int{20}
}
-func (m *AuthorizationData) XXX_Unmarshal(b []byte) error {
+func (m *MemoPlaintextView) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
-func (m *AuthorizationData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *MemoPlaintextView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
- return xxx_messageInfo_AuthorizationData.Marshal(b, m, deterministic)
+ return xxx_messageInfo_MemoPlaintextView.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
@@ -2411,60 +2380,52 @@ 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 *MemoPlaintextView) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MemoPlaintextView.Merge(m, src)
}
-func (m *AuthorizationData) XXX_Size() int {
+func (m *MemoPlaintextView) XXX_Size() int {
return m.Size()
}
-func (m *AuthorizationData) XXX_DiscardUnknown() {
- xxx_messageInfo_AuthorizationData.DiscardUnknown(m)
+func (m *MemoPlaintextView) XXX_DiscardUnknown() {
+ xxx_messageInfo_MemoPlaintextView.DiscardUnknown(m)
}
-var xxx_messageInfo_AuthorizationData proto.InternalMessageInfo
+var xxx_messageInfo_MemoPlaintextView proto.InternalMessageInfo
-func (m *AuthorizationData) GetEffectHash() *v1alpha1.EffectHash {
+func (m *MemoPlaintextView) GetReturnAddress() *v19.AddressView {
if m != nil {
- return m.EffectHash
+ return m.ReturnAddress
}
return nil
}
-func (m *AuthorizationData) GetSpendAuths() []*v1alpha1.SpendAuthSignature {
+func (m *MemoPlaintextView) GetText() string {
if m != nil {
- return m.SpendAuths
+ return m.Text
}
- return nil
+ return ""
}
-func (m *AuthorizationData) GetDelegatorVoteAuths() []*v1alpha1.SpendAuthSignature {
- if m != nil {
- return m.DelegatorVoteAuths
- }
- return nil
-}
-
-// 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 MemoView struct {
+ // Types that are valid to be assigned to MemoView:
+ //
+ // *MemoView_Visible_
+ // *MemoView_Opaque_
+ MemoView isMemoView_MemoView `protobuf_oneof:"memo_view"`
}
-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 *MemoView) Reset() { *m = MemoView{} }
+func (m *MemoView) String() string { return proto.CompactTextString(m) }
+func (*MemoView) ProtoMessage() {}
+func (*MemoView) Descriptor() ([]byte, []int) {
+ return fileDescriptor_8b6c2b29a42813c9, []int{21}
}
-func (m *WitnessData) XXX_Unmarshal(b []byte) error {
+func (m *MemoView) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
-func (m *WitnessData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *MemoView) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
- return xxx_messageInfo_WitnessData.Marshal(b, m, deterministic)
+ return xxx_messageInfo_MemoView.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
@@ -2474,60 +2435,80 @@ 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 *MemoView) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MemoView.Merge(m, src)
}
-func (m *WitnessData) XXX_Size() int {
+func (m *MemoView) XXX_Size() int {
return m.Size()
}
-func (m *WitnessData) XXX_DiscardUnknown() {
- xxx_messageInfo_WitnessData.DiscardUnknown(m)
+func (m *MemoView) XXX_DiscardUnknown() {
+ xxx_messageInfo_MemoView.DiscardUnknown(m)
}
-var xxx_messageInfo_WitnessData proto.InternalMessageInfo
+var xxx_messageInfo_MemoView proto.InternalMessageInfo
+
+type isMemoView_MemoView interface {
+ isMemoView_MemoView()
+ MarshalTo([]byte) (int, error)
+ Size() int
+}
+
+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 *WitnessData) GetAnchor() *v1alpha1.MerkleRoot {
+func (m *MemoView) GetMemoView() isMemoView_MemoView {
if m != nil {
- return m.Anchor
+ return m.MemoView
}
return nil
}
-func (m *WitnessData) GetStateCommitmentProofs() []*v1alpha1.StateCommitmentProof {
- if m != nil {
- return m.StateCommitmentProofs
+func (m *MemoView) GetVisible() *MemoView_Visible {
+ if x, ok := m.GetMemoView().(*MemoView_Visible_); ok {
+ return x.Visible
}
return nil
}
-// 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"`
+func (m *MemoView) GetOpaque() *MemoView_Opaque {
+ if x, ok := m.GetMemoView().(*MemoView_Opaque_); ok {
+ return x.Opaque
+ }
+ return nil
}
-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}
+// 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 *TransactionPlan) XXX_Unmarshal(b []byte) error {
+
+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 *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_8b6c2b29a42813c9, []int{21, 0}
+}
+func (m *MemoView_Visible) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
-func (m *TransactionPlan) 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_TransactionPlan.Marshal(b, m, deterministic)
+ return xxx_messageInfo_MemoView_Visible.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
@@ -2537,104 +2518,48 @@ 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_Visible) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MemoView_Visible.Merge(m, src)
}
-func (m *TransactionPlan) XXX_Size() int {
+func (m *MemoView_Visible) XXX_Size() int {
return m.Size()
}
-func (m *TransactionPlan) XXX_DiscardUnknown() {
- xxx_messageInfo_TransactionPlan.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_TransactionPlan proto.InternalMessageInfo
-
-func (m *TransactionPlan) GetActions() []*ActionPlan {
- if m != nil {
- return m.Actions
- }
- return nil
-}
-
-func (m *TransactionPlan) GetExpiryHeight() uint64 {
- if m != nil {
- return m.ExpiryHeight
- }
- return 0
-}
-
-func (m *TransactionPlan) GetChainId() string {
- if m != nil {
- return m.ChainId
- }
- return ""
+func (m *MemoView_Visible) XXX_DiscardUnknown() {
+ xxx_messageInfo_MemoView_Visible.DiscardUnknown(m)
}
-func (m *TransactionPlan) GetFee() *v1alpha1.Fee {
- if m != nil {
- return m.Fee
- }
- return nil
-}
+var xxx_messageInfo_MemoView_Visible proto.InternalMessageInfo
-func (m *TransactionPlan) GetCluePlans() []*CluePlan {
+func (m *MemoView_Visible) GetCiphertext() *MemoCiphertext {
if m != nil {
- return m.CluePlans
+ return m.Ciphertext
}
return nil
}
-func (m *TransactionPlan) GetMemoPlan() *MemoPlan {
+func (m *MemoView_Visible) GetPlaintext() *MemoPlaintextView {
if m != nil {
- return m.MemoPlan
+ return m.Plaintext
}
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_Opaque struct {
+ Ciphertext *MemoCiphertext `protobuf:"bytes,1,opt,name=ciphertext,proto3" json:"ciphertext,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_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_8b6c2b29a42813c9, []int{21, 1}
}
-func (m *ActionPlan) XXX_Unmarshal(b []byte) error {
+func (m *MemoView_Opaque) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
-func (m *ActionPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *MemoView_Opaque) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
- return xxx_messageInfo_ActionPlan.Marshal(b, m, deterministic)
+ return xxx_messageInfo_MemoView_Opaque.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
@@ -2644,1108 +2569,1161 @@ 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_Opaque) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MemoView_Opaque.Merge(m, src)
}
-func (m *ActionPlan) XXX_Size() int {
+func (m *MemoView_Opaque) XXX_Size() int {
return m.Size()
}
-func (m *ActionPlan) XXX_DiscardUnknown() {
- xxx_messageInfo_ActionPlan.DiscardUnknown(m)
+func (m *MemoView_Opaque) XXX_DiscardUnknown() {
+ xxx_messageInfo_MemoView_Opaque.DiscardUnknown(m)
}
-var xxx_messageInfo_ActionPlan proto.InternalMessageInfo
+var xxx_messageInfo_MemoView_Opaque proto.InternalMessageInfo
-type isActionPlan_Action interface {
- isActionPlan_Action()
- MarshalTo([]byte) (int, error)
- Size() int
+func (m *MemoView_Opaque) 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"`
-}
-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 ActionPlan_Delegate struct {
- Delegate *v1alpha12.Delegate `protobuf:"bytes,40,opt,name=delegate,proto3,oneof" json:"delegate,omitempty"`
-}
-type ActionPlan_Undelegate struct {
- Undelegate *v1alpha12.Undelegate `protobuf:"bytes,41,opt,name=undelegate,proto3,oneof" json:"undelegate,omitempty"`
-}
-type ActionPlan_UndelegateClaim struct {
- UndelegateClaim *v1alpha12.UndelegateClaimPlan `protobuf:"bytes,42,opt,name=undelegate_claim,json=undelegateClaim,proto3,oneof" json:"undelegate_claim,omitempty"`
+func init() {
+ proto.RegisterType((*Transaction)(nil), "penumbra.core.transaction.v1.Transaction")
+ proto.RegisterType((*TransactionBody)(nil), "penumbra.core.transaction.v1.TransactionBody")
+ proto.RegisterType((*TransactionParameters)(nil), "penumbra.core.transaction.v1.TransactionParameters")
+ proto.RegisterType((*DetectionData)(nil), "penumbra.core.transaction.v1.DetectionData")
+ proto.RegisterType((*Action)(nil), "penumbra.core.transaction.v1.Action")
+ proto.RegisterType((*TransactionPerspective)(nil), "penumbra.core.transaction.v1.TransactionPerspective")
+ proto.RegisterType((*TransactionPerspective_ExtendedMetadataById)(nil), "penumbra.core.transaction.v1.TransactionPerspective.ExtendedMetadataById")
+ proto.RegisterType((*TransactionPerspective_CreationTransactionIdByNullifier)(nil), "penumbra.core.transaction.v1.TransactionPerspective.CreationTransactionIdByNullifier")
+ proto.RegisterType((*TransactionPerspective_NullificationTransactionIdByCommitment)(nil), "penumbra.core.transaction.v1.TransactionPerspective.NullificationTransactionIdByCommitment")
+ proto.RegisterType((*PayloadKeyWithCommitment)(nil), "penumbra.core.transaction.v1.PayloadKeyWithCommitment")
+ proto.RegisterType((*NullifierWithNote)(nil), "penumbra.core.transaction.v1.NullifierWithNote")
+ proto.RegisterType((*TransactionView)(nil), "penumbra.core.transaction.v1.TransactionView")
+ proto.RegisterType((*TransactionBodyView)(nil), "penumbra.core.transaction.v1.TransactionBodyView")
+ proto.RegisterType((*ActionView)(nil), "penumbra.core.transaction.v1.ActionView")
+ proto.RegisterType((*AuthorizationData)(nil), "penumbra.core.transaction.v1.AuthorizationData")
+ proto.RegisterType((*WitnessData)(nil), "penumbra.core.transaction.v1.WitnessData")
+ proto.RegisterType((*TransactionPlan)(nil), "penumbra.core.transaction.v1.TransactionPlan")
+ proto.RegisterType((*DetectionDataPlan)(nil), "penumbra.core.transaction.v1.DetectionDataPlan")
+ proto.RegisterType((*ActionPlan)(nil), "penumbra.core.transaction.v1.ActionPlan")
+ proto.RegisterType((*CluePlan)(nil), "penumbra.core.transaction.v1.CluePlan")
+ proto.RegisterType((*MemoPlan)(nil), "penumbra.core.transaction.v1.MemoPlan")
+ proto.RegisterType((*MemoCiphertext)(nil), "penumbra.core.transaction.v1.MemoCiphertext")
+ proto.RegisterType((*MemoPlaintext)(nil), "penumbra.core.transaction.v1.MemoPlaintext")
+ proto.RegisterType((*MemoPlaintextView)(nil), "penumbra.core.transaction.v1.MemoPlaintextView")
+ proto.RegisterType((*MemoView)(nil), "penumbra.core.transaction.v1.MemoView")
+ proto.RegisterType((*MemoView_Visible)(nil), "penumbra.core.transaction.v1.MemoView.Visible")
+ proto.RegisterType((*MemoView_Opaque)(nil), "penumbra.core.transaction.v1.MemoView.Opaque")
}
-type ActionPlan_DaoSpend struct {
- DaoSpend *v1alpha14.DaoSpend `protobuf:"bytes,50,opt,name=dao_spend,json=daoSpend,proto3,oneof" json:"dao_spend,omitempty"`
+
+func init() {
+ proto.RegisterFile("penumbra/core/transaction/v1/transaction.proto", fileDescriptor_8b6c2b29a42813c9)
+}
+
+var fileDescriptor_8b6c2b29a42813c9 = []byte{
+ // 2654 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5b, 0xcf, 0x6f, 0x1b, 0xc7,
+ 0xf5, 0x27, 0x29, 0x59, 0x3f, 0x1e, 0x45, 0x59, 0x1a, 0x4b, 0xfe, 0x6e, 0x84, 0x40, 0x51, 0x98,
+ 0xc4, 0x51, 0xe2, 0x64, 0x19, 0xca, 0x4a, 0x9c, 0xaf, 0x12, 0x04, 0x15, 0x25, 0x57, 0x54, 0x52,
+ 0xcb, 0xec, 0xca, 0x96, 0x51, 0xd7, 0xe9, 0x76, 0xb9, 0x3b, 0x14, 0xd7, 0xe6, 0xfe, 0xc8, 0xce,
+ 0x90, 0x12, 0x7b, 0xeb, 0x3f, 0x50, 0xf4, 0xd0, 0x02, 0x45, 0x4f, 0x45, 0x0f, 0x0d, 0x50, 0xa0,
+ 0xe8, 0x31, 0x68, 0x0f, 0x45, 0x8f, 0x41, 0x4f, 0x01, 0x8a, 0x02, 0x3d, 0xb6, 0xf6, 0xa1, 0x40,
+ 0x8f, 0xfd, 0x0b, 0x8a, 0x99, 0x9d, 0x5d, 0xee, 0x92, 0x5c, 0x91, 0x94, 0xe4, 0x36, 0x46, 0x75,
+ 0xd2, 0xcc, 0xec, 0xfb, 0x7c, 0xde, 0x9b, 0x99, 0x37, 0x33, 0x6f, 0xde, 0x50, 0x20, 0xbb, 0xd8,
+ 0x6e, 0x5a, 0x55, 0x4f, 0x2b, 0xe8, 0x8e, 0x87, 0x0b, 0xd4, 0xd3, 0x6c, 0xa2, 0xe9, 0xd4, 0x74,
+ 0xec, 0x42, 0xab, 0x18, 0xad, 0xca, 0xae, 0xe7, 0x50, 0x07, 0xbd, 0x18, 0xc8, 0xcb, 0x4c, 0x5e,
+ 0x8e, 0x0a, 0xb4, 0x8a, 0x4b, 0x2f, 0x1c, 0x3a, 0xce, 0x61, 0x03, 0x17, 0xb8, 0x6c, 0xb5, 0x59,
+ 0x2b, 0x68, 0x76, 0xdb, 0x07, 0x2e, 0xe5, 0xe3, 0x8a, 0x34, 0x42, 0x30, 0x65, 0x2a, 0x78, 0x41,
+ 0xc8, 0xac, 0xc6, 0x65, 0x74, 0xc7, 0x72, 0x1d, 0x1b, 0xdb, 0xb4, 0x60, 0xe0, 0x63, 0x26, 0x6b,
+ 0xe0, 0xe3, 0x41, 0x92, 0x35, 0x8c, 0x99, 0x64, 0x0d, 0x63, 0x21, 0xf9, 0x5e, 0x92, 0xe4, 0xa1,
+ 0xd3, 0xc2, 0x9e, 0xad, 0xd9, 0x3a, 0x07, 0x74, 0x6a, 0x83, 0x34, 0x98, 0x55, 0x9d, 0x01, 0xcc,
+ 0xaa, 0x3e, 0x48, 0x92, 0xe8, 0xbc, 0x87, 0x44, 0x0f, 0xfa, 0xf7, 0x61, 0xa2, 0x64, 0xdd, 0xc4,
+ 0x0d, 0x03, 0x1b, 0xaa, 0xeb, 0x38, 0x0d, 0x8e, 0x89, 0x36, 0x08, 0xf4, 0x5b, 0x89, 0x68, 0xaa,
+ 0x3d, 0xe6, 0x9d, 0xe0, 0x05, 0x21, 0xbd, 0x12, 0x97, 0x7e, 0x8c, 0xdb, 0x84, 0x89, 0xb0, 0xbf,
+ 0x42, 0xe2, 0xd5, 0xae, 0xa9, 0x3f, 0xae, 0x6b, 0xa4, 0xce, 0x67, 0x9d, 0x97, 0x84, 0xd4, 0x5a,
+ 0x47, 0xca, 0x6b, 0xbb, 0xd4, 0x29, 0x18, 0x58, 0xd7, 0x6a, 0x37, 0x6e, 0xde, 0x54, 0x6b, 0x96,
+ 0xe1, 0x4f, 0x4a, 0xa7, 0x2e, 0x30, 0xeb, 0x89, 0x18, 0xcf, 0x20, 0x5a, 0x0c, 0xc4, 0x1a, 0x7a,
+ 0x2d, 0xf6, 0x51, 0xd4, 0x1f, 0x3f, 0x1a, 0x8c, 0x5f, 0xfe, 0xef, 0x69, 0xc8, 0xde, 0xed, 0x78,
+ 0x1c, 0xda, 0x84, 0xf1, 0xaa, 0x63, 0xb4, 0xa5, 0xf4, 0x4a, 0x7a, 0x35, 0xbb, 0xf6, 0xb6, 0x7c,
+ 0x92, 0x6f, 0xca, 0x11, 0x60, 0xc9, 0x31, 0xda, 0x0a, 0x87, 0xa2, 0x7d, 0xc8, 0x56, 0x4d, 0xdb,
+ 0x30, 0xed, 0x43, 0x95, 0x98, 0x87, 0x52, 0x86, 0x33, 0xad, 0x45, 0x98, 0xb8, 0x29, 0x72, 0xdc,
+ 0xde, 0x56, 0x51, 0x2e, 0xf9, 0xa0, 0x7d, 0xf3, 0xd0, 0xd6, 0x68, 0xd3, 0xc3, 0x0a, 0x54, 0xc3,
+ 0x16, 0xb4, 0x01, 0x13, 0x9a, 0xad, 0xd7, 0x1d, 0x4f, 0x1a, 0xe3, 0x7c, 0xf9, 0x1e, 0x3e, 0xd6,
+ 0xa7, 0x56, 0x51, 0xbe, 0x8d, 0xbd, 0xc7, 0x0d, 0xac, 0x38, 0x0e, 0x55, 0x04, 0x22, 0xff, 0xe7,
+ 0x0c, 0x5c, 0xee, 0x32, 0x15, 0x7d, 0x04, 0x93, 0x7e, 0x8d, 0x48, 0xe9, 0x95, 0xb1, 0xd5, 0xec,
+ 0xda, 0xab, 0x27, 0x77, 0x75, 0x93, 0x97, 0x94, 0x00, 0x84, 0x1e, 0xc1, 0xd5, 0x88, 0x84, 0xea,
+ 0x6a, 0x9e, 0x66, 0x61, 0x8a, 0x3d, 0x22, 0xfa, 0x7b, 0x63, 0xe8, 0x91, 0xab, 0x84, 0x50, 0x65,
+ 0x91, 0xf6, 0x6b, 0x46, 0x0a, 0xcc, 0x1a, 0x98, 0x62, 0x5f, 0x93, 0xa1, 0x51, 0x4d, 0x1a, 0xe7,
+ 0x3a, 0xae, 0x9f, 0xac, 0x63, 0x3b, 0xc0, 0x6c, 0x6b, 0x54, 0x53, 0x72, 0x46, 0xb4, 0x8a, 0xbe,
+ 0x01, 0xe3, 0x16, 0xb6, 0x1c, 0xe9, 0x12, 0x67, 0x7a, 0xeb, 0x64, 0xa6, 0xdb, 0xd8, 0x72, 0xb6,
+ 0x4c, 0xb7, 0x8e, 0x3d, 0x8a, 0x8f, 0xa9, 0xc2, 0x91, 0xf9, 0x1f, 0xa5, 0x61, 0xb1, 0x6f, 0x37,
+ 0xd0, 0x2b, 0x90, 0xc3, 0xc7, 0xae, 0xe9, 0xb5, 0xd5, 0x3a, 0x36, 0x0f, 0xeb, 0x94, 0x3b, 0xd3,
+ 0xb8, 0x32, 0xe3, 0x37, 0x96, 0x79, 0x1b, 0x7a, 0x01, 0xa6, 0xf4, 0xba, 0x66, 0xda, 0xaa, 0x69,
+ 0xf0, 0x21, 0x9b, 0x56, 0x26, 0x79, 0x7d, 0xd7, 0x40, 0xef, 0xc2, 0x58, 0x0d, 0x63, 0x31, 0xd1,
+ 0xaf, 0x74, 0x99, 0x16, 0xae, 0x51, 0x99, 0x6d, 0x48, 0xad, 0xa2, 0xfc, 0x4d, 0x8c, 0x15, 0x26,
+ 0x9f, 0xdf, 0x87, 0x5c, 0xac, 0xcb, 0xa8, 0x04, 0xd3, 0x35, 0xcb, 0x50, 0xf5, 0x46, 0x13, 0x13,
+ 0x69, 0x9c, 0xcf, 0xf2, 0x6b, 0xc9, 0x6e, 0xc8, 0xd6, 0x5a, 0xab, 0x28, 0x6f, 0x35, 0x9a, 0x58,
+ 0x99, 0xaa, 0x59, 0x06, 0x2b, 0x90, 0xfc, 0xcf, 0xe7, 0x60, 0xc2, 0x9f, 0x7b, 0xb4, 0x03, 0x97,
+ 0x88, 0x8b, 0x6d, 0x43, 0xac, 0x8d, 0x42, 0xa2, 0x61, 0xf1, 0x9d, 0xa6, 0x55, 0x94, 0xf7, 0x19,
+ 0xac, 0x9c, 0x52, 0x7c, 0x3c, 0xfa, 0x18, 0x26, 0x9c, 0x26, 0x75, 0x9b, 0x54, 0xf8, 0xca, 0x3b,
+ 0xc3, 0x33, 0xdd, 0xe1, 0xb8, 0x72, 0x4a, 0x11, 0x0c, 0x68, 0x03, 0xc6, 0xc9, 0x91, 0xe6, 0x8a,
+ 0xc1, 0x7a, 0x35, 0x91, 0x89, 0xed, 0xf3, 0xcc, 0x92, 0x23, 0xcd, 0x2d, 0xa7, 0x14, 0x8e, 0x41,
+ 0x1f, 0x03, 0xb0, 0xbf, 0xaa, 0xde, 0xd0, 0x4c, 0x4b, 0xf8, 0xd4, 0x1b, 0xc3, 0x30, 0x6c, 0x31,
+ 0x40, 0x39, 0xa5, 0x4c, 0x93, 0xa0, 0x82, 0x1e, 0xc1, 0x42, 0x4b, 0x6b, 0x98, 0x86, 0x46, 0x1d,
+ 0x4f, 0x35, 0x70, 0xcd, 0xb4, 0x4d, 0x36, 0x68, 0xd2, 0x1c, 0x67, 0x7d, 0x37, 0xb9, 0x87, 0x7c,
+ 0x7f, 0x6d, 0x15, 0xe5, 0x83, 0x00, 0xbd, 0x1d, 0x82, 0xcb, 0x29, 0xe5, 0x4a, 0xab, 0xb7, 0x19,
+ 0xdd, 0x85, 0x39, 0xb3, 0xaa, 0xab, 0x1e, 0x6e, 0x68, 0x6d, 0xd5, 0xf7, 0x3e, 0x69, 0x9e, 0xeb,
+ 0x59, 0x4d, 0xd4, 0xc3, 0xce, 0x96, 0x56, 0x51, 0xde, 0xad, 0xea, 0x0a, 0x83, 0x95, 0x53, 0xca,
+ 0xac, 0x29, 0xca, 0x62, 0x7a, 0xbf, 0x0f, 0x97, 0x5d, 0xcf, 0x71, 0x1d, 0xa2, 0x35, 0x54, 0xd2,
+ 0xac, 0x5a, 0x26, 0x95, 0xd0, 0x00, 0xe3, 0x23, 0x27, 0x5c, 0xab, 0x28, 0x57, 0x04, 0x7a, 0x9f,
+ 0x83, 0x99, 0x06, 0x37, 0xd6, 0x82, 0x6a, 0x30, 0x1f, 0x6a, 0x38, 0x32, 0x69, 0xdd, 0xf0, 0xb4,
+ 0x23, 0xe9, 0x0a, 0xd7, 0x71, 0x73, 0x44, 0x1d, 0xf7, 0x05, 0xbc, 0x9c, 0x52, 0xe6, 0xdc, 0xae,
+ 0x36, 0xf4, 0x29, 0xcc, 0x76, 0xe6, 0xa2, 0xe5, 0x50, 0x2c, 0x2d, 0x70, 0x25, 0xeb, 0x43, 0x2a,
+ 0x09, 0xa7, 0xe2, 0xc0, 0xa1, 0xb8, 0x9c, 0x52, 0x72, 0xad, 0x68, 0x03, 0xa3, 0x37, 0x70, 0x03,
+ 0x1f, 0x76, 0xe8, 0x17, 0x47, 0xa2, 0xdf, 0x0e, 0xc0, 0x01, 0xbd, 0x11, 0x6d, 0x40, 0x04, 0xae,
+ 0x86, 0xa3, 0x64, 0x60, 0xd7, 0x21, 0x26, 0x15, 0x1e, 0x7a, 0x95, 0xab, 0xf9, 0x60, 0xc4, 0xa1,
+ 0xda, 0xf6, 0x39, 0x02, 0x9f, 0x5d, 0x70, 0xfb, 0xb4, 0xa3, 0x7d, 0xc8, 0xf1, 0x1a, 0xdb, 0x61,
+ 0x1d, 0x17, 0xdb, 0xd2, 0x72, 0xdf, 0x7d, 0xb1, 0x67, 0x35, 0x54, 0x04, 0xe8, 0x8e, 0x8b, 0x99,
+ 0xbb, 0xce, 0xb8, 0x91, 0x3a, 0x3a, 0x80, 0xd9, 0x90, 0x54, 0x6f, 0x38, 0x04, 0x4b, 0x2f, 0xf5,
+ 0x3d, 0x55, 0x13, 0x59, 0xb7, 0x18, 0x88, 0x8d, 0x90, 0x1b, 0x6d, 0x40, 0x2a, 0xcc, 0x87, 0xbc,
+ 0xa1, 0x1f, 0xad, 0x0c, 0xd8, 0x4a, 0xba, 0xa8, 0x63, 0x0e, 0xd4, 0xd5, 0x86, 0x2c, 0x58, 0x0c,
+ 0x15, 0x78, 0xf8, 0x48, 0xf3, 0x0c, 0x31, 0x03, 0xf9, 0xbe, 0x67, 0x5b, 0xa2, 0x12, 0x85, 0x63,
+ 0xf9, 0x08, 0x97, 0x32, 0x52, 0x9a, 0xad, 0x67, 0xb7, 0xf7, 0x13, 0x2a, 0xc3, 0x94, 0x70, 0x01,
+ 0x2c, 0xad, 0x72, 0x0d, 0x6f, 0x0e, 0xde, 0x2f, 0x84, 0x17, 0xb1, 0xe1, 0x09, 0xd1, 0x68, 0x0f,
+ 0xa0, 0x69, 0x87, 0x5c, 0x6f, 0x0c, 0x98, 0xc3, 0x90, 0xeb, 0x5e, 0x88, 0x29, 0xa7, 0x94, 0x08,
+ 0x03, 0xfa, 0x1e, 0xcc, 0x75, 0x6a, 0x62, 0x0c, 0xde, 0xe4, 0xac, 0xc5, 0x51, 0x58, 0x03, 0xdf,
+ 0xbb, 0xdc, 0x8c, 0x37, 0x21, 0x0b, 0x16, 0x74, 0xc7, 0xb2, 0x9a, 0xb6, 0x49, 0xdb, 0x7c, 0x8f,
+ 0x57, 0xfd, 0x13, 0x66, 0x8d, 0xeb, 0xf8, 0xff, 0x21, 0x3d, 0x7d, 0x2b, 0xa0, 0xa8, 0x38, 0x4e,
+ 0x23, 0x38, 0x6b, 0x90, 0xde, 0xd3, 0x8a, 0x5c, 0x58, 0xec, 0x52, 0x27, 0xce, 0xa1, 0x1b, 0x5c,
+ 0xdf, 0xc6, 0x69, 0xf4, 0x85, 0x27, 0xd2, 0x15, 0xbd, 0xb7, 0x99, 0x2d, 0xe6, 0x2e, 0x8d, 0x62,
+ 0x49, 0x4b, 0xeb, 0x23, 0x2d, 0xe6, 0x98, 0x4a, 0xb1, 0x72, 0xd9, 0x62, 0xd6, 0xfb, 0xb4, 0xa3,
+ 0x4f, 0x61, 0xce, 0xd4, 0xc9, 0xda, 0x3b, 0xe1, 0xe2, 0xd0, 0x1a, 0xd2, 0x97, 0x83, 0x0e, 0xed,
+ 0xe0, 0x80, 0x60, 0xc0, 0xfb, 0x21, 0x8e, 0x4d, 0x9a, 0x19, 0x6f, 0x2a, 0x4d, 0xc1, 0x84, 0x7f,
+ 0xe8, 0xe4, 0x7f, 0x92, 0x83, 0xab, 0xd1, 0x10, 0x08, 0x7b, 0xc4, 0x65, 0xf1, 0x47, 0x0b, 0xa3,
+ 0xef, 0xc0, 0x8c, 0xab, 0xb5, 0x1b, 0x8e, 0x66, 0xa8, 0xec, 0x7e, 0x20, 0x82, 0xcc, 0xf7, 0x4e,
+ 0x8e, 0xb3, 0x2a, 0x3e, 0xe2, 0x13, 0xdc, 0x66, 0xea, 0x58, 0x9f, 0x4d, 0x6a, 0x61, 0x9b, 0x2a,
+ 0x59, 0x37, 0xfc, 0x42, 0xd0, 0x03, 0x98, 0xe3, 0x5e, 0xa2, 0xda, 0xcd, 0x46, 0xc3, 0xac, 0x99,
+ 0x7e, 0xd0, 0x39, 0xd6, 0xa7, 0x77, 0x5d, 0xf4, 0x7b, 0x81, 0x3c, 0x63, 0xdf, 0x73, 0x28, 0x56,
+ 0x2e, 0x73, 0xa2, 0xb0, 0x9d, 0xa0, 0x6f, 0xc3, 0x8c, 0x66, 0xb4, 0x4c, 0x1d, 0xab, 0xb6, 0x43,
+ 0x31, 0x91, 0xc6, 0x38, 0xaf, 0x3c, 0x7c, 0x80, 0xc2, 0x69, 0xb3, 0x3e, 0x07, 0x2b, 0x13, 0xb4,
+ 0x03, 0x39, 0xcd, 0x30, 0x3c, 0x4c, 0x88, 0xda, 0x32, 0xf1, 0x51, 0x10, 0x89, 0xe5, 0xbb, 0x38,
+ 0xf9, 0x2d, 0x8a, 0x05, 0xda, 0xbe, 0xec, 0x81, 0x89, 0x8f, 0x94, 0x19, 0xad, 0x53, 0x21, 0xe8,
+ 0x7d, 0x98, 0x30, 0xb0, 0xed, 0x58, 0x44, 0xba, 0xc4, 0x19, 0x56, 0xba, 0x18, 0xfc, 0x6b, 0x2f,
+ 0x0f, 0x57, 0xa9, 0xc6, 0xc2, 0x64, 0x45, 0xc8, 0xa3, 0xdb, 0x30, 0x1b, 0x0d, 0xd6, 0x4d, 0x43,
+ 0x9a, 0xe0, 0xde, 0x70, 0xad, 0x7b, 0xbc, 0xfc, 0x5b, 0x5a, 0x3c, 0x3e, 0xdf, 0x35, 0x94, 0x1c,
+ 0x8d, 0x56, 0xd1, 0x47, 0x30, 0xe1, 0x7a, 0xa6, 0x8e, 0x89, 0xb4, 0xc0, 0x0d, 0xb9, 0x96, 0x64,
+ 0xc8, 0x2d, 0x42, 0x4d, 0x4b, 0xa3, 0xd8, 0xa8, 0x30, 0x71, 0x45, 0xa0, 0x50, 0x0b, 0xe6, 0xf1,
+ 0x31, 0xc5, 0x36, 0x1b, 0x37, 0x4b, 0xd8, 0x2a, 0x2d, 0x73, 0xaa, 0xdd, 0xe1, 0xaf, 0x0d, 0x1d,
+ 0x67, 0x93, 0x6f, 0x09, 0xb6, 0xa0, 0xe3, 0xa5, 0xf6, 0xae, 0xa1, 0xcc, 0xe1, 0xae, 0x56, 0xf4,
+ 0x79, 0x1a, 0x5e, 0xd3, 0x3d, 0xac, 0xf1, 0x41, 0x88, 0x0f, 0x08, 0x51, 0xab, 0xed, 0x8e, 0x3f,
+ 0x49, 0xab, 0xdc, 0x98, 0x7b, 0xa7, 0x32, 0x66, 0x4b, 0x68, 0x88, 0x0d, 0x61, 0xa9, 0x1d, 0x3a,
+ 0x99, 0xf2, 0xb2, 0xde, 0x4f, 0x82, 0x44, 0x44, 0xd0, 0xef, 0xd2, 0x70, 0x5d, 0x58, 0xa3, 0x27,
+ 0x9a, 0xab, 0x87, 0xeb, 0x43, 0x5a, 0xe3, 0xf6, 0x7e, 0xf7, 0x54, 0xf6, 0xee, 0x45, 0xf5, 0x74,
+ 0x19, 0x1d, 0x59, 0x82, 0xaf, 0xdb, 0x89, 0x72, 0x24, 0x2a, 0x88, 0xea, 0x70, 0xb5, 0xaa, 0x51,
+ 0xbd, 0xae, 0xf2, 0xd8, 0xda, 0xdf, 0x60, 0xfd, 0x5b, 0xdb, 0x87, 0xdc, 0xca, 0x81, 0xa7, 0x67,
+ 0x89, 0xa1, 0x59, 0x98, 0xed, 0xef, 0xa1, 0xfc, 0xf6, 0x76, 0xa5, 0xda, 0xdb, 0xb8, 0xf4, 0xd3,
+ 0x34, 0x2c, 0xf4, 0x9b, 0x7a, 0xb4, 0x01, 0x53, 0xdc, 0x07, 0x99, 0xa7, 0xfb, 0xfb, 0xde, 0x4b,
+ 0x49, 0x2e, 0xba, 0xc9, 0x0a, 0xbb, 0x86, 0x32, 0xa9, 0xf9, 0x05, 0xb4, 0xd9, 0xcf, 0x39, 0xfd,
+ 0x7b, 0xca, 0x82, 0xec, 0xe7, 0xa2, 0xe4, 0x20, 0x17, 0x25, 0x6f, 0xda, 0xed, 0x5e, 0x3f, 0x5b,
+ 0xfa, 0x7d, 0x1a, 0x56, 0x06, 0x79, 0x01, 0xda, 0x81, 0xe9, 0x8e, 0xbf, 0xa5, 0x07, 0xdc, 0x3d,
+ 0x88, 0x7f, 0xb7, 0xef, 0xf8, 0x50, 0x07, 0xdb, 0x67, 0x71, 0x67, 0xce, 0xb0, 0xb8, 0x97, 0xfe,
+ 0x98, 0x86, 0x6b, 0xc3, 0xb9, 0x04, 0xda, 0x01, 0x88, 0xf8, 0xa0, 0xdf, 0x87, 0xd7, 0x93, 0xf2,
+ 0x12, 0xfb, 0x94, 0x9d, 0xfa, 0x1d, 0x7f, 0x8a, 0x40, 0xcf, 0xb9, 0x0b, 0xf9, 0xcf, 0xd3, 0x20,
+ 0x25, 0x1d, 0x25, 0xa8, 0x04, 0xd9, 0xc8, 0xc1, 0x24, 0xac, 0x7e, 0x39, 0x61, 0x33, 0xee, 0xb0,
+ 0x28, 0xd0, 0x39, 0x82, 0xba, 0x3a, 0x9e, 0x39, 0x75, 0xc7, 0xf3, 0xbf, 0x48, 0xc3, 0x7c, 0xcf,
+ 0xa9, 0x74, 0x7e, 0xae, 0x51, 0x82, 0x71, 0x76, 0x8c, 0x09, 0x0b, 0x47, 0x3d, 0xc5, 0x38, 0x36,
+ 0xff, 0xaf, 0x74, 0x2c, 0x79, 0xc4, 0x8e, 0x22, 0xb4, 0x07, 0xd3, 0x55, 0xc7, 0x68, 0xf3, 0xf3,
+ 0x4c, 0x18, 0x58, 0x1c, 0x29, 0x53, 0xc6, 0x4f, 0xb7, 0xa9, 0xaa, 0x28, 0x7d, 0xfd, 0x32, 0x66,
+ 0xff, 0xc8, 0xc0, 0x95, 0x3e, 0x26, 0xa3, 0x4f, 0x60, 0x46, 0xf8, 0xa8, 0x7f, 0x94, 0xfb, 0x51,
+ 0xcd, 0xea, 0x30, 0xa9, 0x33, 0xde, 0xe5, 0x6c, 0x67, 0x10, 0x9f, 0xff, 0x14, 0xda, 0x16, 0x4c,
+ 0x5b, 0xd8, 0x72, 0x7c, 0x2f, 0xb8, 0xd4, 0x7f, 0xc1, 0xf6, 0xe6, 0xd1, 0xfc, 0xa9, 0xb7, 0x44,
+ 0x29, 0xff, 0xc5, 0x1c, 0x40, 0x67, 0x80, 0xd0, 0x27, 0xf1, 0x1c, 0xd3, 0x8d, 0x11, 0x73, 0x4c,
+ 0x8c, 0xa3, 0x93, 0x67, 0xda, 0xeb, 0xca, 0x33, 0xad, 0x8f, 0x9a, 0x67, 0x12, 0x74, 0x41, 0xae,
+ 0xe9, 0xa3, 0x58, 0xae, 0x69, 0x75, 0x98, 0x4c, 0x91, 0x60, 0xf0, 0xf3, 0x4d, 0x7b, 0x7d, 0xf2,
+ 0x4d, 0x6f, 0x0f, 0x9d, 0x6f, 0x12, 0x54, 0x17, 0x39, 0xa7, 0xff, 0xc5, 0x9c, 0x93, 0x96, 0x90,
+ 0x73, 0x7a, 0xff, 0x34, 0x39, 0x27, 0xe1, 0x49, 0x17, 0x79, 0xa7, 0x8b, 0xbc, 0x53, 0x57, 0xae,
+ 0xe8, 0x7c, 0xf2, 0x4e, 0x6f, 0x9e, 0x39, 0xef, 0x74, 0x91, 0x17, 0x7a, 0x16, 0x79, 0xa1, 0x7e,
+ 0xd9, 0xbc, 0xeb, 0xe7, 0x98, 0xcd, 0x7b, 0xc6, 0x79, 0xa7, 0x1c, 0x64, 0x23, 0xc1, 0x57, 0xfe,
+ 0x67, 0x19, 0x98, 0xdf, 0x6c, 0xd2, 0xba, 0xe3, 0x99, 0x3f, 0xd0, 0xc2, 0xa0, 0x64, 0x1b, 0xb2,
+ 0xb8, 0x56, 0xc3, 0x3a, 0x55, 0xd9, 0x55, 0x41, 0x84, 0x11, 0xaf, 0x24, 0xde, 0x23, 0x6e, 0x71,
+ 0xd9, 0xb2, 0x46, 0xea, 0x0a, 0xe0, 0xb0, 0x8c, 0xee, 0x41, 0xd6, 0x4f, 0x31, 0x69, 0x4d, 0x5a,
+ 0x0f, 0xb2, 0x4b, 0xeb, 0x83, 0x03, 0x52, 0xee, 0x4e, 0xcc, 0xa8, 0x48, 0x48, 0x4a, 0x82, 0x36,
+ 0x82, 0x6a, 0xb0, 0x10, 0xdf, 0xc5, 0x05, 0xff, 0xd8, 0x19, 0xf8, 0x51, 0x6c, 0x17, 0xe7, 0x7a,
+ 0xf2, 0xbf, 0x4d, 0x43, 0xf6, 0xbe, 0x49, 0x6d, 0x4c, 0x08, 0x1f, 0x94, 0x4e, 0x28, 0x9c, 0x1e,
+ 0x35, 0x14, 0x46, 0x06, 0xfc, 0x1f, 0xa1, 0xdc, 0x5f, 0xc2, 0x6b, 0x8b, 0xea, 0x7a, 0x8e, 0x53,
+ 0x0b, 0x86, 0xe5, 0xad, 0x21, 0x2f, 0x3e, 0x15, 0x06, 0x52, 0x16, 0x49, 0x9f, 0x56, 0x92, 0xff,
+ 0x4b, 0xfc, 0x89, 0xba, 0xd2, 0xd0, 0x6c, 0x54, 0xea, 0x7e, 0xa2, 0x1e, 0x2a, 0xce, 0x66, 0xd0,
+ 0xff, 0xce, 0x33, 0xf5, 0x41, 0x42, 0x8c, 0x5d, 0x18, 0x21, 0xc6, 0xe6, 0xd6, 0x77, 0xc5, 0xd9,
+ 0x1b, 0xb1, 0xa7, 0xea, 0x21, 0x42, 0x6c, 0x4e, 0xe2, 0x3f, 0x52, 0x3f, 0x80, 0xf9, 0x1e, 0x7e,
+ 0x74, 0x0b, 0x40, 0x6f, 0x34, 0xb1, 0xea, 0x36, 0x34, 0x3b, 0x48, 0x26, 0x0e, 0xa0, 0xdd, 0x6a,
+ 0x34, 0x31, 0xa7, 0x9d, 0xd6, 0x45, 0x89, 0xe4, 0xff, 0x10, 0x86, 0xee, 0x9c, 0xf5, 0x8c, 0xa1,
+ 0x3b, 0xe3, 0x38, 0xc7, 0xd0, 0x5d, 0xd0, 0x9d, 0x21, 0x74, 0x17, 0x0c, 0xe7, 0x11, 0xba, 0x0b,
+ 0xaa, 0x8b, 0xd0, 0xfd, 0x22, 0x74, 0x3f, 0x63, 0xe8, 0x2e, 0x3c, 0xe9, 0xeb, 0x10, 0xba, 0x3f,
+ 0xdb, 0xd3, 0xfe, 0xf9, 0xba, 0x19, 0xe8, 0xc9, 0x37, 0x83, 0xf5, 0x51, 0x6f, 0x06, 0x62, 0x8a,
+ 0x7b, 0x6f, 0x07, 0x9f, 0x9d, 0x7c, 0x3b, 0xb8, 0x79, 0x8a, 0xdb, 0x01, 0xd3, 0xf5, 0x7c, 0xbe,
+ 0x4c, 0x57, 0x13, 0x5f, 0xa6, 0xdf, 0x1d, 0x39, 0x96, 0x15, 0x23, 0x7e, 0xf1, 0x3a, 0xfd, 0x9f,
+ 0xb8, 0x85, 0x44, 0x9e, 0x8f, 0x7f, 0x98, 0x86, 0xa9, 0x20, 0xb0, 0x40, 0xef, 0xc3, 0xa4, 0x78,
+ 0xed, 0x14, 0x01, 0xc4, 0xf2, 0xc9, 0x0f, 0xa4, 0x4a, 0x20, 0x8e, 0x16, 0xe0, 0x92, 0x47, 0x30,
+ 0xf6, 0x1f, 0x0d, 0x66, 0x14, 0xbf, 0x82, 0x5e, 0x83, 0x59, 0xd7, 0xc3, 0xba, 0x49, 0xd8, 0x72,
+ 0xa9, 0x9a, 0x94, 0xf0, 0xb3, 0x7f, 0x5c, 0xc9, 0x85, 0xad, 0x25, 0x93, 0x92, 0xfc, 0x21, 0x4c,
+ 0x05, 0x21, 0x13, 0xda, 0x85, 0x69, 0xb7, 0xa1, 0x99, 0x36, 0xc5, 0xc7, 0xc1, 0x73, 0xc6, 0xf5,
+ 0xa1, 0xa2, 0x2d, 0x1f, 0xa2, 0x74, 0xd0, 0x68, 0x0e, 0xc6, 0x1e, 0xe3, 0xb6, 0xb0, 0x88, 0x15,
+ 0xf3, 0xd7, 0x60, 0x36, 0xfe, 0x33, 0x42, 0x66, 0xb7, 0x69, 0xdb, 0x22, 0xc5, 0x3f, 0xa3, 0xf8,
+ 0x95, 0xfc, 0x23, 0xc8, 0xc5, 0x58, 0xd1, 0x2d, 0x98, 0xf5, 0x30, 0x6d, 0x7a, 0xb6, 0x3a, 0xda,
+ 0xf8, 0xe4, 0x7c, 0x94, 0xa8, 0x22, 0x04, 0xe3, 0xbc, 0x5f, 0xfe, 0x6f, 0x0d, 0x79, 0x39, 0xef,
+ 0xc1, 0x7c, 0x4c, 0x17, 0x4f, 0xc1, 0xee, 0x26, 0xe8, 0x1b, 0xe6, 0xc1, 0x7a, 0x08, 0x9d, 0xbf,
+ 0x19, 0xf3, 0x47, 0x9c, 0xeb, 0xfa, 0x18, 0x26, 0x5b, 0x26, 0x31, 0xab, 0x0d, 0x2c, 0x94, 0xc8,
+ 0xc3, 0x25, 0x90, 0xe5, 0x03, 0x1f, 0x55, 0x4e, 0x29, 0x01, 0x01, 0xda, 0x81, 0x09, 0xc7, 0xd5,
+ 0x3e, 0x6b, 0x06, 0xcf, 0x1d, 0x6f, 0x0f, 0x49, 0x75, 0x87, 0x83, 0x78, 0xac, 0xc8, 0x4b, 0x4b,
+ 0xbf, 0x4a, 0xc3, 0xa4, 0xe0, 0x47, 0xdf, 0x02, 0xd0, 0xc3, 0x19, 0x13, 0x36, 0x8e, 0xf6, 0x63,
+ 0xd1, 0x08, 0x1e, 0xdd, 0x8e, 0x3a, 0x58, 0x66, 0x98, 0xcb, 0x41, 0xcf, 0xf4, 0x44, 0x9c, 0x6c,
+ 0xe9, 0x00, 0x26, 0x7c, 0xe3, 0xcf, 0xd7, 0xcc, 0x52, 0x36, 0x92, 0xd8, 0x2f, 0x7d, 0x91, 0xf9,
+ 0xf2, 0xc9, 0x72, 0xfa, 0xab, 0x27, 0xcb, 0xe9, 0xbf, 0x3d, 0x59, 0x4e, 0xff, 0xf8, 0xe9, 0x72,
+ 0xea, 0xab, 0xa7, 0xcb, 0xa9, 0xbf, 0x3e, 0x5d, 0x4e, 0xc1, 0x8a, 0xee, 0x58, 0x27, 0x2a, 0x29,
+ 0xcd, 0x45, 0x2f, 0x50, 0x9e, 0x43, 0x9d, 0x4a, 0xfa, 0xc1, 0xc1, 0xa1, 0x49, 0xeb, 0xcd, 0x2a,
+ 0xdb, 0x4c, 0x0a, 0xba, 0x43, 0x2c, 0x87, 0x14, 0x78, 0x68, 0x8a, 0xbd, 0x42, 0x6b, 0x2d, 0x2c,
+ 0xf2, 0xdf, 0xc2, 0x92, 0xc2, 0x49, 0xff, 0x4a, 0xf0, 0x41, 0xa4, 0xda, 0x2a, 0xfe, 0x32, 0x33,
+ 0x56, 0xd9, 0xba, 0xfb, 0xeb, 0xcc, 0x8b, 0x95, 0xc0, 0xa0, 0x2d, 0x66, 0x50, 0xc4, 0x00, 0xf9,
+ 0xa0, 0xf8, 0xa7, 0xce, 0xe7, 0x87, 0xec, 0xf3, 0xc3, 0xc8, 0xe7, 0x87, 0x07, 0xc5, 0x27, 0x99,
+ 0xd5, 0x93, 0x3e, 0x3f, 0xdc, 0xa9, 0x94, 0x82, 0x47, 0xde, 0x7f, 0x66, 0x5e, 0x0a, 0x44, 0x37,
+ 0x36, 0x98, 0xec, 0xc6, 0x46, 0x44, 0x78, 0x63, 0xe3, 0xa0, 0x58, 0x9d, 0xe0, 0xcf, 0xc4, 0x37,
+ 0xfe, 0x1d, 0x00, 0x00, 0xff, 0xff, 0x5a, 0x3c, 0x6e, 0x70, 0x10, 0x31, 0x00, 0x00,
}
-type ActionPlan_DaoOutput struct {
- DaoOutput *v1alpha14.DaoOutput `protobuf:"bytes,51,opt,name=dao_output,json=daoOutput,proto3,oneof" json:"dao_output,omitempty"`
+
+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 dAtA[:n], nil
}
-type ActionPlan_DaoDeposit struct {
- DaoDeposit *v1alpha14.DaoDeposit `protobuf:"bytes,52,opt,name=dao_deposit,json=daoDeposit,proto3,oneof" json:"dao_deposit,omitempty"`
+
+func (m *Transaction) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
}
-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() {}
-
-func (m *ActionPlan) GetAction() isActionPlan_Action {
- if m != nil {
- return m.Action
+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) GetSpend() *SpendPlan {
- if x, ok := m.GetAction().(*ActionPlan_Spend); ok {
- return x.Spend
+ 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) GetOutput() *OutputPlan {
- if x, ok := m.GetAction().(*ActionPlan_Output); ok {
- return x.Output
+ 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) GetSwap() *v1alpha11.SwapPlan {
- if x, ok := m.GetAction().(*ActionPlan_Swap); ok {
- return x.Swap
+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) GetSwapClaim() *v1alpha11.SwapClaimPlan {
- if x, ok := m.GetAction().(*ActionPlan_SwapClaim); ok {
- return x.SwapClaim
- }
- return nil
+func (m *TransactionBody) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *ActionPlan) GetValidatorDefinition() *v1alpha12.ValidatorDefinition {
- if x, ok := m.GetAction().(*ActionPlan_ValidatorDefinition); ok {
- return x.ValidatorDefinition
+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) GetIbcAction() *v1alpha13.IbcAction {
- if x, ok := m.GetAction().(*ActionPlan_IbcAction); ok {
- return x.IbcAction
+ 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) GetProposalSubmit() *v1alpha14.ProposalSubmit {
- if x, ok := m.GetAction().(*ActionPlan_ProposalSubmit); ok {
- return x.ProposalSubmit
+ 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) GetProposalWithdraw() *v1alpha14.ProposalWithdraw {
- if x, ok := m.GetAction().(*ActionPlan_ProposalWithdraw); ok {
- return x.ProposalWithdraw
+ 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) GetValidatorVote() *v1alpha14.ValidatorVote {
- if x, ok := m.GetAction().(*ActionPlan_ValidatorVote); ok {
- return x.ValidatorVote
+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) GetDelegatorVote() *v1alpha14.DelegatorVotePlan {
- if x, ok := m.GetAction().(*ActionPlan_DelegatorVote); ok {
- return x.DelegatorVote
- }
- return nil
+func (m *TransactionParameters) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *ActionPlan) GetProposalDepositClaim() *v1alpha14.ProposalDepositClaim {
- if x, ok := m.GetAction().(*ActionPlan_ProposalDepositClaim); ok {
- return x.ProposalDepositClaim
+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
-}
-
-func (m *ActionPlan) GetWithdrawal() *v1alpha13.Ics20Withdrawal {
- if x, ok := m.GetAction().(*ActionPlan_Withdrawal); ok {
- return x.Withdrawal
+ 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
}
- return nil
+ if m.ExpiryHeight != 0 {
+ i = encodeVarintTransaction(dAtA, i, uint64(m.ExpiryHeight))
+ i--
+ dAtA[i] = 0x8
+ }
+ return len(dAtA) - i, nil
}
-func (m *ActionPlan) GetPositionOpen() *v1alpha11.PositionOpen {
- if x, ok := m.GetAction().(*ActionPlan_PositionOpen); ok {
- return x.PositionOpen
+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) GetPositionClose() *v1alpha11.PositionClose {
- if x, ok := m.GetAction().(*ActionPlan_PositionClose); ok {
- return x.PositionClose
- }
- return nil
+func (m *DetectionData) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *ActionPlan) GetPositionWithdraw() *v1alpha11.PositionWithdrawPlan {
- if x, ok := m.GetAction().(*ActionPlan_PositionWithdraw); ok {
- return x.PositionWithdraw
+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 nil
+ return len(dAtA) - i, nil
}
-func (m *ActionPlan) GetPositionRewardClaim() *v1alpha11.PositionRewardClaimPlan {
- if x, ok := m.GetAction().(*ActionPlan_PositionRewardClaim); ok {
- return x.PositionRewardClaim
+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 nil
+ return dAtA[:n], nil
}
-func (m *ActionPlan) GetDelegate() *v1alpha12.Delegate {
- if x, ok := m.GetAction().(*ActionPlan_Delegate); ok {
- return x.Delegate
- }
- return nil
+func (m *Action) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *ActionPlan) GetUndelegate() *v1alpha12.Undelegate {
- if x, ok := m.GetAction().(*ActionPlan_Undelegate); ok {
- return x.Undelegate
+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 nil
+ return len(dAtA) - i, nil
}
-func (m *ActionPlan) GetUndelegateClaim() *v1alpha12.UndelegateClaimPlan {
- if x, ok := m.GetAction().(*ActionPlan_UndelegateClaim); ok {
- return x.UndelegateClaim
- }
- return nil
+func (m *Action_Spend) 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 *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 *ActionPlan) GetDaoOutput() *v1alpha14.DaoOutput {
- if x, ok := m.GetAction().(*ActionPlan_DaoOutput); ok {
- return x.DaoOutput
- }
- return nil
+func (m *Action_Output) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *ActionPlan) GetDaoDeposit() *v1alpha14.DaoDeposit {
- if x, ok := m.GetAction().(*ActionPlan_DaoDeposit); ok {
- return x.DaoDeposit
+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 nil
+ return len(dAtA) - i, nil
+}
+func (m *Action_Swap) 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 *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))
+ }
+ i--
+ dAtA[i] = 0x1a
}
+ 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_SwapClaim) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
}
-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 *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_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))
}
- return b[:n], nil
+ i--
+ dAtA[i] = 0x22
}
+ 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)
+func (m *Action_ValidatorDefinition) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
}
-var xxx_messageInfo_CluePlan proto.InternalMessageInfo
-
-func (m *CluePlan) GetAddress() *v1alpha1.Address {
- if m != nil {
- return m.Address
+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 *CluePlan) GetRseed() []byte {
- if m != nil {
- return m.Rseed
- }
- return nil
+func (m *Action_IbcRelayAction) 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_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 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_ProposalSubmit) 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_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 *MemoPlan) XXX_Merge(src proto.Message) {
- xxx_messageInfo_MemoPlan.Merge(m, src)
-}
-func (m *MemoPlan) XXX_Size() int {
- return m.Size()
-}
-func (m *MemoPlan) XXX_DiscardUnknown() {
- xxx_messageInfo_MemoPlan.DiscardUnknown(m)
+func (m *Action_ProposalWithdraw) 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
- }
- return nil
-}
-
-func (m *MemoPlan) GetKey() []byte {
- if m != nil {
- return m.Key
+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 MemoCiphertext struct {
- Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"`
+func (m *Action_ValidatorVote) 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_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 *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_DelegatorVote) 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_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
}
-
-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_ProposalDepositClaim) 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_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))
}
- return b[:n], nil
+ i--
+ dAtA[i] = 0x1
+ i--
+ dAtA[i] = 0xb2
}
+ 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_PositionOpen) 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_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 nil
+ return len(dAtA) - i, nil
+}
+func (m *Action_PositionClose) 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_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 ""
+ 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_PositionWithdraw) 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_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))
}
- return b[:n], nil
+ i--
+ dAtA[i] = 0x2
+ i--
+ dAtA[i] = 0x82
}
+ return len(dAtA) - i, nil
}
-func (m *MemoView) XXX_Merge(src proto.Message) {
- xxx_messageInfo_MemoView.Merge(m, src)
+func (m *Action_PositionRewardClaim) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *MemoView) XXX_Size() int {
- return m.Size()
+
+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 len(dAtA) - i, nil
}
-func (m *MemoView) XXX_DiscardUnknown() {
- xxx_messageInfo_MemoView.DiscardUnknown(m)
+func (m *Action_Delegate) 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
-}
-
-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 *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_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 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_Undelegate) 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_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))
+ }
+ i--
+ dAtA[i] = 0x2
+ i--
+ dAtA[i] = 0xca
}
+ 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_UndelegateClaim) 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_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))
}
- return b[:n], nil
+ i--
+ dAtA[i] = 0x2
+ i--
+ dAtA[i] = 0xd2
}
+ 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)
-}
-
-var xxx_messageInfo_MemoView_Visible proto.InternalMessageInfo
-
-func (m *MemoView_Visible) GetCiphertext() *MemoCiphertext {
- if m != nil {
- return m.Ciphertext
- }
- return 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)
-}
-
-var xxx_messageInfo_SpendPlan proto.InternalMessageInfo
-
-func (m *SpendPlan) GetNote() *v1alpha1.Note {
- if m != nil {
- return m.Note
+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 nil
+ return dAtA[:n], nil
}
-func (m *SpendPlan) GetPosition() uint64 {
- if m != nil {
- return m.Position
- }
- return 0
+func (m *TransactionPerspective) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *SpendPlan) GetRandomizer() []byte {
- if m != nil {
- return m.Randomizer
+func (m *TransactionPerspective) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.BatchSwapOutputData) > 0 {
+ for iNdEx := len(m.BatchSwapOutputData) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.BatchSwapOutputData[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTransaction(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x3
+ i--
+ dAtA[i] = 0xe2
+ }
}
- return nil
-}
-
-func (m *SpendPlan) GetValueBlinding() []byte {
- if m != nil {
- return m.ValueBlinding
+ if len(m.NullificationTransactionIdsByCommitment) > 0 {
+ for iNdEx := len(m.NullificationTransactionIdsByCommitment) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.NullificationTransactionIdsByCommitment[iNdEx].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
-}
-
-func (m *SpendPlan) GetProofBlindingR() []byte {
- if m != nil {
- return m.ProofBlindingR
+ if len(m.CreationTransactionIdsByNullifier) > 0 {
+ for iNdEx := len(m.CreationTransactionIdsByNullifier) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.CreationTransactionIdsByNullifier[iNdEx].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 nil
-}
-
-func (m *SpendPlan) GetProofBlindingS() []byte {
- if m != nil {
- return m.ProofBlindingS
+ if len(m.ExtendedMetadata) > 0 {
+ for iNdEx := len(m.ExtendedMetadata) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.ExtendedMetadata[iNdEx].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 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
+ if len(m.Prices) > 0 {
+ for iNdEx := len(m.Prices) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Prices[iNdEx].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
}
- 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
+ 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
}
- 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 *TransactionPerspective_ExtendedMetadataById) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3755,19 +3733,19 @@ func (m *Transaction) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *Transaction) MarshalTo(dAtA []byte) (int, error) {
+func (m *TransactionPerspective_ExtendedMetadataById) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *Transaction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *TransactionPerspective_ExtendedMetadataById) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
- if m.Anchor != nil {
+ if m.ExtendedMetadata != nil {
{
- size, err := m.Anchor.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.ExtendedMetadata.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -3775,18 +3753,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.AssetId != nil {
{
- size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.AssetId.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -3799,7 +3770,7 @@ func (m *Transaction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
-func (m *Id) Marshal() (dAtA []byte, err error) {
+func (m *TransactionPerspective_CreationTransactionIdByNullifier) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3809,27 +3780,44 @@ func (m *Id) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *Id) MarshalTo(dAtA []byte) (int, error) {
+func (m *TransactionPerspective_CreationTransactionIdByNullifier) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *Id) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *TransactionPerspective_CreationTransactionIdByNullifier) 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.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] = 0x12
+ }
+ 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 *EffectHash) Marshal() (dAtA []byte, err error) {
+func (m *TransactionPerspective_NullificationTransactionIdByCommitment) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3839,27 +3827,44 @@ func (m *EffectHash) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *EffectHash) MarshalTo(dAtA []byte) (int, error) {
+func (m *TransactionPerspective_NullificationTransactionIdByCommitment) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *EffectHash) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *TransactionPerspective_NullificationTransactionIdByCommitment) 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.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] = 0x12
+ }
+ if m.Commitment != nil {
+ {
+ size, err := m.Commitment.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 *PayloadKeyWithCommitment) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3869,43 +3874,19 @@ func (m *TransactionBody) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *TransactionBody) MarshalTo(dAtA []byte) (int, error) {
+func (m *PayloadKeyWithCommitment) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *TransactionBody) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *PayloadKeyWithCommitment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
- if m.MemoData != nil {
- {
- size, err := m.MemoData.MarshalToSizedBuffer(dAtA[:i])
- if err != nil {
- return 0, err
- }
- i -= size
- 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
- }
- if m.Fee != nil {
+ if m.Commitment != nil {
{
- size, err := m.Fee.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.Commitment.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -3913,11 +3894,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.PayloadKey != nil {
{
- size, err := m.TransactionParameters.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.PayloadKey.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -3925,26 +3906,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 *NullifierWithNote) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3954,45 +3921,44 @@ func (m *MemoData) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *MemoData) MarshalTo(dAtA []byte) (int, error) {
+func (m *NullifierWithNote) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *MemoData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *NullifierWithNote) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
- if m.XEncryptedMemo != nil {
+ if m.Note != nil {
{
- size := m.XEncryptedMemo.Size()
- i -= size
- if _, err := m.XEncryptedMemo.MarshalTo(dAtA[i:]); err != 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 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)))
+ 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 *TransactionParameters) 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])
@@ -4002,32 +3968,56 @@ func (m *TransactionParameters) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *TransactionParameters) MarshalTo(dAtA []byte) (int, error) {
+func (m *TransactionView) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *TransactionParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *TransactionView) 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.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 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
}
- if m.ExpiryHeight != 0 {
- i = encodeVarintTransaction(dAtA, i, uint64(m.ExpiryHeight))
+ if m.BodyView != nil {
+ {
+ size, err := m.BodyView.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTransaction(dAtA, i, uint64(size))
+ }
i--
- dAtA[i] = 0x8
+ dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
-func (m *DetectionData) 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])
@@ -4037,20 +4027,56 @@ func (m *DetectionData) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *DetectionData) MarshalTo(dAtA []byte) (int, error) {
+func (m *TransactionBodyView) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *DetectionData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *TransactionBodyView) 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 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
+ }
+ 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
+ }
+ 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
+ }
+ 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 +4084,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 +4100,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 +4122,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 +4143,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 +4164,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 +4185,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 +4206,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 +4229,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 +4252,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 +4275,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 +4298,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 +4321,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 +4344,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 +4367,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 +4390,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 +4413,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 +4436,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 +4459,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 +4478,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 +4501,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 +4524,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 +4551,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 +4574,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 +4597,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 +4620,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,60 +4630,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-- {
- {
- 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
- }
- }
- 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-- {
+ if len(m.DelegatorVoteAuths) > 0 {
+ for iNdEx := len(m.DelegatorVoteAuths) - 1; iNdEx >= 0; iNdEx-- {
{
- size, err := m.AdviceNotes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.DelegatorVoteAuths[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -4668,10 +4654,10 @@ func (m *TransactionPerspective) MarshalToSizedBuffer(dAtA []byte) (int, error)
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 +4668,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 +4693,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 +4742,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 +4762,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 +4774,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 +4788,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 +4815,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,180 +4852,59 @@ 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 {
+ if m.Action != nil {
{
- size := m.XMemoView.Size()
+ size := m.Action.Size()
i -= size
- if _, err := m.XMemoView.MarshalTo(dAtA[i:]); err != nil {
+ if _, err := m.Action.MarshalTo(dAtA[i:]); err != nil {
return 0, err
}
}
}
- if m.XDetectionData != 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 := m.XDetectionData.Size()
- i -= size
- if _, err := m.XDetectionData.MarshalTo(dAtA[i:]); err != 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
}
- if m.Fee != 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.Fee.MarshalToSizedBuffer(dAtA[:i])
- if err != nil {
- return 0, err
- }
- i -= size
- i = encodeVarintTransaction(dAtA, i, uint64(size))
- }
- i--
- dAtA[i] = 0x1a
- }
- 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
- }
- 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) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *TransactionBodyView_DetectionData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- 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 len(dAtA) - i, nil
-}
-func (m *TransactionBodyView_MemoView) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *TransactionBodyView_MemoView) 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])
+ size, err := m.Output.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -5072,12 +4916,12 @@ func (m *ActionView_Output) MarshalToSizedBuffer(dAtA []byte) (int, error) {
}
return len(dAtA) - i, nil
}
-func (m *ActionView_Swap) MarshalTo(dAtA []byte) (int, error) {
+func (m *ActionPlan_Swap) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *ActionView_Swap) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *ActionPlan_Swap) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
if m.Swap != nil {
{
@@ -5093,12 +4937,12 @@ func (m *ActionView_Swap) MarshalToSizedBuffer(dAtA []byte) (int, error) {
}
return len(dAtA) - i, nil
}
-func (m *ActionView_SwapClaim) MarshalTo(dAtA []byte) (int, error) {
+func (m *ActionPlan_SwapClaim) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *ActionView_SwapClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *ActionPlan_SwapClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
if m.SwapClaim != nil {
{
@@ -5114,12 +4958,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 +4981,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 +5004,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 +5027,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 +5050,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 +5073,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 +5096,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 +5119,12 @@ 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_PositionOpen) 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_PositionOpen) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
if m.PositionOpen != nil {
{
@@ -5298,12 +5142,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 +5165,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 +5188,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 +5211,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 +5230,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 +5253,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 +5276,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 +5303,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 +5326,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,12 +5349,12 @@ 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 *ActionPlan_Ics20Withdrawal) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *ActionView_Ics20Withdrawal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *ActionPlan_Ics20Withdrawal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
if m.Ics20Withdrawal != nil {
{
@@ -5528,7 +5372,7 @@ func (m *ActionView_Ics20Withdrawal) MarshalToSizedBuffer(dAtA []byte) (int, err
}
return len(dAtA) - i, nil
}
-func (m *SpendView) Marshal() (dAtA []byte, err error) {
+func (m *CluePlan) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -5538,38 +5382,73 @@ func (m *SpendView) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *SpendView) MarshalTo(dAtA []byte) (int, error) {
+func (m *CluePlan) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *SpendView) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *CluePlan) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
- if m.SpendView != nil {
+ 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 := m.SpendView.Size()
- i -= size
- if _, err := m.SpendView.MarshalTo(dAtA[i:]); err != nil {
+ size, err := m.Address.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 *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
+ }
+ return dAtA[:n], nil
+}
+
+func (m *MemoPlan) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *SpendView_Visible_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *MemoPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
- if m.Visible != nil {
+ _ = 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.Plaintext != nil {
{
- size, err := m.Visible.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.Plaintext.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -5581,28 +5460,8 @@ func (m *SpendView_Visible_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
}
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 = encodeVarintTransaction(dAtA, i, uint64(size))
- }
- i--
- dAtA[i] = 0x12
- }
- return len(dAtA) - i, nil
-}
-func (m *SpendView_Visible) Marshal() (dAtA []byte, err error) {
+func (m *MemoCiphertext) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -5612,44 +5471,27 @@ func (m *SpendView_Visible) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *SpendView_Visible) MarshalTo(dAtA []byte) (int, error) {
+func (m *MemoCiphertext) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *SpendView_Visible) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *MemoCiphertext) 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))
- }
- i--
- dAtA[i] = 0x12
- }
- 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))
- }
+ 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
}
return len(dAtA) - i, nil
}
-func (m *SpendView_Opaque) 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])
@@ -5659,73 +5501,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 *MemoPlaintext) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *SpendView_Opaque) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *MemoPlaintext) 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 = 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] = 0xa
- }
- 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
- }
- }
+ dAtA[i] = 0x12
}
- 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 {
+ if m.ReturnAddress != nil {
{
- size, err := m.Visible.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.ReturnAddress.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -5737,28 +5532,8 @@ func (m *DelegatorVoteView_Visible_) MarshalToSizedBuffer(dAtA []byte) (int, err
}
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 = encodeVarintTransaction(dAtA, i, uint64(size))
- }
- i--
- dAtA[i] = 0x12
- }
- return len(dAtA) - i, nil
-}
-func (m *DelegatorVoteView_Visible) 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])
@@ -5768,66 +5543,26 @@ func (m *DelegatorVoteView_Visible) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *DelegatorVoteView_Visible) MarshalTo(dAtA []byte) (int, error) {
+func (m *MemoPlaintextView) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *DelegatorVoteView_Visible) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *MemoPlaintextView) 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.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] = 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 {
+ if m.ReturnAddress != nil {
{
- size, err := m.DelegatorVote.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.ReturnAddress.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -5840,7 +5575,7 @@ func (m *DelegatorVoteView_Opaque) MarshalToSizedBuffer(dAtA []byte) (int, error
return len(dAtA) - i, nil
}
-func (m *OutputView) 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])
@@ -5850,21 +5585,21 @@ func (m *OutputView) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *OutputView) MarshalTo(dAtA []byte) (int, error) {
+func (m *MemoView) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *OutputView) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *MemoView) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
- if m.OutputView != nil {
+ if m.MemoView != nil {
{
- size := m.OutputView.Size()
+ size := m.MemoView.Size()
i -= size
- if _, err := m.OutputView.MarshalTo(dAtA[i:]); err != nil {
+ if _, err := m.MemoView.MarshalTo(dAtA[i:]); err != nil {
return 0, err
}
}
@@ -5872,12 +5607,12 @@ func (m *OutputView) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
-func (m *OutputView_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 *OutputView_Visible_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *MemoView_Visible_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
if m.Visible != nil {
{
@@ -5893,12 +5628,12 @@ func (m *OutputView_Visible_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
}
return len(dAtA) - i, nil
}
-func (m *OutputView_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 *OutputView_Opaque_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *MemoView_Opaque_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
if m.Opaque != nil {
{
@@ -5914,7 +5649,7 @@ func (m *OutputView_Opaque_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
}
return len(dAtA) - i, nil
}
-func (m *OutputView_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])
@@ -5924,31 +5659,19 @@ func (m *OutputView_Visible) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *OutputView_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 *OutputView_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.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.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
}
@@ -5958,9 +5681,9 @@ func (m *OutputView_Visible) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x12
}
- if m.Output != nil {
+ if m.Ciphertext != nil {
{
- size, err := m.Output.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.Ciphertext.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -5973,7 +5696,7 @@ func (m *OutputView_Visible) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
-func (m *OutputView_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])
@@ -5983,19 +5706,19 @@ func (m *OutputView_Opaque) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *OutputView_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 *OutputView_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.Output != nil {
+ if m.Ciphertext != nil {
{
- size, err := m.Output.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.Ciphertext.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -6008,1548 +5731,937 @@ func (m *OutputView_Opaque) MarshalToSizedBuffer(dAtA []byte) (int, error) {
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
+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 *Spend) 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 *Spend) 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.Proof != nil {
- {
- size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i])
- if err != nil {
- return 0, err
- }
- i -= size
- i = encodeVarintTransaction(dAtA, i, uint64(size))
+ if len(m.Actions) > 0 {
+ for _, e := range m.Actions {
+ l = e.Size()
+ n += 1 + l + sovTransaction(uint64(l))
}
- i--
- dAtA[i] = 0x1a
}
- 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
+ if m.TransactionParameters != nil {
+ l = m.TransactionParameters.Size()
+ n += 1 + l + sovTransaction(uint64(l))
}
- 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.DetectionData != nil {
+ l = m.DetectionData.Size()
+ n += 1 + l + sovTransaction(uint64(l))
}
- 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
+ if m.Memo != nil {
+ l = m.Memo.Size()
+ n += 1 + l + sovTransaction(uint64(l))
}
- return dAtA[:n], nil
-}
-
-func (m *SpendBody) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
+ return n
}
-func (m *SpendBody) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
+func (m *TransactionParameters) Size() (n int) {
+ if m == nil {
+ return 0
+ }
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.ExpiryHeight != 0 {
+ n += 1 + sovTransaction(uint64(m.ExpiryHeight))
}
- 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
+ l = len(m.ChainId)
+ if l > 0 {
+ n += 1 + l + sovTransaction(uint64(l))
}
- 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
+ if m.Fee != nil {
+ l = m.Fee.Size()
+ n += 1 + 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 *DetectionData) 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))
+ 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
+ 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) Size() (n int) {
+ if m == nil {
+ return 0
}
- return dAtA[:n], nil
+ var l int
+ _ = l
+ if m.Action != nil {
+ n += m.Action.Size()
+ }
+ return n
}
-func (m *OutputBody) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
+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 *OutputBody) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
+func (m *Action_Output) 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.Output != nil {
+ l = m.Output.Size()
+ n += 1 + 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_Swap) 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.Swap != nil {
+ l = m.Swap.Size()
+ n += 1 + 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_SwapClaim) Size() (n int) {
+ if m == nil {
+ return 0
}
- return len(dAtA) - i, nil
+ var l int
+ _ = l
+ if m.SwapClaim != nil {
+ l = m.SwapClaim.Size()
+ n += 1 + 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_ValidatorDefinition) Size() (n int) {
+ if m == nil {
+ return 0
}
- return dAtA[:n], nil
+ var l int
+ _ = l
+ if m.ValidatorDefinition != nil {
+ l = m.ValidatorDefinition.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_IbcRelayAction) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.IbcRelayAction != nil {
+ l = m.IbcRelayAction.Size()
+ n += 2 + l + sovTransaction(uint64(l))
+ }
+ return n
}
-
-func (m *AuthorizationData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
+func (m *Action_ProposalSubmit) 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.ProposalSubmit != nil {
+ l = m.ProposalSubmit.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_ProposalWithdraw) 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.ProposalWithdraw != nil {
+ l = m.ProposalWithdraw.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_ValidatorVote) Size() (n int) {
+ if m == nil {
+ return 0
}
- return dAtA[:n], nil
-}
-
-func (m *WitnessData) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *WitnessData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
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.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
+ if m.ValidatorVote != nil {
+ l = m.ValidatorVote.Size()
+ n += 2 + l + sovTransaction(uint64(l))
}
- return len(dAtA) - i, nil
+ 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_DelegatorVote) Size() (n int) {
+ if m == nil {
+ return 0
}
- return dAtA[:n], nil
-}
-
-func (m *TransactionPlan) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *TransactionPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
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))
- }
- 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 m.DelegatorVote != nil {
+ l = m.DelegatorVote.Size()
+ n += 2 + 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))
- }
- i--
- dAtA[i] = 0x22
+ return n
+}
+func (m *Action_ProposalDepositClaim) Size() (n int) {
+ if m == nil {
+ return 0
}
- 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
+ var l int
+ _ = l
+ if m.ProposalDepositClaim != nil {
+ l = m.ProposalDepositClaim.Size()
+ n += 2 + l + sovTransaction(uint64(l))
}
- if m.ExpiryHeight != 0 {
- i = encodeVarintTransaction(dAtA, i, uint64(m.ExpiryHeight))
- i--
- dAtA[i] = 0x10
+ return n
+}
+func (m *Action_PositionOpen) Size() (n int) {
+ if m == nil {
+ return 0
}
- 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
- }
+ var l int
+ _ = l
+ if m.PositionOpen != nil {
+ l = m.PositionOpen.Size()
+ n += 2 + l + sovTransaction(uint64(l))
}
- return len(dAtA) - i, nil
+ 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 *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 *ActionPlan) 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 *ActionPlan) 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 m.Action != nil {
- {
- size := m.Action.Size()
- i -= size
- if _, err := m.Action.MarshalTo(dAtA[i:]); err != nil {
- return 0, err
- }
- }
+ if m.PositionRewardClaim != nil {
+ l = m.PositionRewardClaim.Size()
+ n += 2 + l + sovTransaction(uint64(l))
}
- return len(dAtA) - i, nil
+ return n
}
-
-func (m *ActionPlan_Spend) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
+func (m *Action_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_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
+func (m *Action_Undelegate) Size() (n int) {
+ if m == nil {
+ return 0
}
- return len(dAtA) - i, nil
+ var l int
+ _ = l
+ if m.Undelegate != nil {
+ l = m.Undelegate.Size()
+ n += 2 + l + sovTransaction(uint64(l))
+ }
+ return n
}
-func (m *ActionPlan_Output) 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 *ActionPlan_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
+func (m *Action_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_Swap) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
+func (m *Action_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_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
+func (m *Action_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_SwapClaim) 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 *ActionPlan_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))
+func (m *TransactionPerspective) 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))
}
- i--
- dAtA[i] = 0x22
}
- return len(dAtA) - i, nil
-}
-func (m *ActionPlan_ValidatorDefinition) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ActionPlan_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))
+ if len(m.SpendNullifiers) > 0 {
+ for _, e := range m.SpendNullifiers {
+ l = e.Size()
+ n += 1 + l + sovTransaction(uint64(l))
}
- i--
- dAtA[i] = 0x1
- i--
- dAtA[i] = 0x82
}
- return len(dAtA) - i, nil
-}
-func (m *ActionPlan_IbcAction) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-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))
+ if len(m.AdviceNotes) > 0 {
+ for _, e := range m.AdviceNotes {
+ l = e.Size()
+ n += 1 + l + sovTransaction(uint64(l))
}
- i--
- dAtA[i] = 0x1
- i--
- dAtA[i] = 0x8a
}
- return len(dAtA) - i, nil
-}
-func (m *ActionPlan_ProposalSubmit) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ActionPlan_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))
+ if len(m.AddressViews) > 0 {
+ for _, e := range m.AddressViews {
+ l = e.Size()
+ n += 1 + l + sovTransaction(uint64(l))
}
- i--
- dAtA[i] = 0x1
- i--
- dAtA[i] = 0x92
}
- return len(dAtA) - i, nil
-}
-func (m *ActionPlan_ProposalWithdraw) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ActionPlan_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))
+ if len(m.Denoms) > 0 {
+ for _, e := range m.Denoms {
+ l = e.Size()
+ n += 1 + l + sovTransaction(uint64(l))
}
- i--
- dAtA[i] = 0x1
- i--
- dAtA[i] = 0x9a
}
- return len(dAtA) - i, nil
-}
-func (m *ActionPlan_ValidatorVote) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ActionPlan_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))
+ if m.TransactionId != nil {
+ l = m.TransactionId.Size()
+ n += 1 + l + sovTransaction(uint64(l))
+ }
+ if len(m.Prices) > 0 {
+ for _, e := range m.Prices {
+ l = e.Size()
+ n += 2 + l + sovTransaction(uint64(l))
}
- i--
- dAtA[i] = 0x1
- i--
- dAtA[i] = 0xa2
}
- return len(dAtA) - i, nil
-}
-func (m *ActionPlan_DelegatorVote) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ActionPlan_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))
+ if len(m.ExtendedMetadata) > 0 {
+ for _, e := range m.ExtendedMetadata {
+ l = e.Size()
+ n += 2 + l + sovTransaction(uint64(l))
}
- i--
- dAtA[i] = 0x1
- i--
- dAtA[i] = 0xaa
}
- return len(dAtA) - i, nil
-}
-func (m *ActionPlan_ProposalDepositClaim) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ActionPlan_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))
+ if len(m.CreationTransactionIdsByNullifier) > 0 {
+ for _, e := range m.CreationTransactionIdsByNullifier {
+ l = e.Size()
+ n += 2 + l + sovTransaction(uint64(l))
}
- i--
- dAtA[i] = 0x1
- i--
- dAtA[i] = 0xb2
}
- return len(dAtA) - i, nil
-}
-func (m *ActionPlan_Withdrawal) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-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))
+ if len(m.NullificationTransactionIdsByCommitment) > 0 {
+ for _, e := range m.NullificationTransactionIdsByCommitment {
+ l = e.Size()
+ n += 2 + l + sovTransaction(uint64(l))
}
- 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 {
- {
- size, err := m.PositionOpen.MarshalToSizedBuffer(dAtA[:i])
- if err != nil {
- return 0, err
- }
- i -= size
- i = encodeVarintTransaction(dAtA, i, uint64(size))
+ if len(m.BatchSwapOutputData) > 0 {
+ for _, e := range m.BatchSwapOutputData {
+ l = e.Size()
+ n += 2 + l + sovTransaction(uint64(l))
}
- 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])
+ return n
}
-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 *TransactionPerspective_ExtendedMetadataById) 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])
+ var l int
+ _ = l
+ if m.AssetId != nil {
+ l = m.AssetId.Size()
+ n += 1 + l + sovTransaction(uint64(l))
+ }
+ if m.ExtendedMetadata != nil {
+ l = m.ExtendedMetadata.Size()
+ n += 1 + l + sovTransaction(uint64(l))
+ }
+ return n
}
-func (m *ActionPlan_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
+func (m *TransactionPerspective_CreationTransactionIdByNullifier) Size() (n int) {
+ if m == nil {
+ return 0
}
- return len(dAtA) - i, nil
-}
-func (m *ActionPlan_PositionRewardClaim) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
+ var l int
+ _ = l
+ if m.Nullifier != nil {
+ l = m.Nullifier.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 *ActionPlan_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
+func (m *TransactionPerspective_NullificationTransactionIdByCommitment) Size() (n int) {
+ if m == nil {
+ return 0
}
- return len(dAtA) - i, nil
-}
-func (m *ActionPlan_Delegate) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
+ var l int
+ _ = l
+ if m.Commitment != nil {
+ l = m.Commitment.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 *ActionPlan_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
+func (m *PayloadKeyWithCommitment) Size() (n int) {
+ if m == nil {
+ return 0
}
- return len(dAtA) - i, nil
-}
-func (m *ActionPlan_Undelegate) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
+ 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_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))
- }
- i--
- dAtA[i] = 0x2
- i--
- dAtA[i] = 0xca
+func (m *NullifierWithNote) Size() (n int) {
+ if m == nil {
+ return 0
}
- return len(dAtA) - i, nil
-}
-func (m *ActionPlan_UndelegateClaim) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
+ 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_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
+func (m *TransactionView) Size() (n int) {
+ if m == nil {
+ return 0
}
- return len(dAtA) - i, nil
-}
-func (m *ActionPlan_DaoSpend) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-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
+ var l int
+ _ = l
+ if m.BodyView != nil {
+ l = m.BodyView.Size()
+ n += 1 + l + sovTransaction(uint64(l))
}
- return len(dAtA) - i, nil
-}
-func (m *ActionPlan_DaoOutput) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-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
+ if m.BindingSig != nil {
+ l = m.BindingSig.Size()
+ n += 1 + l + sovTransaction(uint64(l))
}
- return len(dAtA) - i, nil
-}
-func (m *ActionPlan_DaoDeposit) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
+ if m.Anchor != nil {
+ l = m.Anchor.Size()
+ n += 1 + 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))
+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))
}
- 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
+ if m.TransactionParameters != nil {
+ l = m.TransactionParameters.Size()
+ n += 1 + l + sovTransaction(uint64(l))
}
- return dAtA[:n], nil
+ 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 *CluePlan) 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 *CluePlan) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
+func (m *ActionView_Spend) Size() (n int) {
+ if m == nil {
+ return 0
+ }
var l int
_ = l
- if m.PrecisionBits != 0 {
- i = encodeVarintTransaction(dAtA, i, uint64(m.PrecisionBits))
- i--
- dAtA[i] = 0x18
+ if m.Spend != nil {
+ l = m.Spend.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
+ return n
+}
+func (m *ActionView_Output) Size() (n int) {
+ if m == nil {
+ return 0
}
- 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))
- }
- i--
- dAtA[i] = 0xa
+ var l int
+ _ = l
+ if m.Output != nil {
+ l = m.Output.Size()
+ n += 1 + l + sovTransaction(uint64(l))
}
- 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 *ActionView_Swap) 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.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] = 0xa
+ if m.Swap != nil {
+ l = m.Swap.Size()
+ n += 1 + l + sovTransaction(uint64(l))
}
- 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 *ActionView_SwapClaim) 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 m.SwapClaim != nil {
+ l = m.SwapClaim.Size()
+ n += 1 + l + sovTransaction(uint64(l))
}
- return len(dAtA) - i, nil
+ return n
}
-
-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
+func (m *ActionView_ValidatorDefinition) Size() (n int) {
+ if m == nil {
+ return 0
}
- return dAtA[:n], nil
-}
-
-func (m *MemoPlaintext) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *MemoPlaintext) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
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))
- }
- i--
- dAtA[i] = 0xa
+ if m.ValidatorDefinition != nil {
+ l = m.ValidatorDefinition.Size()
+ n += 2 + l + sovTransaction(uint64(l))
}
- 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 *ActionView_IbcRelayAction) 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.IbcRelayAction != nil {
+ l = m.IbcRelayAction.Size()
+ n += 2 + l + sovTransaction(uint64(l))
}
- 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 *ActionView_ProposalSubmit) Size() (n int) {
+ if m == nil {
+ return 0
}
- return len(dAtA) - i, 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)
- 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
+ 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 *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 *ActionView_ProposalWithdraw) 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.ProposalWithdraw != nil {
+ l = m.ProposalWithdraw.Size()
+ n += 2 + 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 *ActionView_ValidatorVote) 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.ValidatorVote != nil {
+ l = m.ValidatorVote.Size()
+ n += 2 + 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 *ActionView_DelegatorVote) Size() (n int) {
+ if m == nil {
+ return 0
}
- return dAtA[:n], nil
+ var l int
+ _ = l
+ if m.DelegatorVote != nil {
+ l = m.DelegatorVote.Size()
+ n += 2 + l + sovTransaction(uint64(l))
+ }
+ return n
}
-
-func (m *SpendPlan) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
+func (m *ActionView_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 *SpendPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
+func (m *ActionView_PositionOpen) Size() (n int) {
+ if m == nil {
+ return 0
+ }
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 m.PositionOpen != nil {
+ l = m.PositionOpen.Size()
+ n += 2 + l + sovTransaction(uint64(l))
}
- 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
+ return n
+}
+func (m *ActionView_PositionClose) Size() (n int) {
+ if m == nil {
+ return 0
}
- 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
+ var l int
+ _ = l
+ if m.PositionClose != nil {
+ l = m.PositionClose.Size()
+ n += 2 + l + sovTransaction(uint64(l))
}
- 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
+ return n
+}
+func (m *ActionView_PositionWithdraw) Size() (n int) {
+ if m == nil {
+ return 0
}
- if m.Position != 0 {
- i = encodeVarintTransaction(dAtA, i, uint64(m.Position))
- i--
- dAtA[i] = 0x10
+ var l int
+ _ = l
+ if m.PositionWithdraw != nil {
+ l = m.PositionWithdraw.Size()
+ n += 2 + 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] = 0xa
- }
- 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 *ActionView_PositionRewardClaim) 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.PositionRewardClaim != nil {
+ l = m.PositionRewardClaim.Size()
+ n += 2 + l + sovTransaction(uint64(l))
}
- dAtA[offset] = uint8(v)
- return base
+ return n
}
-func (m *Transaction) Size() (n int) {
+func (m *ActionView_Delegate) 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.Delegate != nil {
+ l = m.Delegate.Size()
+ n += 2 + l + sovTransaction(uint64(l))
}
- l = len(m.BindingSig)
- if l > 0 {
- n += 1 + l + sovTransaction(uint64(l))
+ return n
+}
+func (m *ActionView_Undelegate) Size() (n int) {
+ if m == nil {
+ return 0
}
- if m.Anchor != nil {
- l = m.Anchor.Size()
- n += 1 + l + sovTransaction(uint64(l))
+ var l int
+ _ = l
+ if m.Undelegate != nil {
+ l = m.Undelegate.Size()
+ n += 2 + l + sovTransaction(uint64(l))
}
return n
}
-
-func (m *Id) Size() (n int) {
+func (m *ActionView_UndelegateClaim) 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.UndelegateClaim != nil {
+ l = m.UndelegateClaim.Size()
+ n += 2 + l + sovTransaction(uint64(l))
}
return n
}
-
-func (m *EffectHash) Size() (n int) {
+func (m *ActionView_CommunityPoolSpend) 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.CommunityPoolSpend != nil {
+ l = m.CommunityPoolSpend.Size()
+ n += 2 + l + sovTransaction(uint64(l))
}
return n
}
-
-func (m *TransactionBody) Size() (n int) {
+func (m *ActionView_CommunityPoolOutput) 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.CommunityPoolOutput != nil {
+ l = m.CommunityPoolOutput.Size()
+ n += 2 + l + sovTransaction(uint64(l))
}
- if m.TransactionParameters != nil {
- l = m.TransactionParameters.Size()
- n += 1 + l + sovTransaction(uint64(l))
+ return n
+}
+func (m *ActionView_CommunityPoolDeposit) Size() (n int) {
+ if m == nil {
+ return 0
}
- if m.Fee != nil {
- l = m.Fee.Size()
- n += 1 + l + sovTransaction(uint64(l))
+ var l int
+ _ = l
+ if m.CommunityPoolDeposit != nil {
+ l = m.CommunityPoolDeposit.Size()
+ n += 2 + l + sovTransaction(uint64(l))
}
- if m.DetectionData != nil {
- l = m.DetectionData.Size()
- n += 1 + l + sovTransaction(uint64(l))
+ return n
+}
+func (m *ActionView_Ics20Withdrawal) Size() (n int) {
+ if m == nil {
+ return 0
}
- if m.MemoData != nil {
- l = m.MemoData.Size()
- n += 1 + l + sovTransaction(uint64(l))
+ var l int
+ _ = l
+ if m.Ics20Withdrawal != nil {
+ l = m.Ics20Withdrawal.Size()
+ n += 2 + l + sovTransaction(uint64(l))
}
return n
}
-
-func (m *MemoData) Size() (n int) {
+func (m *AuthorizationData) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.XEncryptedMemo != nil {
- n += m.XEncryptedMemo.Size()
+ 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 *MemoData_EncryptedMemo) Size() (n int) {
+func (m *WitnessData) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.EncryptedMemo != nil {
- l = len(m.EncryptedMemo)
+ 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 *TransactionParameters) Size() (n int) {
+
+func (m *TransactionPlan) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.ExpiryHeight != 0 {
- n += 1 + sovTransaction(uint64(m.ExpiryHeight))
+ if len(m.Actions) > 0 {
+ for _, e := range m.Actions {
+ l = e.Size()
+ n += 1 + l + sovTransaction(uint64(l))
+ }
}
- l = len(m.ChainId)
- if l > 0 {
+ 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 *DetectionData) Size() (n int) {
+func (m *DetectionDataPlan) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if len(m.FmdClues) > 0 {
- for _, e := range m.FmdClues {
+ if len(m.CluePlans) > 0 {
+ for _, e := range m.CluePlans {
l = e.Size()
n += 1 + l + sovTransaction(uint64(l))
}
@@ -7557,7 +6669,7 @@ func (m *DetectionData) Size() (n int) {
return n
}
-func (m *Action) Size() (n int) {
+func (m *ActionPlan) Size() (n int) {
if m == nil {
return 0
}
@@ -7569,7 +6681,7 @@ func (m *Action) Size() (n int) {
return n
}
-func (m *Action_Spend) Size() (n int) {
+func (m *ActionPlan_Spend) Size() (n int) {
if m == nil {
return 0
}
@@ -7581,7 +6693,7 @@ func (m *Action_Spend) Size() (n int) {
}
return n
}
-func (m *Action_Output) Size() (n int) {
+func (m *ActionPlan_Output) Size() (n int) {
if m == nil {
return 0
}
@@ -7593,7 +6705,7 @@ func (m *Action_Output) Size() (n int) {
}
return n
}
-func (m *Action_Swap) Size() (n int) {
+func (m *ActionPlan_Swap) Size() (n int) {
if m == nil {
return 0
}
@@ -7605,7 +6717,7 @@ func (m *Action_Swap) Size() (n int) {
}
return n
}
-func (m *Action_SwapClaim) Size() (n int) {
+func (m *ActionPlan_SwapClaim) Size() (n int) {
if m == nil {
return 0
}
@@ -7617,7 +6729,7 @@ func (m *Action_SwapClaim) Size() (n int) {
}
return n
}
-func (m *Action_ValidatorDefinition) Size() (n int) {
+func (m *ActionPlan_ValidatorDefinition) Size() (n int) {
if m == nil {
return 0
}
@@ -7629,19 +6741,19 @@ func (m *Action_ValidatorDefinition) Size() (n int) {
}
return n
}
-func (m *Action_IbcAction) Size() (n int) {
+func (m *ActionPlan_IbcRelayAction) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.IbcAction != nil {
- l = m.IbcAction.Size()
+ if m.IbcRelayAction != nil {
+ l = m.IbcRelayAction.Size()
n += 2 + l + sovTransaction(uint64(l))
}
return n
}
-func (m *Action_ProposalSubmit) Size() (n int) {
+func (m *ActionPlan_ProposalSubmit) Size() (n int) {
if m == nil {
return 0
}
@@ -7653,7 +6765,7 @@ func (m *Action_ProposalSubmit) Size() (n int) {
}
return n
}
-func (m *Action_ProposalWithdraw) Size() (n int) {
+func (m *ActionPlan_ProposalWithdraw) Size() (n int) {
if m == nil {
return 0
}
@@ -7665,7 +6777,7 @@ func (m *Action_ProposalWithdraw) Size() (n int) {
}
return n
}
-func (m *Action_ValidatorVote) Size() (n int) {
+func (m *ActionPlan_ValidatorVote) Size() (n int) {
if m == nil {
return 0
}
@@ -7677,7 +6789,7 @@ func (m *Action_ValidatorVote) Size() (n int) {
}
return n
}
-func (m *Action_DelegatorVote) Size() (n int) {
+func (m *ActionPlan_DelegatorVote) Size() (n int) {
if m == nil {
return 0
}
@@ -7689,7 +6801,7 @@ func (m *Action_DelegatorVote) Size() (n int) {
}
return n
}
-func (m *Action_ProposalDepositClaim) Size() (n int) {
+func (m *ActionPlan_ProposalDepositClaim) Size() (n int) {
if m == nil {
return 0
}
@@ -7701,7 +6813,7 @@ func (m *Action_ProposalDepositClaim) Size() (n int) {
}
return n
}
-func (m *Action_PositionOpen) Size() (n int) {
+func (m *ActionPlan_PositionOpen) Size() (n int) {
if m == nil {
return 0
}
@@ -7713,7 +6825,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 +6837,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 +6849,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 +6861,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 +6873,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 +6885,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,43 +6897,43 @@ 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 *ActionPlan_Ics20Withdrawal) Size() (n int) {
if m == nil {
return 0
}
@@ -7833,2634 +6945,194 @@ func (m *Action_Ics20Withdrawal) Size() (n int) {
}
return n
}
-func (m *TransactionPerspective) Size() (n int) {
+func (m *CluePlan) 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 m.Address != nil {
+ l = m.Address.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 len(m.AdviceNotes) > 0 {
- for _, e := range m.AdviceNotes {
- l = e.Size()
- 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
- }
- var l int
- _ = l
- l = len(m.Inner)
+ 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 *PayloadKeyWithCommitment) Size() (n int) {
+func (m *MemoPlan) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.PayloadKey != nil {
- l = m.PayloadKey.Size()
+ if m.Plaintext != nil {
+ l = m.Plaintext.Size()
n += 1 + l + sovTransaction(uint64(l))
}
- if m.Commitment != nil {
- l = m.Commitment.Size()
+ l = len(m.Key)
+ if l > 0 {
n += 1 + l + sovTransaction(uint64(l))
}
return n
}
-func (m *NullifierWithNote) Size() (n int) {
+func (m *MemoCiphertext) 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()
+ l = len(m.Inner)
+ if l > 0 {
n += 1 + l + sovTransaction(uint64(l))
}
return n
}
-func (m *TransactionView) Size() (n int) {
+func (m *MemoPlaintext) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.BodyView != nil {
- l = m.BodyView.Size()
+ if m.ReturnAddress != nil {
+ l = m.ReturnAddress.Size()
n += 1 + l + sovTransaction(uint64(l))
}
- l = len(m.BindingSig)
+ l = len(m.Text)
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) {
+func (m *MemoPlaintextView) 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()
+ if m.ReturnAddress != nil {
+ l = m.ReturnAddress.Size()
n += 1 + l + sovTransaction(uint64(l))
}
- if m.Fee != nil {
- l = m.Fee.Size()
+ l = len(m.Text)
+ if l > 0 {
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) {
+func (m *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()
+ n += m.MemoView.Size()
}
return n
}
-func (m *ActionView_Spend) Size() (n int) {
+func (m *MemoView_Visible_) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.Spend != nil {
- l = m.Spend.Size()
+ if m.Visible != nil {
+ l = m.Visible.Size()
n += 1 + l + sovTransaction(uint64(l))
}
return n
}
-func (m *ActionView_Output) Size() (n int) {
+func (m *MemoView_Opaque_) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.Output != nil {
- l = m.Output.Size()
+ if m.Opaque != nil {
+ l = m.Opaque.Size()
n += 1 + l + sovTransaction(uint64(l))
}
return n
}
-func (m *ActionView_Swap) Size() (n int) {
+func (m *MemoView_Visible) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.Swap != nil {
- l = m.Swap.Size()
+ if m.Ciphertext != nil {
+ l = m.Ciphertext.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()
+ if m.Plaintext != nil {
+ l = m.Plaintext.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) {
- 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) {
+
+func (m *MemoView_Opaque) 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))
+ if m.Ciphertext != nil {
+ l = m.Ciphertext.Size()
+ n += 1 + 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 sovTransaction(x uint64) (n int) {
+ return (math_bits.Len64(x|1) + 6) / 7
}
-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 sozTransaction(x uint64) (n int) {
+ return sovTransaction(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
-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
+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 postIndex > l {
+ if iNdEx >= l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha11.PositionWithdraw{}
- 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 = &Action_PositionWithdraw{v}
- iNdEx = postIndex
- case 34:
+ }
+ 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 PositionRewardClaim", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -10487,15 +7159,16 @@ func (m *Action) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha11.PositionRewardClaim{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if m.Body == nil {
+ m.Body = &TransactionBody{}
+ }
+ if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.Action = &Action_PositionRewardClaim{v}
iNdEx = postIndex
- case 40:
+ case 2:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Delegate", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field BindingSig", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -10522,15 +7195,16 @@ func (m *Action) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha12.Delegate{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if m.BindingSig == nil {
+ m.BindingSig = &v1.BindingSignature{}
+ }
+ if err := m.BindingSig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.Action = &Action_Delegate{v}
iNdEx = postIndex
- case 41:
+ case 3:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Undelegate", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Anchor", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -10557,50 +7231,66 @@ func (m *Action) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha12.Undelegate{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if m.Anchor == nil {
+ m.Anchor = &v11.MerkleRoot{}
+ }
+ if err := m.Anchor.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
- }
+ 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 *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
}
- v := &v1alpha12.UndelegateClaim{}
- 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 = &Action_UndelegateClaim{v}
- iNdEx = postIndex
- case 50:
+ }
+ 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 DaoSpend", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Actions", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -10627,15 +7317,14 @@ func (m *Action) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha14.DaoSpend{}
- if err := v.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
}
- m.Action = &Action_DaoSpend{v}
iNdEx = postIndex
- case 51:
+ case 2:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field DaoOutput", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field TransactionParameters", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -10662,15 +7351,16 @@ func (m *Action) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha14.DaoOutput{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if m.TransactionParameters == nil {
+ m.TransactionParameters = &TransactionParameters{}
+ }
+ if err := m.TransactionParameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.Action = &Action_DaoOutput{v}
iNdEx = postIndex
- case 52:
+ case 4:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field DaoDeposit", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field DetectionData", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -10697,15 +7387,16 @@ func (m *Action) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha14.DaoDeposit{}
- 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.Action = &Action_DaoDeposit{v}
iNdEx = postIndex
- case 200:
+ case 5:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Ics20Withdrawal", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Memo", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -10732,11 +7423,12 @@ func (m *Action) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha13.Ics20Withdrawal{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if m.Memo == nil {
+ m.Memo = &MemoCiphertext{}
+ }
+ if err := m.Memo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.Action = &Action_Ics20Withdrawal{v}
iNdEx = postIndex
default:
iNdEx = preIndex
@@ -10759,142 +7451,40 @@ func (m *Action) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *TransactionPerspective) Unmarshal(dAtA []byte) error {
+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: 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 shift >= 64 {
+ return ErrIntOverflowTransaction
}
- if postIndex > l {
+ if iNdEx >= 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
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
}
- iNdEx = postIndex
- case 4:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field AddressViews", wireType)
+ }
+ 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)
}
- var msglen int
+ m.ExpiryHeight = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTransaction
@@ -10904,31 +7494,16 @@ func (m *TransactionPerspective) 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.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:
+ case 2:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Denoms", 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
@@ -10938,29 +7513,27 @@ func (m *TransactionPerspective) 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
}
- m.Denoms = append(m.Denoms, &v1alpha1.DenomMetadata{})
- if err := m.Denoms[len(m.Denoms)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
- }
+ m.ChainId = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
- case 6:
+ case 3:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -10987,10 +7560,10 @@ func (m *TransactionPerspective) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.TransactionId == nil {
- m.TransactionId = &Id{}
+ if m.Fee == nil {
+ m.Fee = &v12.Fee{}
}
- if err := m.TransactionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.Fee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@@ -11015,7 +7588,7 @@ func (m *TransactionPerspective) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *PayloadKey) Unmarshal(dAtA []byte) error {
+func (m *DetectionData) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -11038,17 +7611,17 @@ func (m *PayloadKey) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: PayloadKey: wiretype end group for non-group")
+ return fmt.Errorf("proto: DetectionData: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: PayloadKey: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: DetectionData: 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 Inner", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field FmdClues", wireType)
}
- var byteLen int
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTransaction
@@ -11058,24 +7631,24 @@ func (m *PayloadKey) 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{}
+ m.FmdClues = append(m.FmdClues, &v13.Clue{})
+ if err := m.FmdClues[len(m.FmdClues)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
}
iNdEx = postIndex
default:
@@ -11099,7 +7672,7 @@ func (m *PayloadKey) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *PayloadKeyWithCommitment) Unmarshal(dAtA []byte) error {
+func (m *Action) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -11122,15 +7695,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: Action: 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: 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 PayloadKey", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Spend", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11157,16 +7730,15 @@ func (m *PayloadKeyWithCommitment) 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 := &v14.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 Commitment", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11193,66 +7765,15 @@ func (m *PayloadKeyWithCommitment) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Commitment == nil {
- m.Commitment = &v1alpha1.StateCommitment{}
- }
- if err := m.Commitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ v := &v14.Output{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
+ m.Action = &Action_Output{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 *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
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- wire |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- 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:
+ case 3:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Nullifier", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11279,16 +7800,15 @@ func (m *NullifierWithNote) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Nullifier == nil {
- m.Nullifier = &v1alpha1.Nullifier{}
- }
- if err := m.Nullifier.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ v := &v15.Swap{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
+ m.Action = &Action_Swap{v}
iNdEx = postIndex
- case 2:
+ case 4:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Note", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field SwapClaim", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11315,66 +7835,50 @@ func (m *NullifierWithNote) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Note == nil {
- m.Note = &v1alpha1.Note{}
- }
- if err := m.Note.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ v := &v15.SwapClaim{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
+ m.Action = &Action_SwapClaim{v}
iNdEx = postIndex
- default:
- iNdEx = preIndex
- skippy, err := skipTransaction(dAtA[iNdEx:])
- if err != nil {
- return err
+ case 16:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ValidatorDefinition", 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 *TransactionView) Unmarshal(dAtA []byte) 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 := &v16.ValidatorDefinition{}
+ 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: 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:
+ m.Action = &Action_ValidatorDefinition{v}
+ iNdEx = postIndex
+ case 17:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field BodyView", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field IbcRelayAction", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11399,20 +7903,19 @@ func (m *TransactionView) Unmarshal(dAtA []byte) error {
return ErrInvalidLengthTransaction
}
if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- if m.BodyView == nil {
- m.BodyView = &TransactionBodyView{}
+ return io.ErrUnexpectedEOF
}
- if err := m.BodyView.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ v := &v17.IbcRelay{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
+ m.Action = &Action_IbcRelayAction{v}
iNdEx = postIndex
- case 2:
+ case 18:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field BindingSig", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field ProposalSubmit", wireType)
}
- var byteLen int
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTransaction
@@ -11422,29 +7925,30 @@ 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{}
+ v := &v18.ProposalSubmit{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
}
+ m.Action = &Action_ProposalSubmit{v}
iNdEx = postIndex
- case 3:
+ case 19:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Anchor", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field ProposalWithdraw", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11471,66 +7975,15 @@ func (m *TransactionView) 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 := &v18.ProposalWithdraw{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
+ m.Action = &Action_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 *TransactionBodyView) Unmarshal(dAtA []byte) 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: TransactionBodyView: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: TransactionBodyView: 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 ActionViews", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field ValidatorVote", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11557,14 +8010,15 @@ func (m *TransactionBodyView) Unmarshal(dAtA []byte) error {
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 {
+ v := &v18.ValidatorVote{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
+ m.Action = &Action_ValidatorVote{v}
iNdEx = postIndex
- case 2:
+ case 21:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field TransactionParameters", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field DelegatorVote", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11591,16 +8045,15 @@ func (m *TransactionBodyView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.TransactionParameters == nil {
- m.TransactionParameters = &TransactionParameters{}
- }
- if err := m.TransactionParameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ v := &v18.DelegatorVote{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
+ m.Action = &Action_DelegatorVote{v}
iNdEx = postIndex
- case 3:
+ case 22:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field ProposalDepositClaim", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11627,16 +8080,15 @@ func (m *TransactionBodyView) 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 {
+ v := &v18.ProposalDepositClaim{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
+ m.Action = &Action_ProposalDepositClaim{v}
iNdEx = postIndex
- case 4:
+ case 30:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field DetectionData", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field PositionOpen", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11663,15 +8115,15 @@ func (m *TransactionBodyView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &DetectionData{}
+ v := &v15.PositionOpen{}
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.XDetectionData = &TransactionBodyView_DetectionData{v}
+ m.Action = &Action_PositionOpen{v}
iNdEx = postIndex
- case 5:
+ case 31:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field MemoView", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field PositionClose", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11698,65 +8150,15 @@ func (m *TransactionBodyView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &MemoView{}
+ v := &v15.PositionClose{}
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.XMemoView = &TransactionBodyView_MemoView{v}
+ m.Action = &Action_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 *ActionView) Unmarshal(dAtA []byte) 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: ActionView: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: ActionView: 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 Spend", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field PositionWithdraw", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11783,15 +8185,15 @@ func (m *ActionView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &SpendView{}
+ v := &v15.PositionWithdraw{}
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.ActionView = &ActionView_Spend{v}
+ m.Action = &Action_PositionWithdraw{v}
iNdEx = postIndex
- case 2:
+ case 34:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field PositionRewardClaim", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11818,15 +8220,15 @@ func (m *ActionView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &OutputView{}
+ v := &v15.PositionRewardClaim{}
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.ActionView = &ActionView_Output{v}
+ m.Action = &Action_PositionRewardClaim{v}
iNdEx = postIndex
- case 3:
+ case 40:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Delegate", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11853,15 +8255,15 @@ func (m *ActionView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha11.SwapView{}
+ v := &v16.Delegate{}
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.ActionView = &ActionView_Swap{v}
+ m.Action = &Action_Delegate{v}
iNdEx = postIndex
- case 4:
+ case 41:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field SwapClaim", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Undelegate", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11888,15 +8290,15 @@ func (m *ActionView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha11.SwapClaimView{}
+ v := &v16.Undelegate{}
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.ActionView = &ActionView_SwapClaim{v}
+ m.Action = &Action_Undelegate{v}
iNdEx = postIndex
- case 16:
+ case 42:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field ValidatorDefinition", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field UndelegateClaim", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11923,15 +8325,15 @@ func (m *ActionView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha12.ValidatorDefinition{}
+ v := &v16.UndelegateClaim{}
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.ActionView = &ActionView_ValidatorDefinition{v}
+ m.Action = &Action_UndelegateClaim{v}
iNdEx = postIndex
- case 17:
+ case 50:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field IbcAction", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field CommunityPoolSpend", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11958,15 +8360,15 @@ func (m *ActionView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha13.IbcAction{}
+ v := &v18.CommunityPoolSpend{}
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.ActionView = &ActionView_IbcAction{v}
+ m.Action = &Action_CommunityPoolSpend{v}
iNdEx = postIndex
- case 18:
+ case 51:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field ProposalSubmit", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field CommunityPoolOutput", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11993,15 +8395,15 @@ func (m *ActionView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha14.ProposalSubmit{}
+ v := &v18.CommunityPoolOutput{}
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.ActionView = &ActionView_ProposalSubmit{v}
+ m.Action = &Action_CommunityPoolOutput{v}
iNdEx = postIndex
- case 19:
+ case 52:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field ProposalWithdraw", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field CommunityPoolDeposit", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12028,15 +8430,15 @@ func (m *ActionView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha14.ProposalWithdraw{}
+ v := &v18.CommunityPoolDeposit{}
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.ActionView = &ActionView_ProposalWithdraw{v}
+ m.Action = &Action_CommunityPoolDeposit{v}
iNdEx = postIndex
- case 20:
+ case 200:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field ValidatorVote", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Ics20Withdrawal", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12063,15 +8465,65 @@ func (m *ActionView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha14.ValidatorVote{}
+ v := &v17.Ics20Withdrawal{}
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.ActionView = &ActionView_ValidatorVote{v}
+ m.Action = &Action_Ics20Withdrawal{v}
iNdEx = postIndex
- case 21:
+ 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 DelegatorVote", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field PayloadKeys", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12098,15 +8550,14 @@ func (m *ActionView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &DelegatorVoteView{}
- 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.ActionView = &ActionView_DelegatorVote{v}
iNdEx = postIndex
- case 22:
+ case 2:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field ProposalDepositClaim", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field SpendNullifiers", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12133,15 +8584,14 @@ func (m *ActionView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha14.ProposalDepositClaim{}
- 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.ActionView = &ActionView_ProposalDepositClaim{v}
iNdEx = postIndex
- case 30:
+ case 3:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field PositionOpen", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field AdviceNotes", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12168,15 +8618,14 @@ func (m *ActionView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha11.PositionOpen{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ m.AdviceNotes = append(m.AdviceNotes, &v14.Note{})
+ if err := m.AdviceNotes[len(m.AdviceNotes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.ActionView = &ActionView_PositionOpen{v}
iNdEx = postIndex
- case 31:
+ case 4:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field PositionClose", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field AddressViews", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12203,15 +8652,14 @@ func (m *ActionView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha11.PositionClose{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ m.AddressViews = append(m.AddressViews, &v19.AddressView{})
+ if err := m.AddressViews[len(m.AddressViews)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.ActionView = &ActionView_PositionClose{v}
iNdEx = postIndex
- case 32:
+ case 5:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field PositionWithdraw", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Denoms", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12238,15 +8686,14 @@ func (m *ActionView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha11.PositionWithdraw{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ m.Denoms = append(m.Denoms, &v110.Metadata{})
+ if err := m.Denoms[len(m.Denoms)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.ActionView = &ActionView_PositionWithdraw{v}
iNdEx = postIndex
- case 34:
+ case 6:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field PositionRewardClaim", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field TransactionId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12273,15 +8720,16 @@ func (m *ActionView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha11.PositionRewardClaim{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if m.TransactionId == nil {
+ m.TransactionId = &v111.TransactionId{}
+ }
+ if err := m.TransactionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.ActionView = &ActionView_PositionRewardClaim{v}
iNdEx = postIndex
- case 41:
+ 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 Prices", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12308,15 +8756,14 @@ func (m *ActionView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha12.Delegate{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ m.Prices = append(m.Prices, &v110.EstimatedPrice{})
+ if err := m.Prices[len(m.Prices)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.ActionView = &ActionView_Delegate{v}
iNdEx = postIndex
- case 42:
+ case 30:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Undelegate", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field ExtendedMetadata", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12343,15 +8790,14 @@ func (m *ActionView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha12.Undelegate{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ m.ExtendedMetadata = append(m.ExtendedMetadata, &TransactionPerspective_ExtendedMetadataById{})
+ if err := m.ExtendedMetadata[len(m.ExtendedMetadata)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.ActionView = &ActionView_Undelegate{v}
iNdEx = postIndex
- case 43:
+ case 40:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field UndelegateClaim", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field CreationTransactionIdsByNullifier", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12378,15 +8824,14 @@ func (m *ActionView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha12.UndelegateClaim{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ m.CreationTransactionIdsByNullifier = append(m.CreationTransactionIdsByNullifier, &TransactionPerspective_CreationTransactionIdByNullifier{})
+ if err := m.CreationTransactionIdsByNullifier[len(m.CreationTransactionIdsByNullifier)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.ActionView = &ActionView_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 NullificationTransactionIdsByCommitment", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12413,15 +8858,14 @@ func (m *ActionView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha14.DaoSpend{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ m.NullificationTransactionIdsByCommitment = append(m.NullificationTransactionIdsByCommitment, &TransactionPerspective_NullificationTransactionIdByCommitment{})
+ if err := m.NullificationTransactionIdsByCommitment[len(m.NullificationTransactionIdsByCommitment)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.ActionView = &ActionView_DaoSpend{v}
iNdEx = postIndex
- case 51:
+ case 60:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field DaoOutput", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field BatchSwapOutputData", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12448,15 +8892,64 @@ func (m *ActionView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha14.DaoOutput{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ m.BatchSwapOutputData = append(m.BatchSwapOutputData, &v15.BatchSwapOutputData{})
+ if err := m.BatchSwapOutputData[len(m.BatchSwapOutputData)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.ActionView = &ActionView_DaoOutput{v}
iNdEx = postIndex
- case 52:
+ 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_ExtendedMetadataById) Unmarshal(dAtA []byte) 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: ExtendedMetadataById: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ExtendedMetadataById: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field DaoDeposit", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field AssetId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12483,15 +8976,16 @@ func (m *ActionView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha14.DaoDeposit{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if m.AssetId == nil {
+ m.AssetId = &v110.AssetId{}
+ }
+ if err := m.AssetId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.ActionView = &ActionView_DaoDeposit{v}
iNdEx = postIndex
- case 200:
+ case 2:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Ics20Withdrawal", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field ExtendedMetadata", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12518,11 +9012,12 @@ func (m *ActionView) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha13.Ics20Withdrawal{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if m.ExtendedMetadata == nil {
+ m.ExtendedMetadata = &types.Any{}
+ }
+ if err := m.ExtendedMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.ActionView = &ActionView_Ics20Withdrawal{v}
iNdEx = postIndex
default:
iNdEx = preIndex
@@ -12545,7 +9040,7 @@ func (m *ActionView) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *SpendView) Unmarshal(dAtA []byte) error {
+func (m *TransactionPerspective_CreationTransactionIdByNullifier) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -12568,15 +9063,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: CreationTransactionIdByNullifier: 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: CreationTransactionIdByNullifier: 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 {
@@ -12603,15 +9098,16 @@ 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 {
+ if m.Nullifier == nil {
+ m.Nullifier = &v112.Nullifier{}
+ }
+ if err := m.Nullifier.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 TransactionId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12638,11 +9134,12 @@ 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 {
+ if m.TransactionId == nil {
+ m.TransactionId = &v111.TransactionId{}
+ }
+ if err := m.TransactionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.SpendView = &SpendView_Opaque_{v}
iNdEx = postIndex
default:
iNdEx = preIndex
@@ -12665,7 +9162,7 @@ func (m *SpendView) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *SpendView_Visible) Unmarshal(dAtA []byte) error {
+func (m *TransactionPerspective_NullificationTransactionIdByCommitment) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -12688,15 +9185,15 @@ func (m *SpendView_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: NullificationTransactionIdByCommitment: 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: NullificationTransactionIdByCommitment: 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 Commitment", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12723,16 +9220,16 @@ func (m *SpendView_Visible) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Spend == nil {
- m.Spend = &Spend{}
+ if m.Commitment == nil {
+ m.Commitment = &v11.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
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 TransactionId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12759,10 +9256,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 = &v111.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 +9284,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 +9307,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 = &v19.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 +9378,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 = &v11.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 +9406,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 +9429,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 +9464,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 = &v112.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 +9500,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 = &v14.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 +9528,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 {
@@ -13006,25 +9541,61 @@ func (m *DelegatorVoteView_Visible) Unmarshal(dAtA []byte) error {
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
- b := dAtA[iNdEx]
- iNdEx++
- wire |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ 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
}
- }
- 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 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 +9622,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 = &v1.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 +9658,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 = &v11.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 +9686,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 +9709,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 +9744,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 +9814,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 +9850,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 +9878,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 +9901,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 +9936,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 := &v14.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 +9971,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 := &v14.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 +10006,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 := &v15.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 +10041,15 @@ 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 {
- return err
- }
- iNdEx = postIndex
- default:
- iNdEx = preIndex
- skippy, err := skipTransaction(dAtA[iNdEx:])
- if err != nil {
+ v := &v15.SwapClaimView{}
+ 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 *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 iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- 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:
+ }
+ m.ActionView = &ActionView_SwapClaim{v}
+ iNdEx = postIndex
+ case 16:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field ValidatorDefinition", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -13623,16 +10076,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 := &v16.ValidatorDefinition{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
+ m.ActionView = &ActionView_ValidatorDefinition{v}
iNdEx = postIndex
- case 2:
+ case 17:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field AuthSig", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field IbcRelayAction", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -13659,16 +10111,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 := &v17.IbcRelay{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
+ m.ActionView = &ActionView_IbcRelayAction{v}
iNdEx = postIndex
- case 3:
+ case 18:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field ProposalSubmit", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -13695,66 +10146,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 := &v18.ProposalSubmit{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
+ m.ActionView = &ActionView_ProposalSubmit{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 19:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field BalanceCommitment", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field ProposalWithdraw", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -13781,18 +10181,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 := &v18.ProposalWithdraw{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
+ m.ActionView = &ActionView_ProposalWithdraw{v}
iNdEx = postIndex
- case 3:
+ case 20:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Nullifier", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field ValidatorVote", wireType)
}
- var byteLen int
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTransaction
@@ -13802,31 +10201,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 := &v18.ValidatorVote{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
}
+ m.ActionView = &ActionView_ValidatorVote{v}
iNdEx = postIndex
- case 4:
+ case 21:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Rk", 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
@@ -13836,79 +10236,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 := &v18.DelegatorVoteView{}
+ 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_DelegatorVote{v}
+ iNdEx = postIndex
+ case 22:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field ProposalDepositClaim", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -13935,16 +10286,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 := &v18.ProposalDepositClaim{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
+ m.ActionView = &ActionView_ProposalDepositClaim{v}
iNdEx = postIndex
- case 2:
+ case 30:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field PositionOpen", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -13971,66 +10321,50 @@ 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 := &v15.PositionOpen{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
+ m.ActionView = &ActionView_PositionOpen{v}
iNdEx = postIndex
- default:
- iNdEx = preIndex
- skippy, err := skipTransaction(dAtA[iNdEx:])
- if err != nil {
- return err
+ case 31:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PositionClose", 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 *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
+ 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 := &v15.PositionClose{}
+ 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: 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:
+ m.ActionView = &ActionView_PositionClose{v}
+ iNdEx = postIndex
+ 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 +10391,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 := &v15.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 +10426,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 := &v15.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 +10446,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 := &v16.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 +10481,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 := &v16.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 +10531,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 := &v16.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 +10566,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 := &v18.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 +10601,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 := &v18.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 +10636,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 := &v18.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 +10671,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 := &v17.Ics20Withdrawal{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
+ m.ActionView = &ActionView_Ics20Withdrawal{v}
iNdEx = postIndex
default:
iNdEx = preIndex
@@ -14463,7 +10698,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 +10721,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 +10756,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 = &v111.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 +10777,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, &v1.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 +10826,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, &v1.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 +10910,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 = &v11.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 +10946,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, &v11.StateCommitmentProof{})
+ if err := m.StateCommitmentProofs[len(m.StateCommitmentProofs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@@ -14704,7 +10972,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 +10995,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 +11030,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 +11064,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 +11100,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 +11136,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 +11222,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 +11306,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha14.ValidatorVote{}
+ v := &v14.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 +11341,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha14.DelegatorVotePlan{}
+ v := &v14.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 +11376,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha14.ProposalDepositClaim{}
+ v := &v15.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 +11411,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha13.Ics20Withdrawal{}
+ v := &v15.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 +11446,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha11.PositionOpen{}
+ v := &v16.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 +11481,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha11.PositionClose{}
+ v := &v17.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 +11516,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha11.PositionWithdrawPlan{}
+ v := &v18.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 +11551,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha11.PositionRewardClaimPlan{}
+ v := &v18.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 +11586,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha12.Delegate{}
+ v := &v18.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 +11621,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha12.Undelegate{}
+ v := &v18.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 +11656,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha12.UndelegateClaimPlan{}
+ v := &v18.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 30:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field DaoSpend", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field PositionOpen", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -15427,15 +11691,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha14.DaoSpend{}
+ v := &v15.PositionOpen{}
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.Action = &ActionPlan_DaoSpend{v}
+ m.Action = &ActionPlan_PositionOpen{v}
iNdEx = postIndex
- case 51:
+ case 31:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field DaoOutput", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field PositionClose", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -15462,15 +11726,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha14.DaoOutput{}
+ v := &v15.PositionClose{}
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.Action = &ActionPlan_DaoOutput{v}
+ m.Action = &ActionPlan_PositionClose{v}
iNdEx = postIndex
- case 52:
+ case 32:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field DaoDeposit", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field PositionWithdraw", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -15497,65 +11761,15 @@ func (m *ActionPlan) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha14.DaoDeposit{}
+ v := &v15.PositionWithdrawPlan{}
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.Action = &ActionPlan_DaoDeposit{v}
+ m.Action = &ActionPlan_PositionWithdraw{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 34:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field PositionRewardClaim", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -15582,18 +11796,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 := &v15.PositionRewardClaimPlan{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
+ m.Action = &ActionPlan_PositionRewardClaim{v}
iNdEx = postIndex
- case 2:
+ case 40:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Rseed", 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
@@ -15603,31 +11816,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 := &v16.Delegate{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
}
+ m.Action = &ActionPlan_Delegate{v}
iNdEx = postIndex
- case 3:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field PrecisionBits", wireType)
+ case 41:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Undelegate", wireType)
}
- m.PrecisionBits = 0
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTransaction
@@ -15637,64 +11851,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 := &v16.Undelegate{}
+ 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_Undelegate{v}
+ iNdEx = postIndex
+ case 42:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Plaintext", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field UndelegateClaim", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -15721,18 +11901,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 := &v16.UndelegateClaimPlan{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
+ m.Action = &ActionPlan_UndelegateClaim{v}
iNdEx = postIndex
- case 2:
+ case 50:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Key", 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
@@ -15742,81 +11921,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 := &v18.CommunityPoolSpend{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ m.Action = &ActionPlan_CommunityPoolSpend{v}
+ iNdEx = postIndex
+ case 51:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field CommunityPoolOutput", wireType)
}
- var byteLen int
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTransaction
@@ -15826,79 +11956,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 := &v18.CommunityPoolOutput{}
+ 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_CommunityPoolOutput{v}
+ iNdEx = postIndex
+ case 52:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field CommunityPoolDeposit", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -15925,18 +12006,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 := &v18.CommunityPoolDeposit{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
+ m.Action = &ActionPlan_CommunityPoolDeposit{v}
iNdEx = postIndex
- case 2:
+ case 200:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Text", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Ics20Withdrawal", wireType)
}
- var stringLen uint64
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTransaction
@@ -15946,23 +12026,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 := &v17.Ics20Withdrawal{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ m.Action = &ActionPlan_Ics20Withdrawal{v}
iNdEx = postIndex
default:
iNdEx = preIndex
@@ -15985,7 +12068,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 +12091,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 +12126,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 = &v19.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 +12147,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 +12207,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 +12230,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 +12265,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 +12286,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 +12327,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 +12350,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 +12370,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 +12411,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 +12434,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 +12469,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 = &v19.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 +12490,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 +12572,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 = &v19.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 +12608,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 +12647,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 +12670,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 +12705,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 +12740,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 +12810,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 +12846,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 +12932,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/v1/txhash.pb.go b/relayer/chains/penumbra/core/txhash/v1/txhash.pb.go
new file mode 100644
index 000000000..38d267899
--- /dev/null
+++ b/relayer/chains/penumbra/core/txhash/v1/txhash.pb.go
@@ -0,0 +1,503 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: penumbra/core/txhash/v1/txhash.proto
+
+package txhashv1
+
+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_c59a591286b5edd2, []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_c59a591286b5edd2, []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.v1.EffectHash")
+ proto.RegisterType((*TransactionId)(nil), "penumbra.core.txhash.v1.TransactionId")
+}
+
+func init() {
+ proto.RegisterFile("penumbra/core/txhash/v1/txhash.proto", fileDescriptor_c59a591286b5edd2)
+}
+
+var fileDescriptor_c59a591286b5edd2 = []byte{
+ // 285 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x29, 0x48, 0xcd, 0x2b,
+ 0xcd, 0x4d, 0x2a, 0x4a, 0xd4, 0x4f, 0xce, 0x2f, 0x4a, 0xd5, 0x2f, 0xa9, 0xc8, 0x48, 0x2c, 0xce,
+ 0xd0, 0x2f, 0x33, 0x84, 0xb2, 0xf4, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0xc4, 0x61, 0xaa, 0xf4,
+ 0x40, 0xaa, 0xf4, 0xa0, 0x72, 0x65, 0x86, 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, 0xfd, 0x4c, 0x27, 0x1e, 0xc9,
+ 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0xe3, 0x84, 0xc7, 0x72, 0x0c, 0x17, 0x1e,
+ 0xcb, 0x31, 0xdc, 0x78, 0x2c, 0xc7, 0xc0, 0x25, 0x9d, 0x9c, 0x9f, 0xab, 0x87, 0xc3, 0x09, 0x4e,
+ 0xdc, 0x21, 0x60, 0x66, 0x00, 0xc8, 0xa1, 0x01, 0x8c, 0x51, 0x3e, 0xe9, 0x99, 0x25, 0x19, 0xa5,
+ 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0xc9, 0xf9, 0xc5, 0xb9, 0xf9, 0xc5, 0xfa, 0x45, 0xa9, 0x39,
+ 0x89, 0x95, 0xa9, 0x45, 0xfa, 0x65, 0x46, 0x70, 0x66, 0x72, 0x46, 0x62, 0x66, 0x5e, 0xb1, 0x3e,
+ 0x0e, 0xcf, 0x5b, 0x43, 0x58, 0x65, 0x86, 0x8b, 0x98, 0x98, 0x03, 0x9c, 0x43, 0x56, 0x31, 0x89,
+ 0x07, 0xc0, 0x2c, 0x77, 0x06, 0x59, 0x0e, 0xb1, 0x51, 0x2f, 0xcc, 0xf0, 0x14, 0x42, 0x26, 0x06,
+ 0x24, 0x13, 0x03, 0x91, 0x89, 0x09, 0x33, 0x7c, 0xc4, 0xa4, 0x8c, 0x43, 0x26, 0xc6, 0x3d, 0xc0,
+ 0xc9, 0x37, 0xb5, 0x24, 0x31, 0x25, 0xb1, 0x24, 0xf1, 0x15, 0x93, 0x14, 0x4c, 0x95, 0x95, 0x15,
+ 0x48, 0x99, 0x95, 0x15, 0x44, 0x9d, 0x95, 0x55, 0x98, 0x61, 0x12, 0x1b, 0x38, 0xf0, 0x8d, 0x01,
+ 0x01, 0x00, 0x00, 0xff, 0xff, 0xa1, 0x44, 0x06, 0x7d, 0xa4, 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/v1/decaf377_fmd.pb.go b/relayer/chains/penumbra/crypto/decaf377_fmd/v1/decaf377_fmd.pb.go
new file mode 100644
index 000000000..6f15d8bb2
--- /dev/null
+++ b/relayer/chains/penumbra/crypto/decaf377_fmd/v1/decaf377_fmd.pb.go
@@ -0,0 +1,326 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: penumbra/crypto/decaf377_fmd/v1/decaf377_fmd.proto
+
+package decaf377_fmdv1
+
+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_85fd7d84b4ad102e, []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.v1.Clue")
+}
+
+func init() {
+ proto.RegisterFile("penumbra/crypto/decaf377_fmd/v1/decaf377_fmd.proto", fileDescriptor_85fd7d84b4ad102e)
+}
+
+var fileDescriptor_85fd7d84b4ad102e = []byte{
+ // 272 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x32, 0x2a, 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, 0x44, 0xe1, 0xeb, 0x15, 0x14,
+ 0xe5, 0x97, 0xe4, 0x0b, 0xc9, 0xc3, 0xf4, 0xe8, 0x41, 0xf4, 0xe8, 0xa1, 0xa8, 0x29, 0x33, 0x54,
+ 0x92, 0xe1, 0x62, 0x71, 0xce, 0x29, 0x4d, 0x15, 0x12, 0xe1, 0x62, 0xcd, 0xcc, 0xcb, 0x4b, 0x2d,
+ 0x92, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x09, 0x82, 0x70, 0x9c, 0x8e, 0x31, 0x9d, 0x78, 0x24, 0xc7,
+ 0x78, 0xe1, 0x91, 0x1c, 0xe3, 0x83, 0x47, 0x72, 0x8c, 0x13, 0x1e, 0xcb, 0x31, 0x5c, 0x78, 0x2c,
+ 0xc7, 0x70, 0xe3, 0xb1, 0x1c, 0x03, 0x97, 0x72, 0x72, 0x7e, 0xae, 0x1e, 0x01, 0xd3, 0x9d, 0x04,
+ 0x5c, 0xa0, 0x02, 0x6e, 0xb9, 0x29, 0x01, 0x20, 0x07, 0x05, 0x30, 0x46, 0x45, 0xa5, 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, 0x04, 0xbc, 0x6c, 0x8d, 0xcc, 0x2f, 0x33, 0x5c, 0xc4, 0xc4, 0x1c, 0xe0, 0xec, 0xb2,
+ 0x8a, 0x49, 0x2e, 0x00, 0xe6, 0x2e, 0x67, 0x88, 0xbb, 0x90, 0x9c, 0xa1, 0x17, 0x66, 0x78, 0x0a,
+ 0xa1, 0x20, 0x06, 0xa2, 0x20, 0x06, 0x49, 0x41, 0x4c, 0x98, 0xe1, 0x23, 0x26, 0x2d, 0xfc, 0x0a,
+ 0x62, 0xdc, 0x03, 0x9c, 0x7c, 0x53, 0x4b, 0x12, 0x53, 0x12, 0x4b, 0x12, 0x5f, 0x31, 0x29, 0xc2,
+ 0x14, 0x5b, 0x59, 0x41, 0x54, 0x5b, 0x59, 0x21, 0x29, 0xb7, 0xb2, 0x0a, 0x33, 0x4c, 0x62, 0x03,
+ 0x47, 0x87, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x0a, 0x26, 0xec, 0x07, 0xc4, 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/v1/decaf377_frost.pb.go b/relayer/chains/penumbra/crypto/decaf377_frost/v1/decaf377_frost.pb.go
new file mode 100644
index 000000000..cd3dce766
--- /dev/null
+++ b/relayer/chains/penumbra/crypto/decaf377_frost/v1/decaf377_frost.pb.go
@@ -0,0 +1,1524 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: penumbra/crypto/decaf377_frost/v1/decaf377_frost.proto
+
+package decaf377_frostv1
+
+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_b4822bfeb2663db2, []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_b4822bfeb2663db2, []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_b4822bfeb2663db2, []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_b4822bfeb2663db2, []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_b4822bfeb2663db2, []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_b4822bfeb2663db2, []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_b4822bfeb2663db2, []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.v1.VerifiableSecretSharingCommitment")
+ proto.RegisterType((*DKGRound1Package)(nil), "penumbra.crypto.decaf377_frost.v1.DKGRound1Package")
+ proto.RegisterType((*SigningShare)(nil), "penumbra.crypto.decaf377_frost.v1.SigningShare")
+ proto.RegisterType((*DKGRound2Package)(nil), "penumbra.crypto.decaf377_frost.v1.DKGRound2Package")
+ proto.RegisterType((*NonceCommitment)(nil), "penumbra.crypto.decaf377_frost.v1.NonceCommitment")
+ proto.RegisterType((*SigningCommitments)(nil), "penumbra.crypto.decaf377_frost.v1.SigningCommitments")
+ proto.RegisterType((*SignatureShare)(nil), "penumbra.crypto.decaf377_frost.v1.SignatureShare")
+}
+
+func init() {
+ proto.RegisterFile("penumbra/crypto/decaf377_frost/v1/decaf377_frost.proto", fileDescriptor_b4822bfeb2663db2)
+}
+
+var fileDescriptor_b4822bfeb2663db2 = []byte{
+ // 511 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x94, 0x4f, 0x8b, 0xd3, 0x40,
+ 0x18, 0xc6, 0x3b, 0x59, 0xe8, 0xca, 0x58, 0x75, 0x99, 0x83, 0x14, 0x0f, 0xa1, 0x1b, 0x51, 0x0a,
+ 0x2e, 0x09, 0xe9, 0x82, 0x0b, 0xf1, 0x20, 0xb4, 0xc5, 0x05, 0xd7, 0x3f, 0x21, 0x95, 0x1e, 0xa4,
+ 0x58, 0xa6, 0x93, 0x49, 0x3a, 0x6c, 0x33, 0x53, 0x66, 0xa6, 0x95, 0xfd, 0x16, 0x7e, 0x06, 0x0f,
+ 0x1e, 0x3c, 0xf8, 0x39, 0xc4, 0xd3, 0x9e, 0xc4, 0xa3, 0xb4, 0x37, 0x3f, 0x85, 0xa4, 0x49, 0xfa,
+ 0xef, 0x60, 0x16, 0x6f, 0xf3, 0xbe, 0x79, 0x9e, 0x67, 0x7e, 0xef, 0x4b, 0x12, 0xf8, 0x74, 0x4a,
+ 0xf9, 0x2c, 0x19, 0x49, 0xec, 0x10, 0x79, 0x35, 0xd5, 0xc2, 0x09, 0x29, 0xc1, 0xd1, 0xe9, 0xd9,
+ 0xd9, 0x30, 0x92, 0x42, 0x69, 0x67, 0xee, 0xee, 0x75, 0xec, 0xa9, 0x14, 0x5a, 0xa0, 0xe3, 0xc2,
+ 0x67, 0x67, 0x3e, 0x7b, 0x4f, 0x35, 0x77, 0xad, 0xe7, 0xf0, 0xb8, 0x4f, 0x25, 0x8b, 0x18, 0x1e,
+ 0x4d, 0x68, 0x8f, 0x12, 0x49, 0x75, 0x6f, 0x8c, 0x25, 0xe3, 0x71, 0x47, 0x24, 0x09, 0xd3, 0x09,
+ 0xe5, 0x1a, 0x3d, 0x80, 0xb7, 0xe8, 0x84, 0xa6, 0x47, 0x55, 0x07, 0x8d, 0x83, 0x66, 0x2d, 0x58,
+ 0xd7, 0xd6, 0x17, 0x00, 0x8f, 0xba, 0x17, 0xe7, 0x81, 0x98, 0xf1, 0xd0, 0xf5, 0x31, 0xb9, 0xc4,
+ 0x31, 0x45, 0x21, 0x84, 0x64, 0x6d, 0xaf, 0x83, 0x06, 0x68, 0xde, 0x6e, 0x75, 0xed, 0x52, 0x1a,
+ 0xbb, 0x14, 0x25, 0xd8, 0xca, 0x45, 0x27, 0x10, 0x4d, 0xa5, 0x10, 0xd1, 0x50, 0x44, 0xc3, 0x4b,
+ 0x2e, 0x3e, 0x4e, 0x68, 0x18, 0xd3, 0xba, 0xd1, 0x00, 0xcd, 0x5a, 0x70, 0xb4, 0x7a, 0xf2, 0x36,
+ 0xba, 0x28, 0xfa, 0xd6, 0x63, 0x58, 0xeb, 0xb1, 0x98, 0x33, 0x1e, 0xa7, 0xa9, 0x14, 0xdd, 0x87,
+ 0x55, 0x45, 0xf0, 0x04, 0xcb, 0x15, 0x5f, 0x2d, 0xc8, 0x2b, 0x6b, 0xbc, 0x99, 0xa7, 0x55, 0xcc,
+ 0xf3, 0x0e, 0xde, 0x51, 0x99, 0x77, 0xa8, 0x52, 0x73, 0x3e, 0x92, 0x73, 0x83, 0x91, 0xb6, 0xef,
+ 0x0c, 0x6a, 0x6a, 0xab, 0xb2, 0x9e, 0xc0, 0x7b, 0x6f, 0x04, 0x27, 0x74, 0x6b, 0xd3, 0x75, 0x78,
+ 0x98, 0x6f, 0x36, 0xa7, 0x2a, 0x4a, 0xeb, 0x1b, 0x80, 0x28, 0xcf, 0xda, 0xe8, 0x15, 0x7a, 0x09,
+ 0xab, 0x63, 0x16, 0x32, 0x1e, 0xe7, 0x48, 0xad, 0x1b, 0x20, 0xed, 0x5d, 0x1a, 0xe4, 0x09, 0xe8,
+ 0x15, 0x3c, 0x1c, 0x31, 0xbe, 0x0a, 0x33, 0xfe, 0x3b, 0xac, 0x88, 0xb0, 0x9a, 0xf0, 0x6e, 0xca,
+ 0x8b, 0xf5, 0x4c, 0xd2, 0x7f, 0x6e, 0xbc, 0xfd, 0xd3, 0xf8, 0xbe, 0x30, 0xc1, 0xf5, 0xc2, 0x04,
+ 0xbf, 0x17, 0x26, 0xf8, 0xb4, 0x34, 0x2b, 0xd7, 0x4b, 0xb3, 0xf2, 0x6b, 0x69, 0x56, 0xe0, 0x23,
+ 0x22, 0x92, 0x72, 0x88, 0x36, 0xea, 0xe6, 0xad, 0x17, 0x69, 0xc7, 0x4f, 0x5f, 0x7e, 0x1f, 0xbc,
+ 0xff, 0x10, 0x33, 0x3d, 0x9e, 0x8d, 0x6c, 0x22, 0x12, 0x87, 0x08, 0x95, 0x08, 0xe5, 0x48, 0x3a,
+ 0xc1, 0x57, 0x54, 0x3a, 0xf3, 0xd6, 0xfa, 0x48, 0xc6, 0x98, 0x71, 0xe5, 0x94, 0x7e, 0x62, 0xcf,
+ 0x76, 0x3b, 0x73, 0xf7, 0xb3, 0x71, 0xe0, 0x77, 0xba, 0x5f, 0x8d, 0x86, 0x5f, 0xf0, 0x75, 0x32,
+ 0xbe, 0x1d, 0x18, 0xbb, 0xef, 0xfe, 0xd8, 0x48, 0x06, 0x99, 0x64, 0xb0, 0x23, 0x19, 0xf4, 0xdd,
+ 0x85, 0x71, 0x52, 0x26, 0x19, 0x9c, 0xfb, 0xed, 0xd7, 0x54, 0xe3, 0x10, 0x6b, 0xfc, 0xc7, 0x78,
+ 0x58, 0xc8, 0x3d, 0x2f, 0xd3, 0x7b, 0xde, 0x8e, 0xc1, 0xf3, 0xfa, 0xee, 0xa8, 0xba, 0xfa, 0x0d,
+ 0x9c, 0xfe, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x7e, 0x00, 0x87, 0xc9, 0x40, 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/v1/decaf377_rdsa.pb.go b/relayer/chains/penumbra/crypto/decaf377_rdsa/v1/decaf377_rdsa.pb.go
new file mode 100644
index 000000000..1732db883
--- /dev/null
+++ b/relayer/chains/penumbra/crypto/decaf377_rdsa/v1/decaf377_rdsa.pb.go
@@ -0,0 +1,673 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: penumbra/crypto/decaf377_rdsa/v1/decaf377_rdsa.proto
+
+package decaf377_rdsav1
+
+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_70f2e93711fd8093, []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_70f2e93711fd8093, []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_70f2e93711fd8093, []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.v1.SpendAuthSignature")
+ proto.RegisterType((*BindingSignature)(nil), "penumbra.crypto.decaf377_rdsa.v1.BindingSignature")
+ proto.RegisterType((*SpendVerificationKey)(nil), "penumbra.crypto.decaf377_rdsa.v1.SpendVerificationKey")
+}
+
+func init() {
+ proto.RegisterFile("penumbra/crypto/decaf377_rdsa/v1/decaf377_rdsa.proto", fileDescriptor_70f2e93711fd8093)
+}
+
+var fileDescriptor_70f2e93711fd8093 = []byte{
+ // 325 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x32, 0x29, 0x48, 0xcd, 0x2b,
+ 0xcd, 0x4d, 0x2a, 0x4a, 0xd4, 0x4f, 0x2e, 0xaa, 0x2c, 0x28, 0xc9, 0xd7, 0x4f, 0x49, 0x4d, 0x4e,
+ 0x4c, 0x33, 0x36, 0x37, 0x8f, 0x2f, 0x4a, 0x29, 0x4e, 0xd4, 0x2f, 0x33, 0x44, 0x15, 0xd0, 0x2b,
+ 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x52, 0x80, 0xe9, 0xd2, 0x83, 0xe8, 0xd2, 0x43, 0x55, 0x54, 0x66,
+ 0xa8, 0xa4, 0xc5, 0x25, 0x14, 0x5c, 0x90, 0x9a, 0x97, 0xe2, 0x58, 0x5a, 0x92, 0x11, 0x9c, 0x99,
+ 0x9e, 0x97, 0x58, 0x52, 0x5a, 0x94, 0x2a, 0x24, 0xc2, 0xc5, 0x9a, 0x99, 0x97, 0x97, 0x5a, 0x24,
+ 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x13, 0x04, 0xe1, 0x28, 0x69, 0x70, 0x09, 0x38, 0x65, 0xe6, 0xa5,
+ 0x64, 0xe6, 0xa5, 0x13, 0x52, 0xa9, 0xc3, 0x25, 0x02, 0x36, 0x35, 0x2c, 0xb5, 0x28, 0x33, 0x2d,
+ 0x33, 0x39, 0xb1, 0x24, 0x33, 0x3f, 0xcf, 0x3b, 0xb5, 0x12, 0xbb, 0x6a, 0xa7, 0x73, 0x4c, 0x27,
+ 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0xe3, 0x84, 0xc7, 0x72, 0x0c,
+ 0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, 0xc7, 0xc0, 0xa5, 0x92, 0x9c, 0x9f, 0xab, 0x47, 0xc8,
+ 0x13, 0x4e, 0x82, 0x2e, 0x50, 0x91, 0xa0, 0x94, 0xe2, 0xc4, 0x00, 0x90, 0xcf, 0x03, 0x18, 0xa3,
+ 0x62, 0xd2, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0x93, 0xf3, 0x8b, 0x73,
+ 0xf3, 0x8b, 0xf5, 0x8b, 0x52, 0x73, 0x12, 0x2b, 0x53, 0x8b, 0xf4, 0xcb, 0x8c, 0xe0, 0xcc, 0xe4,
+ 0x8c, 0xc4, 0xcc, 0xbc, 0x62, 0x7d, 0x42, 0xa1, 0x6b, 0x8d, 0x22, 0x50, 0x66, 0xb8, 0x88, 0x89,
+ 0x39, 0xc0, 0xd9, 0x65, 0x15, 0x93, 0x7c, 0x00, 0xcc, 0x6d, 0xce, 0x10, 0xb7, 0x21, 0xbb, 0x44,
+ 0x2f, 0xcc, 0xf0, 0x14, 0x42, 0x45, 0x0c, 0x44, 0x45, 0x0c, 0xb2, 0x8a, 0x98, 0x30, 0xc3, 0x47,
+ 0x4c, 0xda, 0x04, 0x54, 0xc4, 0xb8, 0x07, 0x38, 0xf9, 0xa6, 0x96, 0x24, 0xa6, 0x24, 0x96, 0x24,
+ 0xbe, 0x62, 0x52, 0x82, 0xa9, 0xb6, 0xb2, 0x82, 0x28, 0xb7, 0xb2, 0x42, 0x56, 0x6f, 0x65, 0x15,
+ 0x66, 0x98, 0xc4, 0x06, 0x8e, 0x7d, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x15, 0xef, 0xa1,
+ 0xa6, 0x35, 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/v1/tct.pb.go b/relayer/chains/penumbra/crypto/tct/v1/tct.pb.go
new file mode 100644
index 000000000..228882a48
--- /dev/null
+++ b/relayer/chains/penumbra/crypto/tct/v1/tct.pb.go
@@ -0,0 +1,1060 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: penumbra/crypto/tct/v1/tct.proto
+
+package tctv1
+
+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_e171b1288fe7a145, []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_e171b1288fe7a145, []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_e171b1288fe7a145, []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_e171b1288fe7a145, []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.v1.StateCommitment")
+ proto.RegisterType((*MerkleRoot)(nil), "penumbra.crypto.tct.v1.MerkleRoot")
+ proto.RegisterType((*StateCommitmentProof)(nil), "penumbra.crypto.tct.v1.StateCommitmentProof")
+ proto.RegisterType((*MerklePathChunk)(nil), "penumbra.crypto.tct.v1.MerklePathChunk")
+}
+
+func init() { proto.RegisterFile("penumbra/crypto/tct/v1/tct.proto", fileDescriptor_e171b1288fe7a145) }
+
+var fileDescriptor_e171b1288fe7a145 = []byte{
+ // 415 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x92, 0xc1, 0x6a, 0xdb, 0x40,
+ 0x10, 0x86, 0xbd, 0x72, 0x5b, 0x9c, 0x6d, 0xa9, 0x41, 0x84, 0xe0, 0xa6, 0x20, 0x8c, 0x2e, 0xc9,
+ 0x49, 0x62, 0xed, 0x9b, 0x7a, 0xb3, 0x0b, 0xed, 0x25, 0x20, 0x54, 0xe1, 0x43, 0x31, 0x98, 0xd5,
+ 0x76, 0x1b, 0x2d, 0xb1, 0x76, 0xc4, 0x6a, 0x24, 0xc8, 0xb9, 0x2f, 0xd0, 0x67, 0xe8, 0xb1, 0x4f,
+ 0x52, 0x72, 0xca, 0xb1, 0xc7, 0x22, 0xdf, 0xfa, 0x14, 0x45, 0x56, 0xec, 0xb8, 0xc6, 0xce, 0x49,
+ 0x9a, 0xf9, 0xfe, 0x99, 0xf9, 0x67, 0x19, 0x3a, 0xcc, 0xa5, 0x2e, 0xb3, 0xc4, 0x70, 0x5f, 0x98,
+ 0xdb, 0x1c, 0xc1, 0x47, 0x81, 0x7e, 0xc5, 0x9a, 0x8f, 0x97, 0x1b, 0x40, 0xb0, 0xcf, 0x36, 0x0a,
+ 0xaf, 0x55, 0x78, 0x0d, 0xaa, 0x98, 0x7b, 0x41, 0xfb, 0x9f, 0x90, 0xa3, 0x9c, 0x42, 0x96, 0x29,
+ 0xcc, 0xa4, 0x46, 0xfb, 0x94, 0x3e, 0x57, 0x5a, 0x4b, 0x33, 0x20, 0x43, 0x72, 0xf9, 0x2a, 0x6a,
+ 0x03, 0xd7, 0xa5, 0xf4, 0x4a, 0x9a, 0x9b, 0xa5, 0x8c, 0x00, 0x8e, 0x69, 0xee, 0x08, 0x3d, 0xdd,
+ 0xeb, 0x16, 0x1a, 0x80, 0xaf, 0x76, 0x48, 0xfb, 0x1a, 0x50, 0x2e, 0xc4, 0x36, 0xbf, 0x2e, 0x7c,
+ 0x39, 0xba, 0xf0, 0x0e, 0xfb, 0xf2, 0xf6, 0xda, 0x44, 0xaf, 0x9b, 0xfa, 0x1d, 0x93, 0xe7, 0xb4,
+ 0x97, 0x43, 0xa1, 0x50, 0x81, 0x1e, 0x58, 0x43, 0x72, 0xf9, 0x2c, 0xda, 0xc6, 0xf6, 0x7b, 0x7a,
+ 0xc2, 0x4b, 0x4c, 0x17, 0x39, 0xc7, 0x74, 0xd0, 0x1d, 0x76, 0x9f, 0x9a, 0xd3, 0xee, 0x14, 0x72,
+ 0x4c, 0xa7, 0x69, 0xa9, 0x6f, 0xa2, 0x5e, 0x53, 0xd9, 0x84, 0x6e, 0x4a, 0xfb, 0x7b, 0xd0, 0x7e,
+ 0x4b, 0x4f, 0x0a, 0x95, 0x2c, 0x95, 0xbe, 0x5e, 0xb0, 0x87, 0xcd, 0x7b, 0x0f, 0x09, 0xb6, 0x0b,
+ 0x47, 0x6b, 0x4b, 0x8f, 0x70, 0xb4, 0x0b, 0xc7, 0x83, 0xee, 0x7f, 0x70, 0x3c, 0xf9, 0x66, 0xfd,
+ 0xaa, 0x1d, 0x72, 0x5f, 0x3b, 0xe4, 0x4f, 0xed, 0x90, 0xef, 0x2b, 0xa7, 0x73, 0xbf, 0x72, 0x3a,
+ 0xbf, 0x57, 0x4e, 0x87, 0x9e, 0x0b, 0xc8, 0x8e, 0x58, 0x9f, 0xf4, 0x62, 0xd1, 0x3c, 0x2f, 0x42,
+ 0x48, 0x3e, 0x7f, 0xbc, 0x56, 0x98, 0x96, 0x89, 0x27, 0x20, 0xf3, 0x05, 0x14, 0x19, 0x14, 0xbe,
+ 0x91, 0x4b, 0x7e, 0x2b, 0x8d, 0x5f, 0x8d, 0xb6, 0xbf, 0x22, 0xe5, 0x4a, 0x17, 0xfe, 0xe1, 0x63,
+ 0x79, 0x87, 0x02, 0x2b, 0xf6, 0xc3, 0xea, 0x86, 0xd3, 0xf8, 0xa7, 0x75, 0x16, 0x6e, 0x86, 0x4e,
+ 0xdb, 0xa1, 0xb1, 0x40, 0x6f, 0xc6, 0xee, 0x1e, 0xc1, 0xbc, 0x05, 0xf3, 0x58, 0xe0, 0x7c, 0xc6,
+ 0x6a, 0xcb, 0x3d, 0x0c, 0xe6, 0x1f, 0xc2, 0xc9, 0x95, 0x44, 0xfe, 0x85, 0x23, 0xff, 0x6b, 0xbd,
+ 0xd9, 0x88, 0x82, 0xa0, 0x55, 0x05, 0x41, 0x2c, 0x30, 0x08, 0x66, 0x2c, 0x79, 0xb1, 0x3e, 0xd4,
+ 0xf1, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe3, 0x2c, 0xf6, 0x4d, 0xcc, 0x02, 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/v1/threshold.pb.go b/relayer/chains/penumbra/custody/threshold/v1/threshold.pb.go
new file mode 100644
index 000000000..8c4ea3406
--- /dev/null
+++ b/relayer/chains/penumbra/custody/threshold/v1/threshold.pb.go
@@ -0,0 +1,3618 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: penumbra/custody/threshold/v1/threshold.proto
+
+package thresholdv1
+
+import (
+ fmt "fmt"
+ proto "github.com/cosmos/gogoproto/proto"
+ v12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/governance/v1"
+ v11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/stake/v1"
+ v1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/transaction/v1"
+ v13 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/decaf377_frost/v1"
+ 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_d60f2e30e69d733f, []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_d60f2e30e69d733f, []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 {
+ // Types that are valid to be assigned to Request:
+ // *CoordinatorRound1_Plan
+ // *CoordinatorRound1_ValidatorDefinition
+ // *CoordinatorRound1_ValidatorVote
+ Request isCoordinatorRound1_Request `protobuf_oneof:"request"`
+}
+
+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_d60f2e30e69d733f, []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
+
+type isCoordinatorRound1_Request interface {
+ isCoordinatorRound1_Request()
+ MarshalTo([]byte) (int, error)
+ Size() int
+}
+
+type CoordinatorRound1_Plan struct {
+ Plan *v1.TransactionPlan `protobuf:"bytes,1,opt,name=plan,proto3,oneof" json:"plan,omitempty"`
+}
+type CoordinatorRound1_ValidatorDefinition struct {
+ ValidatorDefinition *v11.Validator `protobuf:"bytes,2,opt,name=validator_definition,json=validatorDefinition,proto3,oneof" json:"validator_definition,omitempty"`
+}
+type CoordinatorRound1_ValidatorVote struct {
+ ValidatorVote *v12.ValidatorVoteBody `protobuf:"bytes,3,opt,name=validator_vote,json=validatorVote,proto3,oneof" json:"validator_vote,omitempty"`
+}
+
+func (*CoordinatorRound1_Plan) isCoordinatorRound1_Request() {}
+func (*CoordinatorRound1_ValidatorDefinition) isCoordinatorRound1_Request() {}
+func (*CoordinatorRound1_ValidatorVote) isCoordinatorRound1_Request() {}
+
+func (m *CoordinatorRound1) GetRequest() isCoordinatorRound1_Request {
+ if m != nil {
+ return m.Request
+ }
+ return nil
+}
+
+func (m *CoordinatorRound1) GetPlan() *v1.TransactionPlan {
+ if x, ok := m.GetRequest().(*CoordinatorRound1_Plan); ok {
+ return x.Plan
+ }
+ return nil
+}
+
+func (m *CoordinatorRound1) GetValidatorDefinition() *v11.Validator {
+ if x, ok := m.GetRequest().(*CoordinatorRound1_ValidatorDefinition); ok {
+ return x.ValidatorDefinition
+ }
+ return nil
+}
+
+func (m *CoordinatorRound1) GetValidatorVote() *v12.ValidatorVoteBody {
+ if x, ok := m.GetRequest().(*CoordinatorRound1_ValidatorVote); ok {
+ return x.ValidatorVote
+ }
+ return nil
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*CoordinatorRound1) XXX_OneofWrappers() []interface{} {
+ return []interface{}{
+ (*CoordinatorRound1_Plan)(nil),
+ (*CoordinatorRound1_ValidatorDefinition)(nil),
+ (*CoordinatorRound1_ValidatorVote)(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_d60f2e30e69d733f, []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 *v13.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_d60f2e30e69d733f, []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() *v13.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_d60f2e30e69d733f, []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_d60f2e30e69d733f, []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 []*v13.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_d60f2e30e69d733f, []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() []*v13.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_d60f2e30e69d733f, []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 []*v13.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_d60f2e30e69d733f, []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() []*v13.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 *v13.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_d60f2e30e69d733f, []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() *v13.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_d60f2e30e69d733f, []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_d60f2e30e69d733f, []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_d60f2e30e69d733f, []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.v1.VerificationKey")
+ proto.RegisterType((*Signature)(nil), "penumbra.custody.threshold.v1.Signature")
+ proto.RegisterType((*CoordinatorRound1)(nil), "penumbra.custody.threshold.v1.CoordinatorRound1")
+ proto.RegisterType((*CoordinatorRound2)(nil), "penumbra.custody.threshold.v1.CoordinatorRound2")
+ proto.RegisterType((*CoordinatorRound2_IdentifiedCommitments)(nil), "penumbra.custody.threshold.v1.CoordinatorRound2.IdentifiedCommitments")
+ proto.RegisterType((*CoordinatorRound2_PartialSigningPackage)(nil), "penumbra.custody.threshold.v1.CoordinatorRound2.PartialSigningPackage")
+ proto.RegisterType((*FollowerRound1)(nil), "penumbra.custody.threshold.v1.FollowerRound1")
+ proto.RegisterType((*FollowerRound1_Inner)(nil), "penumbra.custody.threshold.v1.FollowerRound1.Inner")
+ proto.RegisterType((*FollowerRound2)(nil), "penumbra.custody.threshold.v1.FollowerRound2")
+ proto.RegisterType((*FollowerRound2_Inner)(nil), "penumbra.custody.threshold.v1.FollowerRound2.Inner")
+ proto.RegisterType((*DKGRound1)(nil), "penumbra.custody.threshold.v1.DKGRound1")
+ proto.RegisterType((*DKGRound2)(nil), "penumbra.custody.threshold.v1.DKGRound2")
+ proto.RegisterType((*DKGRound2_TargetedPackage)(nil), "penumbra.custody.threshold.v1.DKGRound2.TargetedPackage")
+ proto.RegisterType((*DKGRound2_Inner)(nil), "penumbra.custody.threshold.v1.DKGRound2.Inner")
+}
+
+func init() {
+ proto.RegisterFile("penumbra/custody/threshold/v1/threshold.proto", fileDescriptor_d60f2e30e69d733f)
+}
+
+var fileDescriptor_d60f2e30e69d733f = []byte{
+ // 926 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0xcd, 0x6e, 0xdb, 0x46,
+ 0x10, 0x16, 0xa9, 0x24, 0x85, 0xd7, 0xae, 0x6c, 0x6f, 0x1c, 0x40, 0x10, 0x1a, 0xc1, 0xd1, 0xa5,
+ 0x2e, 0xd2, 0x2c, 0x41, 0x19, 0x6d, 0x02, 0x15, 0xe8, 0xc1, 0x72, 0x13, 0x1b, 0x41, 0x0b, 0x81,
+ 0x76, 0x55, 0xa0, 0x30, 0xe0, 0xac, 0xc9, 0x15, 0xb5, 0x20, 0xb5, 0xcb, 0xec, 0xae, 0x58, 0xe8,
+ 0x0d, 0x7a, 0x2a, 0xf2, 0x0c, 0x45, 0x81, 0x16, 0xed, 0x13, 0xe4, 0x0d, 0x8a, 0x9e, 0x72, 0xe8,
+ 0xa1, 0xc7, 0xc2, 0xbe, 0xf5, 0x29, 0x0a, 0xfe, 0x2d, 0x29, 0xf9, 0x47, 0x41, 0xdb, 0x43, 0x6f,
+ 0x3b, 0x3b, 0xf3, 0x7d, 0x33, 0xfc, 0x66, 0x86, 0x24, 0x78, 0x14, 0x11, 0x36, 0x9d, 0x9c, 0x09,
+ 0x6c, 0xb9, 0x53, 0xa9, 0xb8, 0x37, 0xb3, 0xd4, 0x58, 0x10, 0x39, 0xe6, 0xa1, 0x67, 0xc5, 0x76,
+ 0x69, 0xa0, 0x48, 0x70, 0xc5, 0xe1, 0xfd, 0x22, 0x1c, 0xe5, 0xe1, 0xa8, 0x8c, 0x88, 0xed, 0x16,
+ 0x2a, 0xd9, 0xb8, 0x20, 0x96, 0x12, 0x98, 0x49, 0xec, 0x2a, 0xca, 0x59, 0x4a, 0x56, 0x9a, 0x19,
+ 0x5d, 0xeb, 0xc3, 0xf9, 0x78, 0x97, 0x4f, 0x22, 0xce, 0x08, 0x53, 0x96, 0x54, 0x38, 0x20, 0x09,
+ 0x26, 0x3d, 0xe4, 0xd1, 0x1f, 0x5f, 0x17, 0xed, 0xf3, 0x98, 0x08, 0x86, 0x99, 0x9b, 0x42, 0x4a,
+ 0xeb, 0x32, 0x4e, 0xcc, 0x22, 0xc5, 0x2d, 0x8f, 0xb8, 0x78, 0xb4, 0xfb, 0xf8, 0xf1, 0xe9, 0x48,
+ 0x70, 0xa9, 0x12, 0xcc, 0xfc, 0x4d, 0x86, 0xeb, 0xbc, 0x0f, 0xd6, 0x87, 0x44, 0xd0, 0x11, 0x75,
+ 0x71, 0x52, 0xf3, 0x73, 0x32, 0x83, 0x5b, 0xe0, 0x36, 0x65, 0x8c, 0x88, 0xa6, 0xb1, 0x6d, 0xec,
+ 0xac, 0x39, 0x99, 0xd1, 0x79, 0x00, 0x56, 0x8e, 0xa8, 0xcf, 0xb0, 0x9a, 0x0a, 0x72, 0x4d, 0xc8,
+ 0x4f, 0x26, 0xd8, 0xec, 0x73, 0x2e, 0x3c, 0xca, 0xb0, 0xe2, 0xc2, 0xe1, 0x53, 0xe6, 0xd9, 0xb0,
+ 0x0f, 0x6e, 0x45, 0x21, 0x66, 0x69, 0xe8, 0x6a, 0xf7, 0x11, 0x2a, 0xd5, 0xe5, 0x82, 0xa0, 0xaa,
+ 0x5e, 0xb1, 0x8d, 0x8e, 0x4b, 0x73, 0x10, 0x62, 0x76, 0x50, 0x73, 0x52, 0x30, 0x7c, 0x01, 0xb6,
+ 0x62, 0x1c, 0x52, 0x2f, 0xe1, 0x3d, 0xf5, 0xc8, 0x88, 0x32, 0x9a, 0xc4, 0x34, 0xcd, 0x94, 0xf4,
+ 0xe1, 0x02, 0xa9, 0x56, 0x0d, 0x65, 0xd2, 0xc6, 0x36, 0x1a, 0x16, 0xe8, 0x83, 0x9a, 0x73, 0x57,
+ 0x53, 0xed, 0x6b, 0x26, 0x88, 0x41, 0xa3, 0xcc, 0x10, 0x73, 0x45, 0x9a, 0xf5, 0x94, 0xfb, 0xc9,
+ 0xb5, 0xdc, 0x95, 0x1e, 0x54, 0x13, 0x0c, 0xb9, 0x22, 0x7b, 0xdc, 0x9b, 0x1d, 0xd4, 0x9c, 0x77,
+ 0xe3, 0xb9, 0xcb, 0x15, 0xf0, 0x8e, 0x20, 0x2f, 0xa7, 0x44, 0xaa, 0xce, 0x0f, 0xf5, 0xcb, 0x52,
+ 0x75, 0xe1, 0x4b, 0xb0, 0x21, 0xa9, 0xcf, 0x28, 0xf3, 0x4f, 0x23, 0xec, 0x06, 0xd8, 0x27, 0xb2,
+ 0x69, 0x6c, 0xd7, 0x77, 0x56, 0xbb, 0x4f, 0xd1, 0x8d, 0x43, 0x89, 0x2e, 0x71, 0xa1, 0x01, 0x16,
+ 0x8a, 0xe2, 0xf0, 0x28, 0xe3, 0x1b, 0x64, 0x74, 0xce, 0xba, 0x9c, 0xb3, 0x65, 0xeb, 0x95, 0x01,
+ 0xee, 0x1d, 0x7a, 0x84, 0x29, 0x3a, 0xa2, 0xc4, 0xeb, 0xf3, 0xc9, 0x84, 0xaa, 0x09, 0x61, 0x4a,
+ 0xc2, 0x36, 0x00, 0xb4, 0x70, 0x14, 0x8d, 0xae, 0xdc, 0xc0, 0xaf, 0xc0, 0xaa, 0x5b, 0x86, 0xe7,
+ 0x9d, 0xf8, 0xa8, 0x52, 0x67, 0x3a, 0x87, 0x68, 0x61, 0xea, 0x62, 0x1b, 0xe5, 0x25, 0x55, 0x72,
+ 0x39, 0x55, 0xa6, 0xd6, 0xb7, 0x06, 0xb8, 0x77, 0x65, 0xf5, 0x90, 0x83, 0x75, 0x1c, 0x86, 0xa7,
+ 0xd5, 0xb4, 0xff, 0x54, 0x9e, 0x2b, 0x9f, 0xd9, 0x69, 0xe0, 0x30, 0xac, 0xd8, 0x9d, 0xd7, 0x26,
+ 0x68, 0x3c, 0xe5, 0x61, 0xc8, 0xbf, 0x21, 0xc5, 0x38, 0x1f, 0x56, 0x47, 0x7f, 0xb5, 0xbb, 0xbb,
+ 0x24, 0xf3, 0x3c, 0x1a, 0x1d, 0x26, 0xd0, 0x7c, 0x5f, 0xe0, 0xa7, 0xc0, 0x8c, 0x82, 0x5c, 0x38,
+ 0xb4, 0x84, 0x67, 0x61, 0x49, 0x1d, 0x33, 0x0a, 0x60, 0x0f, 0xd4, 0x25, 0xf5, 0xf3, 0x39, 0xdd,
+ 0x59, 0x42, 0xa0, 0x97, 0xd7, 0x49, 0x40, 0xad, 0x17, 0xe0, 0x76, 0x5a, 0xcb, 0x62, 0x1b, 0x33,
+ 0x3d, 0xff, 0x83, 0x36, 0x76, 0x7e, 0x59, 0xd4, 0xae, 0xfb, 0xaf, 0xb4, 0xeb, 0xfe, 0x7f, 0xb4,
+ 0x73, 0x0a, 0xed, 0x0e, 0xc1, 0x1d, 0x39, 0xc6, 0x42, 0x6f, 0xa9, 0xfd, 0x96, 0xb2, 0xa5, 0x5c,
+ 0x47, 0x09, 0xd2, 0xc9, 0x09, 0x3a, 0x3f, 0x1a, 0x60, 0x65, 0xff, 0xf9, 0xb3, 0x7c, 0xc8, 0x3e,
+ 0x03, 0xf5, 0x28, 0xf0, 0xaf, 0x90, 0xe9, 0x3a, 0x56, 0x0d, 0x2d, 0x16, 0x3d, 0xc1, 0x43, 0x1b,
+ 0x6c, 0xb1, 0x69, 0x18, 0xa6, 0xfb, 0x5a, 0xd9, 0x9a, 0x54, 0xb6, 0x35, 0xe7, 0xae, 0xf6, 0x95,
+ 0x3d, 0x84, 0x1b, 0xa0, 0x4e, 0xa2, 0x20, 0xd5, 0x65, 0xcd, 0x49, 0x8e, 0xb0, 0x01, 0xcc, 0x38,
+ 0x68, 0xde, 0x4a, 0x2f, 0xcc, 0x38, 0xe8, 0xfc, 0x6e, 0x96, 0x95, 0x76, 0xe1, 0xfe, 0x7c, 0x4b,
+ 0x97, 0xb5, 0x42, 0x03, 0xe7, 0xbb, 0x99, 0xe5, 0x30, 0x8b, 0x1c, 0x49, 0x15, 0x45, 0x77, 0xd6,
+ 0x32, 0xcd, 0xbf, 0x00, 0xeb, 0xc7, 0x58, 0xf8, 0x44, 0x11, 0xaf, 0x78, 0x1b, 0x64, 0x20, 0x43,
+ 0x83, 0x1e, 0x82, 0x4d, 0xc2, 0x52, 0x85, 0x88, 0x57, 0xbc, 0x3f, 0x73, 0xce, 0x0d, 0xed, 0xc8,
+ 0xc1, 0xad, 0xef, 0x8c, 0xa2, 0x89, 0x3e, 0x80, 0x97, 0x60, 0x45, 0x43, 0x9f, 0xbc, 0xf5, 0xe3,
+ 0x2c, 0x14, 0xe7, 0x6c, 0x2e, 0x66, 0x94, 0xf0, 0x3d, 0xb0, 0xa2, 0x15, 0xcf, 0xeb, 0x2a, 0x2f,
+ 0xf6, 0x5e, 0x9b, 0xbf, 0x9e, 0xb7, 0x8d, 0x37, 0xe7, 0x6d, 0xe3, 0xcf, 0xf3, 0xb6, 0xf1, 0xea,
+ 0xa2, 0x5d, 0x7b, 0x73, 0xd1, 0xae, 0xfd, 0x71, 0xd1, 0xae, 0x81, 0x07, 0x2e, 0x9f, 0xdc, 0x5c,
+ 0xc8, 0x5e, 0xe3, 0xb8, 0xb0, 0x06, 0xc9, 0x67, 0x7d, 0x60, 0x7c, 0xfd, 0xa5, 0x4f, 0xd5, 0x78,
+ 0x7a, 0x96, 0x7c, 0xaf, 0x2c, 0x97, 0xcb, 0x09, 0x97, 0x96, 0x20, 0x21, 0x9e, 0x11, 0x61, 0xc5,
+ 0x5d, 0x7d, 0x74, 0xc7, 0x98, 0x32, 0x69, 0xdd, 0xf8, 0x83, 0xf4, 0x89, 0x36, 0x62, 0xfb, 0x7b,
+ 0xb3, 0x3e, 0xe8, 0x1f, 0xff, 0x6c, 0xde, 0x1f, 0x14, 0xe5, 0xf4, 0xf3, 0x72, 0x74, 0x01, 0x68,
+ 0x68, 0xff, 0x56, 0xfa, 0x4f, 0x72, 0xff, 0x89, 0xf6, 0x9f, 0x0c, 0xed, 0x73, 0xf3, 0x83, 0x1b,
+ 0xfd, 0x27, 0xcf, 0x06, 0x7b, 0x9f, 0x13, 0x85, 0x3d, 0xac, 0xf0, 0x5f, 0xe6, 0x76, 0x11, 0xdb,
+ 0xeb, 0xe5, 0xc1, 0xbd, 0x9e, 0x8e, 0xee, 0xf5, 0x86, 0xf6, 0xd9, 0x9d, 0xf4, 0x5f, 0x66, 0xf7,
+ 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x1b, 0x64, 0x2e, 0x8e, 0xe9, 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.Request != nil {
+ {
+ size := m.Request.Size()
+ i -= size
+ if _, err := m.Request.MarshalTo(dAtA[i:]); err != nil {
+ return 0, err
+ }
+ }
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *CoordinatorRound1_Plan) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CoordinatorRound1_Plan) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ 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 *CoordinatorRound1_ValidatorDefinition) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CoordinatorRound1_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 = encodeVarintThreshold(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x12
+ }
+ return len(dAtA) - i, nil
+}
+func (m *CoordinatorRound1_ValidatorVote) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *CoordinatorRound1_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 = encodeVarintThreshold(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x1a
+ }
+ 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.Request != nil {
+ n += m.Request.Size()
+ }
+ return n
+}
+
+func (m *CoordinatorRound1_Plan) 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 *CoordinatorRound1_ValidatorDefinition) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.ValidatorDefinition != nil {
+ l = m.ValidatorDefinition.Size()
+ n += 1 + l + sovThreshold(uint64(l))
+ }
+ return n
+}
+func (m *CoordinatorRound1_ValidatorVote) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.ValidatorVote != nil {
+ l = m.ValidatorVote.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
+ }
+ v := &v1.TransactionPlan{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ m.Request = &CoordinatorRound1_Plan{v}
+ iNdEx = postIndex
+ case 2:
+ 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 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
+ }
+ v := &v11.Validator{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ m.Request = &CoordinatorRound1_ValidatorDefinition{v}
+ iNdEx = postIndex
+ case 3:
+ 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 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
+ }
+ v := &v12.ValidatorVoteBody{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ m.Request = &CoordinatorRound1_ValidatorVote{v}
+ 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 = &v13.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, &v13.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, &v13.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 = &v13.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/v1/custody.pb.go b/relayer/chains/penumbra/custody/v1/custody.pb.go
new file mode 100644
index 000000000..e49458536
--- /dev/null
+++ b/relayer/chains/penumbra/custody/v1/custody.pb.go
@@ -0,0 +1,2859 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: penumbra/custody/v1/custody.proto
+
+package custodyv1
+
+import (
+ context "context"
+ fmt "fmt"
+ grpc1 "github.com/cosmos/gogoproto/grpc"
+ proto "github.com/cosmos/gogoproto/proto"
+ v13 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/governance/v1"
+ v11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/stake/v1"
+ v14 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/keys/v1"
+ v1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/transaction/v1"
+ v12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/decaf377_rdsa/v1"
+ 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 AuthorizeRequest struct {
+ // The transaction plan to authorize.
+ Plan *v1.TransactionPlan `protobuf:"bytes,1,opt,name=plan,proto3" json:"plan,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"`
+}
+
+func (m *AuthorizeRequest) Reset() { *m = AuthorizeRequest{} }
+func (m *AuthorizeRequest) String() string { return proto.CompactTextString(m) }
+func (*AuthorizeRequest) ProtoMessage() {}
+func (*AuthorizeRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e460ce3850593522, []int{0}
+}
+func (m *AuthorizeRequest) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *AuthorizeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_AuthorizeRequest.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *AuthorizeRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_AuthorizeRequest.Merge(m, src)
+}
+func (m *AuthorizeRequest) XXX_Size() int {
+ return m.Size()
+}
+func (m *AuthorizeRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_AuthorizeRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AuthorizeRequest proto.InternalMessageInfo
+
+func (m *AuthorizeRequest) GetPlan() *v1.TransactionPlan {
+ if m != nil {
+ return m.Plan
+ }
+ return nil
+}
+
+func (m *AuthorizeRequest) GetPreAuthorizations() []*PreAuthorization {
+ if m != nil {
+ return m.PreAuthorizations
+ }
+ return nil
+}
+
+type AuthorizeResponse struct {
+ Data *v1.AuthorizationData `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *AuthorizeResponse) Reset() { *m = AuthorizeResponse{} }
+func (m *AuthorizeResponse) String() string { return proto.CompactTextString(m) }
+func (*AuthorizeResponse) ProtoMessage() {}
+func (*AuthorizeResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e460ce3850593522, []int{1}
+}
+func (m *AuthorizeResponse) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *AuthorizeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_AuthorizeResponse.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *AuthorizeResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_AuthorizeResponse.Merge(m, src)
+}
+func (m *AuthorizeResponse) XXX_Size() int {
+ return m.Size()
+}
+func (m *AuthorizeResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_AuthorizeResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AuthorizeResponse proto.InternalMessageInfo
+
+func (m *AuthorizeResponse) GetData() *v1.AuthorizationData {
+ if m != nil {
+ return m.Data
+ }
+ return nil
+}
+
+type AuthorizeValidatorDefinitionRequest struct {
+ // The validator definition to authorize.
+ ValidatorDefinition *v11.Validator `protobuf:"bytes,1,opt,name=validator_definition,json=validatorDefinition,proto3" json:"validator_definition,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"`
+}
+
+func (m *AuthorizeValidatorDefinitionRequest) Reset() { *m = AuthorizeValidatorDefinitionRequest{} }
+func (m *AuthorizeValidatorDefinitionRequest) String() string { return proto.CompactTextString(m) }
+func (*AuthorizeValidatorDefinitionRequest) ProtoMessage() {}
+func (*AuthorizeValidatorDefinitionRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e460ce3850593522, []int{2}
+}
+func (m *AuthorizeValidatorDefinitionRequest) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *AuthorizeValidatorDefinitionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_AuthorizeValidatorDefinitionRequest.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *AuthorizeValidatorDefinitionRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_AuthorizeValidatorDefinitionRequest.Merge(m, src)
+}
+func (m *AuthorizeValidatorDefinitionRequest) XXX_Size() int {
+ return m.Size()
+}
+func (m *AuthorizeValidatorDefinitionRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_AuthorizeValidatorDefinitionRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AuthorizeValidatorDefinitionRequest proto.InternalMessageInfo
+
+func (m *AuthorizeValidatorDefinitionRequest) GetValidatorDefinition() *v11.Validator {
+ if m != nil {
+ return m.ValidatorDefinition
+ }
+ return nil
+}
+
+func (m *AuthorizeValidatorDefinitionRequest) GetPreAuthorizations() []*PreAuthorization {
+ if m != nil {
+ return m.PreAuthorizations
+ }
+ return nil
+}
+
+type AuthorizeValidatorDefinitionResponse struct {
+ // The authorization signature for the validator definition.
+ ValidatorDefinitionAuth *v12.SpendAuthSignature `protobuf:"bytes,1,opt,name=validator_definition_auth,json=validatorDefinitionAuth,proto3" json:"validator_definition_auth,omitempty"`
+}
+
+func (m *AuthorizeValidatorDefinitionResponse) Reset() { *m = AuthorizeValidatorDefinitionResponse{} }
+func (m *AuthorizeValidatorDefinitionResponse) String() string { return proto.CompactTextString(m) }
+func (*AuthorizeValidatorDefinitionResponse) ProtoMessage() {}
+func (*AuthorizeValidatorDefinitionResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e460ce3850593522, []int{3}
+}
+func (m *AuthorizeValidatorDefinitionResponse) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *AuthorizeValidatorDefinitionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_AuthorizeValidatorDefinitionResponse.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *AuthorizeValidatorDefinitionResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_AuthorizeValidatorDefinitionResponse.Merge(m, src)
+}
+func (m *AuthorizeValidatorDefinitionResponse) XXX_Size() int {
+ return m.Size()
+}
+func (m *AuthorizeValidatorDefinitionResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_AuthorizeValidatorDefinitionResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AuthorizeValidatorDefinitionResponse proto.InternalMessageInfo
+
+func (m *AuthorizeValidatorDefinitionResponse) GetValidatorDefinitionAuth() *v12.SpendAuthSignature {
+ if m != nil {
+ return m.ValidatorDefinitionAuth
+ }
+ return nil
+}
+
+type AuthorizeValidatorVoteRequest struct {
+ // The validator vote to authorize.
+ ValidatorVote *v13.ValidatorVoteBody `protobuf:"bytes,1,opt,name=validator_vote,json=validatorVote,proto3" json:"validator_vote,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"`
+}
+
+func (m *AuthorizeValidatorVoteRequest) Reset() { *m = AuthorizeValidatorVoteRequest{} }
+func (m *AuthorizeValidatorVoteRequest) String() string { return proto.CompactTextString(m) }
+func (*AuthorizeValidatorVoteRequest) ProtoMessage() {}
+func (*AuthorizeValidatorVoteRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e460ce3850593522, []int{4}
+}
+func (m *AuthorizeValidatorVoteRequest) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *AuthorizeValidatorVoteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_AuthorizeValidatorVoteRequest.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *AuthorizeValidatorVoteRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_AuthorizeValidatorVoteRequest.Merge(m, src)
+}
+func (m *AuthorizeValidatorVoteRequest) XXX_Size() int {
+ return m.Size()
+}
+func (m *AuthorizeValidatorVoteRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_AuthorizeValidatorVoteRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AuthorizeValidatorVoteRequest proto.InternalMessageInfo
+
+func (m *AuthorizeValidatorVoteRequest) GetValidatorVote() *v13.ValidatorVoteBody {
+ if m != nil {
+ return m.ValidatorVote
+ }
+ return nil
+}
+
+func (m *AuthorizeValidatorVoteRequest) GetPreAuthorizations() []*PreAuthorization {
+ if m != nil {
+ return m.PreAuthorizations
+ }
+ return nil
+}
+
+type AuthorizeValidatorVoteResponse struct {
+ // The authorization signature for the validator vote.
+ ValidatorVoteAuth *v12.SpendAuthSignature `protobuf:"bytes,1,opt,name=validator_vote_auth,json=validatorVoteAuth,proto3" json:"validator_vote_auth,omitempty"`
+}
+
+func (m *AuthorizeValidatorVoteResponse) Reset() { *m = AuthorizeValidatorVoteResponse{} }
+func (m *AuthorizeValidatorVoteResponse) String() string { return proto.CompactTextString(m) }
+func (*AuthorizeValidatorVoteResponse) ProtoMessage() {}
+func (*AuthorizeValidatorVoteResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e460ce3850593522, []int{5}
+}
+func (m *AuthorizeValidatorVoteResponse) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *AuthorizeValidatorVoteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_AuthorizeValidatorVoteResponse.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *AuthorizeValidatorVoteResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_AuthorizeValidatorVoteResponse.Merge(m, src)
+}
+func (m *AuthorizeValidatorVoteResponse) XXX_Size() int {
+ return m.Size()
+}
+func (m *AuthorizeValidatorVoteResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_AuthorizeValidatorVoteResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AuthorizeValidatorVoteResponse proto.InternalMessageInfo
+
+func (m *AuthorizeValidatorVoteResponse) GetValidatorVoteAuth() *v12.SpendAuthSignature {
+ if m != nil {
+ return m.ValidatorVoteAuth
+ }
+ return nil
+}
+
+// A pre-authorization packet. This allows a custodian to delegate (partial)
+// signing authority to other authorization mechanisms. Details of how a
+// custodian manages those keys are out-of-scope for the custody protocol and
+// are custodian-specific.
+type PreAuthorization struct {
+ // Types that are valid to be assigned to PreAuthorization:
+ // *PreAuthorization_Ed25519_
+ PreAuthorization isPreAuthorization_PreAuthorization `protobuf_oneof:"pre_authorization"`
+}
+
+func (m *PreAuthorization) Reset() { *m = PreAuthorization{} }
+func (m *PreAuthorization) String() string { return proto.CompactTextString(m) }
+func (*PreAuthorization) ProtoMessage() {}
+func (*PreAuthorization) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e460ce3850593522, []int{6}
+}
+func (m *PreAuthorization) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *PreAuthorization) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_PreAuthorization.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *PreAuthorization) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_PreAuthorization.Merge(m, src)
+}
+func (m *PreAuthorization) XXX_Size() int {
+ return m.Size()
+}
+func (m *PreAuthorization) XXX_DiscardUnknown() {
+ xxx_messageInfo_PreAuthorization.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PreAuthorization proto.InternalMessageInfo
+
+type isPreAuthorization_PreAuthorization interface {
+ isPreAuthorization_PreAuthorization()
+ MarshalTo([]byte) (int, error)
+ Size() int
+}
+
+type PreAuthorization_Ed25519_ struct {
+ Ed25519 *PreAuthorization_Ed25519 `protobuf:"bytes,1,opt,name=ed25519,proto3,oneof" json:"ed25519,omitempty"`
+}
+
+func (*PreAuthorization_Ed25519_) isPreAuthorization_PreAuthorization() {}
+
+func (m *PreAuthorization) GetPreAuthorization() isPreAuthorization_PreAuthorization {
+ if m != nil {
+ return m.PreAuthorization
+ }
+ return nil
+}
+
+func (m *PreAuthorization) GetEd25519() *PreAuthorization_Ed25519 {
+ if x, ok := m.GetPreAuthorization().(*PreAuthorization_Ed25519_); ok {
+ return x.Ed25519
+ }
+ return nil
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*PreAuthorization) XXX_OneofWrappers() []interface{} {
+ return []interface{}{
+ (*PreAuthorization_Ed25519_)(nil),
+ }
+}
+
+// An Ed25519-based preauthorization, containing an Ed25519 signature over the
+// `TransactionPlan`.
+type PreAuthorization_Ed25519 struct {
+ // The Ed25519 verification key used to verify the signature.
+ Vk []byte `protobuf:"bytes,1,opt,name=vk,proto3" json:"vk,omitempty"`
+ // The Ed25519 signature over the `TransactionPlan`.
+ Sig []byte `protobuf:"bytes,2,opt,name=sig,proto3" json:"sig,omitempty"`
+}
+
+func (m *PreAuthorization_Ed25519) Reset() { *m = PreAuthorization_Ed25519{} }
+func (m *PreAuthorization_Ed25519) String() string { return proto.CompactTextString(m) }
+func (*PreAuthorization_Ed25519) ProtoMessage() {}
+func (*PreAuthorization_Ed25519) Descriptor() ([]byte, []int) {
+ return fileDescriptor_e460ce3850593522, []int{6, 0}
+}
+func (m *PreAuthorization_Ed25519) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *PreAuthorization_Ed25519) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_PreAuthorization_Ed25519.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *PreAuthorization_Ed25519) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_PreAuthorization_Ed25519.Merge(m, src)
+}
+func (m *PreAuthorization_Ed25519) XXX_Size() int {
+ return m.Size()
+}
+func (m *PreAuthorization_Ed25519) XXX_DiscardUnknown() {
+ xxx_messageInfo_PreAuthorization_Ed25519.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PreAuthorization_Ed25519 proto.InternalMessageInfo
+
+func (m *PreAuthorization_Ed25519) GetVk() []byte {
+ if m != nil {
+ return m.Vk
+ }
+ return nil
+}
+
+func (m *PreAuthorization_Ed25519) GetSig() []byte {
+ if m != nil {
+ return m.Sig
+ }
+ 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_e460ce3850593522, []int{7}
+}
+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 *v14.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_e460ce3850593522, []int{8}
+}
+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() *v14.FullViewingKey {
+ if m != nil {
+ return m.FullViewingKey
+ }
+ return nil
+}
+
+type ConfirmAddressRequest struct {
+ AddressIndex *v14.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_e460ce3850593522, []int{9}
+}
+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() *v14.AddressIndex {
+ if m != nil {
+ return m.AddressIndex
+ }
+ return nil
+}
+
+type ConfirmAddressResponse struct {
+ Address *v14.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_e460ce3850593522, []int{10}
+}
+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() *v14.Address {
+ if m != nil {
+ return m.Address
+ }
+ return nil
+}
+
+func init() {
+ proto.RegisterType((*AuthorizeRequest)(nil), "penumbra.custody.v1.AuthorizeRequest")
+ proto.RegisterType((*AuthorizeResponse)(nil), "penumbra.custody.v1.AuthorizeResponse")
+ proto.RegisterType((*AuthorizeValidatorDefinitionRequest)(nil), "penumbra.custody.v1.AuthorizeValidatorDefinitionRequest")
+ proto.RegisterType((*AuthorizeValidatorDefinitionResponse)(nil), "penumbra.custody.v1.AuthorizeValidatorDefinitionResponse")
+ proto.RegisterType((*AuthorizeValidatorVoteRequest)(nil), "penumbra.custody.v1.AuthorizeValidatorVoteRequest")
+ proto.RegisterType((*AuthorizeValidatorVoteResponse)(nil), "penumbra.custody.v1.AuthorizeValidatorVoteResponse")
+ proto.RegisterType((*PreAuthorization)(nil), "penumbra.custody.v1.PreAuthorization")
+ proto.RegisterType((*PreAuthorization_Ed25519)(nil), "penumbra.custody.v1.PreAuthorization.Ed25519")
+ proto.RegisterType((*ExportFullViewingKeyRequest)(nil), "penumbra.custody.v1.ExportFullViewingKeyRequest")
+ proto.RegisterType((*ExportFullViewingKeyResponse)(nil), "penumbra.custody.v1.ExportFullViewingKeyResponse")
+ proto.RegisterType((*ConfirmAddressRequest)(nil), "penumbra.custody.v1.ConfirmAddressRequest")
+ proto.RegisterType((*ConfirmAddressResponse)(nil), "penumbra.custody.v1.ConfirmAddressResponse")
+}
+
+func init() { proto.RegisterFile("penumbra/custody/v1/custody.proto", fileDescriptor_e460ce3850593522) }
+
+var fileDescriptor_e460ce3850593522 = []byte{
+ // 911 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xcf, 0x6f, 0x1b, 0x45,
+ 0x18, 0xcd, 0x3a, 0x11, 0x11, 0x5f, 0x53, 0x2b, 0x59, 0xf7, 0x47, 0x30, 0xad, 0x09, 0x5b, 0x8a,
+ 0x2a, 0x02, 0xbb, 0xac, 0xd3, 0xd2, 0x34, 0x9c, 0xe2, 0xb4, 0xd0, 0x08, 0x21, 0xac, 0x4d, 0x65,
+ 0x55, 0x55, 0x84, 0x35, 0xd9, 0x1d, 0x3b, 0x2b, 0xaf, 0x67, 0x96, 0x99, 0xd9, 0xa1, 0x86, 0x13,
+ 0x17, 0xce, 0x48, 0x5c, 0xb8, 0x21, 0x71, 0x84, 0x7f, 0x04, 0x71, 0xea, 0x09, 0x21, 0x71, 0x41,
+ 0xc9, 0x8d, 0x03, 0x67, 0x8e, 0x68, 0x77, 0x67, 0xed, 0x5d, 0x67, 0x6d, 0x5a, 0x50, 0x4e, 0x9e,
+ 0xf9, 0xe6, 0xbd, 0xf7, 0xfd, 0xf0, 0xdb, 0xd1, 0xc0, 0xeb, 0x21, 0x26, 0xd1, 0xf0, 0x88, 0x21,
+ 0xcb, 0x8d, 0xb8, 0xa0, 0xde, 0xc8, 0x92, 0x76, 0xb6, 0x34, 0x43, 0x46, 0x05, 0xd5, 0x6b, 0x19,
+ 0xc4, 0xcc, 0xe2, 0xd2, 0xae, 0x6f, 0x4c, 0x78, 0x94, 0x61, 0x6b, 0x80, 0x47, 0x3c, 0x66, 0xc6,
+ 0xbf, 0x29, 0xad, 0x6e, 0x16, 0x11, 0x82, 0x21, 0xc2, 0x91, 0x2b, 0x7c, 0x4a, 0x62, 0x60, 0x6e,
+ 0xab, 0xf0, 0x6f, 0x17, 0xf1, 0x2e, 0x1d, 0x86, 0x94, 0x60, 0x22, 0x2c, 0x2e, 0xd0, 0x00, 0xc7,
+ 0x9c, 0x64, 0xa1, 0xd0, 0xef, 0xcd, 0x42, 0xf7, 0xa9, 0xc4, 0x8c, 0x20, 0xe2, 0x26, 0x94, 0xc9,
+ 0x4e, 0xf1, 0x6e, 0x4f, 0x78, 0x6c, 0x14, 0x0a, 0x6a, 0x79, 0xd8, 0x45, 0xbd, 0xad, 0xbb, 0x77,
+ 0xbb, 0xcc, 0xe3, 0x28, 0xa6, 0x14, 0x02, 0x29, 0xcb, 0xf8, 0x49, 0x83, 0xd5, 0xdd, 0x48, 0x1c,
+ 0x53, 0xe6, 0x7f, 0x81, 0x1d, 0xfc, 0x59, 0x84, 0xb9, 0xd0, 0x77, 0x61, 0x29, 0x0c, 0x10, 0x59,
+ 0xd7, 0x36, 0xb4, 0x5b, 0x17, 0x9a, 0xef, 0x98, 0x93, 0x31, 0x51, 0x86, 0xcd, 0x7c, 0x83, 0xd2,
+ 0x36, 0x1f, 0x4d, 0xb6, 0xed, 0x00, 0x11, 0x27, 0xa1, 0xea, 0x8f, 0x40, 0x0f, 0x19, 0xee, 0x22,
+ 0x25, 0x8d, 0xe2, 0x63, 0xbe, 0xbe, 0xb8, 0xb1, 0x78, 0xeb, 0x42, 0xf3, 0xa6, 0x59, 0x32, 0x77,
+ 0xb3, 0xcd, 0xf0, 0x6e, 0x1e, 0xed, 0xac, 0x85, 0x53, 0x11, 0x6e, 0x3c, 0x86, 0xb5, 0x5c, 0xb1,
+ 0x3c, 0xa4, 0x84, 0x63, 0x7d, 0x0f, 0x96, 0x3c, 0x24, 0x90, 0xaa, 0xd6, 0x9a, 0x5f, 0x6d, 0x41,
+ 0xf0, 0x3e, 0x12, 0xc8, 0x49, 0xc8, 0xc6, 0xef, 0x1a, 0xdc, 0x18, 0x4b, 0x77, 0x50, 0xe0, 0x7b,
+ 0x48, 0x50, 0x76, 0x1f, 0xf7, 0x7c, 0xe2, 0x27, 0xd5, 0xa8, 0xd1, 0x7c, 0x0a, 0x97, 0x64, 0x76,
+ 0xda, 0xf5, 0xc6, 0xc7, 0x2a, 0xf9, 0xe6, 0x54, 0xf2, 0xf1, 0x9f, 0x67, 0xa6, 0xff, 0xb0, 0xb4,
+ 0xcd, 0xb1, 0xb6, 0x53, 0x93, 0x67, 0xd3, 0x9c, 0xd3, 0xdc, 0xbe, 0xd3, 0xe0, 0x8d, 0xf9, 0xdd,
+ 0xa9, 0x59, 0x86, 0xf0, 0x4a, 0x59, 0x7b, 0x49, 0x3d, 0xaa, 0xc7, 0xdb, 0xb9, 0x2a, 0x12, 0xa3,
+ 0x99, 0x45, 0x5f, 0x49, 0xdb, 0x3c, 0x08, 0x31, 0xf1, 0xe2, 0x7c, 0x07, 0x7e, 0x9f, 0x20, 0x11,
+ 0x31, 0xec, 0x5c, 0x2d, 0x69, 0x36, 0x46, 0x18, 0xbf, 0x6a, 0x70, 0xfd, 0x6c, 0x69, 0x1d, 0x2a,
+ 0xc6, 0x6e, 0xec, 0x42, 0x75, 0x52, 0x93, 0xa4, 0x02, 0xab, 0x42, 0xb6, 0x67, 0x0e, 0x3b, 0xf7,
+ 0x6d, 0xe4, 0x27, 0x1e, 0x8b, 0xb6, 0xa8, 0x37, 0x72, 0x2e, 0xca, 0x7c, 0xe8, 0x9c, 0x66, 0xfe,
+ 0xb5, 0x06, 0x8d, 0x59, 0x8d, 0xa9, 0x69, 0x7b, 0x50, 0x2b, 0x76, 0xf6, 0xff, 0xe7, 0xbc, 0x56,
+ 0x68, 0x2d, 0x99, 0xf0, 0xf7, 0x1a, 0xac, 0x4e, 0x17, 0xac, 0xef, 0xc3, 0x32, 0xf6, 0x9a, 0x77,
+ 0xee, 0xd8, 0xf7, 0x4a, 0xbe, 0xf2, 0xd9, 0x8d, 0x9a, 0x0f, 0x52, 0xd2, 0xc3, 0x05, 0x27, 0xe3,
+ 0xd7, 0x37, 0x61, 0x59, 0x45, 0xf5, 0x2a, 0x54, 0xe4, 0x20, 0x11, 0x5c, 0x71, 0x2a, 0x72, 0xa0,
+ 0xaf, 0xc2, 0x22, 0xf7, 0xfb, 0xeb, 0x95, 0x24, 0x10, 0x2f, 0x5b, 0x35, 0x58, 0x3b, 0x33, 0x6b,
+ 0xe3, 0x3a, 0xbc, 0xfa, 0xe0, 0x69, 0x48, 0x99, 0xf8, 0x20, 0x0a, 0x82, 0x8e, 0x8f, 0x3f, 0xf7,
+ 0x49, 0xff, 0x23, 0x3c, 0x52, 0x06, 0x30, 0x28, 0x5c, 0x2b, 0x3f, 0x56, 0x63, 0xfc, 0x04, 0x56,
+ 0x7b, 0x51, 0x10, 0x74, 0x65, 0x7a, 0xd4, 0x1d, 0xe0, 0x91, 0x6a, 0xea, 0xe6, 0x94, 0x45, 0x92,
+ 0x4b, 0x5c, 0xda, 0xe6, 0x94, 0x50, 0xb5, 0x57, 0xd8, 0x1b, 0x08, 0x2e, 0xef, 0x51, 0xd2, 0xf3,
+ 0xd9, 0x70, 0xd7, 0xf3, 0x18, 0xe6, 0x3c, 0xb3, 0xe2, 0x43, 0xb8, 0x88, 0xd2, 0x48, 0xd7, 0x27,
+ 0x1e, 0x7e, 0xaa, 0xd2, 0xdc, 0x98, 0x91, 0x46, 0xb1, 0xf7, 0x63, 0xa8, 0xb3, 0x82, 0x72, 0x3b,
+ 0xc3, 0x81, 0x2b, 0xd3, 0x29, 0x54, 0x37, 0xdb, 0xb0, 0xac, 0x90, 0x4a, 0xbd, 0x31, 0x5f, 0xdd,
+ 0xc9, 0xe0, 0xcd, 0xbf, 0x96, 0xa0, 0xba, 0x97, 0xfe, 0x77, 0x07, 0x98, 0x49, 0xdf, 0xc5, 0xfa,
+ 0x13, 0x78, 0x79, 0xec, 0x41, 0xbd, 0xdc, 0xcb, 0xd3, 0xb7, 0x7f, 0xfd, 0xcd, 0x7f, 0x83, 0xa9,
+ 0x42, 0xbf, 0xd5, 0xe0, 0xda, 0xbc, 0x4b, 0x45, 0xdf, 0x9e, 0x2f, 0x34, 0xfb, 0x96, 0xad, 0xdf,
+ 0xfb, 0x0f, 0x4c, 0x55, 0xd5, 0x57, 0x1a, 0x5c, 0x29, 0xff, 0xec, 0xf4, 0xe6, 0x73, 0xaa, 0xe6,
+ 0x2e, 0x9f, 0xfa, 0xd6, 0x0b, 0x71, 0x54, 0x0d, 0x5f, 0xc2, 0xa5, 0x32, 0xc3, 0xea, 0xef, 0x96,
+ 0x8a, 0xcd, 0xb1, 0x7e, 0xdd, 0x7e, 0x01, 0x86, 0x4a, 0xee, 0x43, 0xb5, 0xe8, 0x2c, 0xfd, 0xad,
+ 0x52, 0x91, 0x52, 0x87, 0xd7, 0x37, 0x9f, 0x0b, 0x9b, 0xa6, 0x6a, 0xfd, 0xad, 0xfd, 0x7c, 0xd2,
+ 0xd0, 0x9e, 0x9d, 0x34, 0xb4, 0x3f, 0x4e, 0x1a, 0xda, 0x37, 0xa7, 0x8d, 0x85, 0x67, 0xa7, 0x8d,
+ 0x85, 0xdf, 0x4e, 0x1b, 0x0b, 0x70, 0xd5, 0xa5, 0xc3, 0x32, 0xa9, 0xd6, 0x8a, 0x72, 0x68, 0x3b,
+ 0x7e, 0x7e, 0xb4, 0xb5, 0x27, 0xfb, 0x7d, 0x5f, 0x1c, 0x47, 0x47, 0xf1, 0xed, 0x6d, 0xb9, 0x94,
+ 0x0f, 0x29, 0xb7, 0x18, 0x0e, 0xd0, 0x08, 0x33, 0x4b, 0x36, 0xc7, 0x4b, 0xf7, 0x18, 0xf9, 0x84,
+ 0x5b, 0x25, 0x4f, 0xba, 0xf7, 0xd5, 0x52, 0xda, 0x3f, 0x54, 0x16, 0xdb, 0x7b, 0x8f, 0x7f, 0xac,
+ 0xd4, 0xda, 0x59, 0x5a, 0x95, 0xca, 0xec, 0xd8, 0xbf, 0x4c, 0xa2, 0x87, 0x2a, 0x7a, 0xd8, 0xb1,
+ 0x4f, 0x2a, 0xaf, 0x95, 0x44, 0x0f, 0x3f, 0x6c, 0xb7, 0x3e, 0xc6, 0x02, 0xc5, 0xef, 0x82, 0x3f,
+ 0x2b, 0x97, 0x33, 0xc4, 0xce, 0x8e, 0x82, 0xec, 0xec, 0x74, 0xec, 0xa3, 0x97, 0x92, 0xe7, 0xd3,
+ 0xd6, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xcc, 0x6b, 0x25, 0x92, 0x66, 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
+
+// CustodyServiceClient is the client API for CustodyService service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type CustodyServiceClient interface {
+ // Requests authorization of the transaction with the given description.
+ Authorize(ctx context.Context, in *AuthorizeRequest, opts ...grpc.CallOption) (*AuthorizeResponse, error)
+ // Requests authorization of the given validator definition update.
+ AuthorizeValidatorDefinition(ctx context.Context, in *AuthorizeValidatorDefinitionRequest, opts ...grpc.CallOption) (*AuthorizeValidatorDefinitionResponse, error)
+ // Requests authorization of the given validator vote.
+ AuthorizeValidatorVote(ctx context.Context, in *AuthorizeValidatorVoteRequest, opts ...grpc.CallOption) (*AuthorizeValidatorVoteResponse, 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 custodyServiceClient struct {
+ cc grpc1.ClientConn
+}
+
+func NewCustodyServiceClient(cc grpc1.ClientConn) CustodyServiceClient {
+ return &custodyServiceClient{cc}
+}
+
+func (c *custodyServiceClient) Authorize(ctx context.Context, in *AuthorizeRequest, opts ...grpc.CallOption) (*AuthorizeResponse, error) {
+ out := new(AuthorizeResponse)
+ err := c.cc.Invoke(ctx, "/penumbra.custody.v1.CustodyService/Authorize", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *custodyServiceClient) AuthorizeValidatorDefinition(ctx context.Context, in *AuthorizeValidatorDefinitionRequest, opts ...grpc.CallOption) (*AuthorizeValidatorDefinitionResponse, error) {
+ out := new(AuthorizeValidatorDefinitionResponse)
+ err := c.cc.Invoke(ctx, "/penumbra.custody.v1.CustodyService/AuthorizeValidatorDefinition", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *custodyServiceClient) AuthorizeValidatorVote(ctx context.Context, in *AuthorizeValidatorVoteRequest, opts ...grpc.CallOption) (*AuthorizeValidatorVoteResponse, error) {
+ out := new(AuthorizeValidatorVoteResponse)
+ err := c.cc.Invoke(ctx, "/penumbra.custody.v1.CustodyService/AuthorizeValidatorVote", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *custodyServiceClient) ExportFullViewingKey(ctx context.Context, in *ExportFullViewingKeyRequest, opts ...grpc.CallOption) (*ExportFullViewingKeyResponse, error) {
+ out := new(ExportFullViewingKeyResponse)
+ err := c.cc.Invoke(ctx, "/penumbra.custody.v1.CustodyService/ExportFullViewingKey", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *custodyServiceClient) ConfirmAddress(ctx context.Context, in *ConfirmAddressRequest, opts ...grpc.CallOption) (*ConfirmAddressResponse, error) {
+ out := new(ConfirmAddressResponse)
+ err := c.cc.Invoke(ctx, "/penumbra.custody.v1.CustodyService/ConfirmAddress", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+// CustodyServiceServer is the server API for CustodyService service.
+type CustodyServiceServer interface {
+ // Requests authorization of the transaction with the given description.
+ Authorize(context.Context, *AuthorizeRequest) (*AuthorizeResponse, error)
+ // Requests authorization of the given validator definition update.
+ AuthorizeValidatorDefinition(context.Context, *AuthorizeValidatorDefinitionRequest) (*AuthorizeValidatorDefinitionResponse, error)
+ // Requests authorization of the given validator vote.
+ AuthorizeValidatorVote(context.Context, *AuthorizeValidatorVoteRequest) (*AuthorizeValidatorVoteResponse, 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)
+}
+
+// UnimplementedCustodyServiceServer can be embedded to have forward compatible implementations.
+type UnimplementedCustodyServiceServer struct {
+}
+
+func (*UnimplementedCustodyServiceServer) Authorize(ctx context.Context, req *AuthorizeRequest) (*AuthorizeResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method Authorize not implemented")
+}
+func (*UnimplementedCustodyServiceServer) AuthorizeValidatorDefinition(ctx context.Context, req *AuthorizeValidatorDefinitionRequest) (*AuthorizeValidatorDefinitionResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method AuthorizeValidatorDefinition not implemented")
+}
+func (*UnimplementedCustodyServiceServer) AuthorizeValidatorVote(ctx context.Context, req *AuthorizeValidatorVoteRequest) (*AuthorizeValidatorVoteResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method AuthorizeValidatorVote not implemented")
+}
+func (*UnimplementedCustodyServiceServer) ExportFullViewingKey(ctx context.Context, req *ExportFullViewingKeyRequest) (*ExportFullViewingKeyResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method ExportFullViewingKey not implemented")
+}
+func (*UnimplementedCustodyServiceServer) ConfirmAddress(ctx context.Context, req *ConfirmAddressRequest) (*ConfirmAddressResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method ConfirmAddress not implemented")
+}
+
+func RegisterCustodyServiceServer(s grpc1.Server, srv CustodyServiceServer) {
+ s.RegisterService(&_CustodyService_serviceDesc, srv)
+}
+
+func _CustodyService_Authorize_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(AuthorizeRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(CustodyServiceServer).Authorize(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/penumbra.custody.v1.CustodyService/Authorize",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(CustodyServiceServer).Authorize(ctx, req.(*AuthorizeRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _CustodyService_AuthorizeValidatorDefinition_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(AuthorizeValidatorDefinitionRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(CustodyServiceServer).AuthorizeValidatorDefinition(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/penumbra.custody.v1.CustodyService/AuthorizeValidatorDefinition",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(CustodyServiceServer).AuthorizeValidatorDefinition(ctx, req.(*AuthorizeValidatorDefinitionRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _CustodyService_AuthorizeValidatorVote_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(AuthorizeValidatorVoteRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(CustodyServiceServer).AuthorizeValidatorVote(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/penumbra.custody.v1.CustodyService/AuthorizeValidatorVote",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(CustodyServiceServer).AuthorizeValidatorVote(ctx, req.(*AuthorizeValidatorVoteRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _CustodyService_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.(CustodyServiceServer).ExportFullViewingKey(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/penumbra.custody.v1.CustodyService/ExportFullViewingKey",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(CustodyServiceServer).ExportFullViewingKey(ctx, req.(*ExportFullViewingKeyRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _CustodyService_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.(CustodyServiceServer).ConfirmAddress(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/penumbra.custody.v1.CustodyService/ConfirmAddress",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(CustodyServiceServer).ConfirmAddress(ctx, req.(*ConfirmAddressRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+var _CustodyService_serviceDesc = grpc.ServiceDesc{
+ ServiceName: "penumbra.custody.v1.CustodyService",
+ HandlerType: (*CustodyServiceServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "Authorize",
+ Handler: _CustodyService_Authorize_Handler,
+ },
+ {
+ MethodName: "AuthorizeValidatorDefinition",
+ Handler: _CustodyService_AuthorizeValidatorDefinition_Handler,
+ },
+ {
+ MethodName: "AuthorizeValidatorVote",
+ Handler: _CustodyService_AuthorizeValidatorVote_Handler,
+ },
+ {
+ MethodName: "ExportFullViewingKey",
+ Handler: _CustodyService_ExportFullViewingKey_Handler,
+ },
+ {
+ MethodName: "ConfirmAddress",
+ Handler: _CustodyService_ConfirmAddress_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "penumbra/custody/v1/custody.proto",
+}
+
+func (m *AuthorizeRequest) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *AuthorizeRequest) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AuthorizeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.PreAuthorizations) > 0 {
+ for iNdEx := len(m.PreAuthorizations) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.PreAuthorizations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintCustody(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x1a
+ }
+ }
+ if m.Plan != nil {
+ {
+ size, err := m.Plan.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 *AuthorizeResponse) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *AuthorizeResponse) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AuthorizeResponse) 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 = encodeVarintCustody(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *AuthorizeValidatorDefinitionRequest) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *AuthorizeValidatorDefinitionRequest) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AuthorizeValidatorDefinitionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.PreAuthorizations) > 0 {
+ for iNdEx := len(m.PreAuthorizations) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.PreAuthorizations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintCustody(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x1a
+ }
+ }
+ if m.ValidatorDefinition != nil {
+ {
+ size, err := m.ValidatorDefinition.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 *AuthorizeValidatorDefinitionResponse) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *AuthorizeValidatorDefinitionResponse) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AuthorizeValidatorDefinitionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.ValidatorDefinitionAuth != nil {
+ {
+ size, err := m.ValidatorDefinitionAuth.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 *AuthorizeValidatorVoteRequest) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *AuthorizeValidatorVoteRequest) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AuthorizeValidatorVoteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.PreAuthorizations) > 0 {
+ for iNdEx := len(m.PreAuthorizations) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.PreAuthorizations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintCustody(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x1a
+ }
+ }
+ if m.ValidatorVote != nil {
+ {
+ size, err := m.ValidatorVote.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 *AuthorizeValidatorVoteResponse) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *AuthorizeValidatorVoteResponse) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AuthorizeValidatorVoteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.ValidatorVoteAuth != nil {
+ {
+ size, err := m.ValidatorVoteAuth.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 *PreAuthorization) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *PreAuthorization) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *PreAuthorization) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.PreAuthorization != nil {
+ {
+ size := m.PreAuthorization.Size()
+ i -= size
+ if _, err := m.PreAuthorization.MarshalTo(dAtA[i:]); err != nil {
+ return 0, err
+ }
+ }
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *PreAuthorization_Ed25519_) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *PreAuthorization_Ed25519_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ if m.Ed25519 != nil {
+ {
+ size, err := m.Ed25519.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 *PreAuthorization_Ed25519) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *PreAuthorization_Ed25519) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *PreAuthorization_Ed25519) 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 = encodeVarintCustody(dAtA, i, uint64(len(m.Sig)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(m.Vk) > 0 {
+ i -= len(m.Vk)
+ copy(dAtA[i:], m.Vk)
+ i = encodeVarintCustody(dAtA, i, uint64(len(m.Vk)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+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
+ }
+ return dAtA[:n], nil
+}
+
+func (m *ExportFullViewingKeyRequest) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ExportFullViewingKeyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ return len(dAtA) - i, nil
+}
+
+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 dAtA[:n], nil
+}
+
+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.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 len(dAtA) - i, nil
+}
+
+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 *AuthorizeValidatorDefinitionRequest) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.ValidatorDefinition != nil {
+ l = m.ValidatorDefinition.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 *AuthorizeValidatorDefinitionResponse) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.ValidatorDefinitionAuth != nil {
+ l = m.ValidatorDefinitionAuth.Size()
+ n += 1 + l + sovCustody(uint64(l))
+ }
+ return n
+}
+
+func (m *AuthorizeValidatorVoteRequest) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.ValidatorVote != nil {
+ l = m.ValidatorVote.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 *AuthorizeValidatorVoteResponse) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.ValidatorVoteAuth != nil {
+ l = m.ValidatorVoteAuth.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
+ l = len(m.Vk)
+ if l > 0 {
+ n += 1 + l + sovCustody(uint64(l))
+ }
+ l = len(m.Sig)
+ if l > 0 {
+ n += 1 + l + sovCustody(uint64(l))
+ }
+ 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
+}
+func sozCustody(x uint64) (n int) {
+ return sovCustody(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *AuthorizeRequest) Unmarshal(dAtA []byte) 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: AuthorizeRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: AuthorizeRequest: 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 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.Plan == nil {
+ m.Plan = &v1.TransactionPlan{}
+ }
+ if err := m.Plan.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)
+ }
+ 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
+ }
+ m.PreAuthorizations = append(m.PreAuthorizations, &PreAuthorization{})
+ if err := m.PreAuthorizations[len(m.PreAuthorizations)-1].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 *AuthorizeResponse) Unmarshal(dAtA []byte) 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: AuthorizeResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: AuthorizeResponse: 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 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.Data == nil {
+ m.Data = &v1.AuthorizationData{}
+ }
+ if err := m.Data.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 *AuthorizeValidatorDefinitionRequest) Unmarshal(dAtA []byte) 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: AuthorizeValidatorDefinitionRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: AuthorizeValidatorDefinitionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ 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 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.ValidatorDefinition == nil {
+ m.ValidatorDefinition = &v11.Validator{}
+ }
+ if err := m.ValidatorDefinition.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)
+ }
+ 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
+ }
+ m.PreAuthorizations = append(m.PreAuthorizations, &PreAuthorization{})
+ if err := m.PreAuthorizations[len(m.PreAuthorizations)-1].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 *AuthorizeValidatorDefinitionResponse) Unmarshal(dAtA []byte) 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: AuthorizeValidatorDefinitionResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: AuthorizeValidatorDefinitionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ValidatorDefinitionAuth", 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.ValidatorDefinitionAuth == nil {
+ m.ValidatorDefinitionAuth = &v12.SpendAuthSignature{}
+ }
+ if err := m.ValidatorDefinitionAuth.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 *AuthorizeValidatorVoteRequest) Unmarshal(dAtA []byte) 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: AuthorizeValidatorVoteRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: AuthorizeValidatorVoteRequest: 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)
+ }
+ 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.ValidatorVote == nil {
+ m.ValidatorVote = &v13.ValidatorVoteBody{}
+ }
+ if err := m.ValidatorVote.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)
+ }
+ 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
+ }
+ m.PreAuthorizations = append(m.PreAuthorizations, &PreAuthorization{})
+ if err := m.PreAuthorizations[len(m.PreAuthorizations)-1].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 *AuthorizeValidatorVoteResponse) Unmarshal(dAtA []byte) 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: AuthorizeValidatorVoteResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: AuthorizeValidatorVoteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ValidatorVoteAuth", 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.ValidatorVoteAuth == nil {
+ m.ValidatorVoteAuth = &v12.SpendAuthSignature{}
+ }
+ if err := m.ValidatorVoteAuth.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 *PreAuthorization) Unmarshal(dAtA []byte) 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: PreAuthorization: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PreAuthorization: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Ed25519", 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
+ }
+ v := &PreAuthorization_Ed25519{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ m.PreAuthorization = &PreAuthorization_Ed25519_{v}
+ 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 *PreAuthorization_Ed25519) Unmarshal(dAtA []byte) 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: Ed25519: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Ed25519: 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 ErrIntOverflowCustody
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ byteLen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if byteLen < 0 {
+ return ErrInvalidLengthCustody
+ }
+ postIndex := iNdEx + byteLen
+ if postIndex < 0 {
+ return ErrInvalidLengthCustody
+ }
+ 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 Sig", wireType)
+ }
+ var byteLen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowCustody
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ byteLen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if byteLen < 0 {
+ return ErrInvalidLengthCustody
+ }
+ postIndex := iNdEx + byteLen
+ if postIndex < 0 {
+ return ErrInvalidLengthCustody
+ }
+ 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 := 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 *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 = &v14.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 = &v14.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 = &v14.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
+ depth := 0
+ for iNdEx < l {
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowCustody
+ }
+ 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, ErrIntOverflowCustody
+ }
+ 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, ErrIntOverflowCustody
+ }
+ 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, ErrInvalidLengthCustody
+ }
+ iNdEx += length
+ case 3:
+ depth++
+ case 4:
+ if depth == 0 {
+ return 0, ErrUnexpectedEndOfGroupCustody
+ }
+ depth--
+ case 5:
+ iNdEx += 4
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ if iNdEx < 0 {
+ return 0, ErrInvalidLengthCustody
+ }
+ if depth == 0 {
+ return iNdEx, nil
+ }
+ }
+ return 0, io.ErrUnexpectedEOF
+}
+
+var (
+ ErrInvalidLengthCustody = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowCustody = fmt.Errorf("proto: integer overflow")
+ ErrUnexpectedEndOfGroupCustody = 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
deleted file mode 100644
index d30aa8c26..000000000
--- a/relayer/chains/penumbra/custody/v1alpha1/custody.pb.go
+++ /dev/null
@@ -1,1213 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: penumbra/custody/v1alpha1/custody.proto
-
-package custodyv1alpha1
-
-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/crypto/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
-
-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.
- //
- // 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"`
-}
-
-func (m *AuthorizeRequest) Reset() { *m = AuthorizeRequest{} }
-func (m *AuthorizeRequest) String() string { return proto.CompactTextString(m) }
-func (*AuthorizeRequest) ProtoMessage() {}
-func (*AuthorizeRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_8c8c99775232419d, []int{0}
-}
-func (m *AuthorizeRequest) XXX_Unmarshal(b []byte) error {
- return m.Unmarshal(b)
-}
-func (m *AuthorizeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- if deterministic {
- return xxx_messageInfo_AuthorizeRequest.Marshal(b, m, deterministic)
- } else {
- b = b[:cap(b)]
- n, err := m.MarshalToSizedBuffer(b)
- if err != nil {
- return nil, err
- }
- return b[:n], nil
- }
-}
-func (m *AuthorizeRequest) XXX_Merge(src proto.Message) {
- xxx_messageInfo_AuthorizeRequest.Merge(m, src)
-}
-func (m *AuthorizeRequest) XXX_Size() int {
- return m.Size()
-}
-func (m *AuthorizeRequest) XXX_DiscardUnknown() {
- xxx_messageInfo_AuthorizeRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_AuthorizeRequest proto.InternalMessageInfo
-
-func (m *AuthorizeRequest) GetPlan() *v1alpha1.TransactionPlan {
- if m != nil {
- return m.Plan
- }
- 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
- }
- return nil
-}
-
-type AuthorizeResponse struct {
- Data *v1alpha1.AuthorizationData `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
-}
-
-func (m *AuthorizeResponse) Reset() { *m = AuthorizeResponse{} }
-func (m *AuthorizeResponse) String() string { return proto.CompactTextString(m) }
-func (*AuthorizeResponse) ProtoMessage() {}
-func (*AuthorizeResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_8c8c99775232419d, []int{1}
-}
-func (m *AuthorizeResponse) XXX_Unmarshal(b []byte) error {
- return m.Unmarshal(b)
-}
-func (m *AuthorizeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- if deterministic {
- return xxx_messageInfo_AuthorizeResponse.Marshal(b, m, deterministic)
- } else {
- b = b[:cap(b)]
- n, err := m.MarshalToSizedBuffer(b)
- if err != nil {
- return nil, err
- }
- return b[:n], nil
- }
-}
-func (m *AuthorizeResponse) XXX_Merge(src proto.Message) {
- xxx_messageInfo_AuthorizeResponse.Merge(m, src)
-}
-func (m *AuthorizeResponse) XXX_Size() int {
- return m.Size()
-}
-func (m *AuthorizeResponse) XXX_DiscardUnknown() {
- xxx_messageInfo_AuthorizeResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_AuthorizeResponse proto.InternalMessageInfo
-
-func (m *AuthorizeResponse) GetData() *v1alpha1.AuthorizationData {
- if m != nil {
- return m.Data
- }
- return nil
-}
-
-// A pre-authorization packet. This allows a custodian to delegate (partial)
-// signing authority to other authorization mechanisms. Details of how a
-// custodian manages those keys are out-of-scope for the custody protocol and
-// are custodian-specific.
-type PreAuthorization struct {
- // Types that are valid to be assigned to PreAuthorization:
- // *PreAuthorization_Ed25519_
- PreAuthorization isPreAuthorization_PreAuthorization `protobuf_oneof:"pre_authorization"`
-}
-
-func (m *PreAuthorization) Reset() { *m = PreAuthorization{} }
-func (m *PreAuthorization) String() string { return proto.CompactTextString(m) }
-func (*PreAuthorization) ProtoMessage() {}
-func (*PreAuthorization) Descriptor() ([]byte, []int) {
- return fileDescriptor_8c8c99775232419d, []int{2}
-}
-func (m *PreAuthorization) XXX_Unmarshal(b []byte) error {
- return m.Unmarshal(b)
-}
-func (m *PreAuthorization) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- if deterministic {
- return xxx_messageInfo_PreAuthorization.Marshal(b, m, deterministic)
- } else {
- b = b[:cap(b)]
- n, err := m.MarshalToSizedBuffer(b)
- if err != nil {
- return nil, err
- }
- return b[:n], nil
- }
-}
-func (m *PreAuthorization) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PreAuthorization.Merge(m, src)
-}
-func (m *PreAuthorization) XXX_Size() int {
- return m.Size()
-}
-func (m *PreAuthorization) XXX_DiscardUnknown() {
- xxx_messageInfo_PreAuthorization.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PreAuthorization proto.InternalMessageInfo
-
-type isPreAuthorization_PreAuthorization interface {
- isPreAuthorization_PreAuthorization()
- MarshalTo([]byte) (int, error)
- Size() int
-}
-
-type PreAuthorization_Ed25519_ struct {
- Ed25519 *PreAuthorization_Ed25519 `protobuf:"bytes,1,opt,name=ed25519,proto3,oneof" json:"ed25519,omitempty"`
-}
-
-func (*PreAuthorization_Ed25519_) isPreAuthorization_PreAuthorization() {}
-
-func (m *PreAuthorization) GetPreAuthorization() isPreAuthorization_PreAuthorization {
- if m != nil {
- return m.PreAuthorization
- }
- return nil
-}
-
-func (m *PreAuthorization) GetEd25519() *PreAuthorization_Ed25519 {
- if x, ok := m.GetPreAuthorization().(*PreAuthorization_Ed25519_); ok {
- return x.Ed25519
- }
- return nil
-}
-
-// XXX_OneofWrappers is for the internal use of the proto package.
-func (*PreAuthorization) XXX_OneofWrappers() []interface{} {
- return []interface{}{
- (*PreAuthorization_Ed25519_)(nil),
- }
-}
-
-// An Ed25519-based preauthorization, containing an Ed25519 signature over the
-// `TransactionPlan`.
-type PreAuthorization_Ed25519 struct {
- // The Ed25519 verification key used to verify the signature.
- Vk []byte `protobuf:"bytes,1,opt,name=vk,proto3" json:"vk,omitempty"`
- // The Ed25519 signature over the `TransactionPlan`.
- Sig []byte `protobuf:"bytes,2,opt,name=sig,proto3" json:"sig,omitempty"`
-}
-
-func (m *PreAuthorization_Ed25519) Reset() { *m = PreAuthorization_Ed25519{} }
-func (m *PreAuthorization_Ed25519) String() string { return proto.CompactTextString(m) }
-func (*PreAuthorization_Ed25519) ProtoMessage() {}
-func (*PreAuthorization_Ed25519) Descriptor() ([]byte, []int) {
- return fileDescriptor_8c8c99775232419d, []int{2, 0}
-}
-func (m *PreAuthorization_Ed25519) XXX_Unmarshal(b []byte) error {
- return m.Unmarshal(b)
-}
-func (m *PreAuthorization_Ed25519) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- if deterministic {
- return xxx_messageInfo_PreAuthorization_Ed25519.Marshal(b, m, deterministic)
- } else {
- b = b[:cap(b)]
- n, err := m.MarshalToSizedBuffer(b)
- if err != nil {
- return nil, err
- }
- return b[:n], nil
- }
-}
-func (m *PreAuthorization_Ed25519) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PreAuthorization_Ed25519.Merge(m, src)
-}
-func (m *PreAuthorization_Ed25519) XXX_Size() int {
- return m.Size()
-}
-func (m *PreAuthorization_Ed25519) XXX_DiscardUnknown() {
- xxx_messageInfo_PreAuthorization_Ed25519.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PreAuthorization_Ed25519 proto.InternalMessageInfo
-
-func (m *PreAuthorization_Ed25519) GetVk() []byte {
- if m != nil {
- return m.Vk
- }
- return nil
-}
-
-func (m *PreAuthorization_Ed25519) GetSig() []byte {
- if m != nil {
- return m.Sig
- }
- 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")
-}
-
-func init() {
- proto.RegisterFile("penumbra/custody/v1alpha1/custody.proto", fileDescriptor_8c8c99775232419d)
-}
-
-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,
-}
-
-// 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
-
-// CustodyProtocolServiceClient is the client API for CustodyProtocolService service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type CustodyProtocolServiceClient interface {
- // Requests authorization of the transaction with the given description.
- Authorize(ctx context.Context, in *AuthorizeRequest, opts ...grpc.CallOption) (*AuthorizeResponse, error)
-}
-
-type custodyProtocolServiceClient struct {
- cc grpc1.ClientConn
-}
-
-func NewCustodyProtocolServiceClient(cc grpc1.ClientConn) CustodyProtocolServiceClient {
- return &custodyProtocolServiceClient{cc}
-}
-
-func (c *custodyProtocolServiceClient) Authorize(ctx context.Context, in *AuthorizeRequest, opts ...grpc.CallOption) (*AuthorizeResponse, error) {
- out := new(AuthorizeResponse)
- err := c.cc.Invoke(ctx, "/penumbra.custody.v1alpha1.CustodyProtocolService/Authorize", 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)
-}
-
-// UnimplementedCustodyProtocolServiceServer can be embedded to have forward compatible implementations.
-type UnimplementedCustodyProtocolServiceServer struct {
-}
-
-func (*UnimplementedCustodyProtocolServiceServer) Authorize(ctx context.Context, req *AuthorizeRequest) (*AuthorizeResponse, error) {
- return nil, status.Errorf(codes.Unimplemented, "method Authorize not implemented")
-}
-
-func RegisterCustodyProtocolServiceServer(s grpc1.Server, srv CustodyProtocolServiceServer) {
- s.RegisterService(&_CustodyProtocolService_serviceDesc, srv)
-}
-
-func _CustodyProtocolService_Authorize_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(AuthorizeRequest)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(CustodyProtocolServiceServer).Authorize(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/penumbra.custody.v1alpha1.CustodyProtocolService/Authorize",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(CustodyProtocolServiceServer).Authorize(ctx, req.(*AuthorizeRequest))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-var _CustodyProtocolService_serviceDesc = grpc.ServiceDesc{
- ServiceName: "penumbra.custody.v1alpha1.CustodyProtocolService",
- HandlerType: (*CustodyProtocolServiceServer)(nil),
- Methods: []grpc.MethodDesc{
- {
- MethodName: "Authorize",
- Handler: _CustodyProtocolService_Authorize_Handler,
- },
- },
- Streams: []grpc.StreamDesc{},
- Metadata: "penumbra/custody/v1alpha1/custody.proto",
-}
-
-func (m *AuthorizeRequest) Marshal() (dAtA []byte, err error) {
- size := m.Size()
- dAtA = make([]byte, size)
- n, err := m.MarshalToSizedBuffer(dAtA[:size])
- if err != nil {
- return nil, err
- }
- return dAtA[:n], nil
-}
-
-func (m *AuthorizeRequest) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *AuthorizeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
- var l int
- _ = l
- if len(m.PreAuthorizations) > 0 {
- for iNdEx := len(m.PreAuthorizations) - 1; iNdEx >= 0; iNdEx-- {
- {
- size, err := m.PreAuthorizations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
- if err != nil {
- return 0, err
- }
- i -= size
- i = encodeVarintCustody(dAtA, i, uint64(size))
- }
- i--
- 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])
- 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 *AuthorizeResponse) Marshal() (dAtA []byte, err error) {
- size := m.Size()
- dAtA = make([]byte, size)
- n, err := m.MarshalToSizedBuffer(dAtA[:size])
- if err != nil {
- return nil, err
- }
- return dAtA[:n], nil
-}
-
-func (m *AuthorizeResponse) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *AuthorizeResponse) 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 = encodeVarintCustody(dAtA, i, uint64(size))
- }
- i--
- dAtA[i] = 0xa
- }
- return len(dAtA) - i, nil
-}
-
-func (m *PreAuthorization) Marshal() (dAtA []byte, err error) {
- size := m.Size()
- dAtA = make([]byte, size)
- n, err := m.MarshalToSizedBuffer(dAtA[:size])
- if err != nil {
- return nil, err
- }
- return dAtA[:n], nil
-}
-
-func (m *PreAuthorization) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *PreAuthorization) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
- var l int
- _ = l
- if m.PreAuthorization != nil {
- {
- size := m.PreAuthorization.Size()
- i -= size
- if _, err := m.PreAuthorization.MarshalTo(dAtA[i:]); err != nil {
- return 0, err
- }
- }
- }
- return len(dAtA) - i, nil
-}
-
-func (m *PreAuthorization_Ed25519_) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *PreAuthorization_Ed25519_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- if m.Ed25519 != nil {
- {
- size, err := m.Ed25519.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 *PreAuthorization_Ed25519) Marshal() (dAtA []byte, err error) {
- size := m.Size()
- dAtA = make([]byte, size)
- n, err := m.MarshalToSizedBuffer(dAtA[:size])
- if err != nil {
- return nil, err
- }
- return dAtA[:n], nil
-}
-
-func (m *PreAuthorization_Ed25519) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *PreAuthorization_Ed25519) 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 = encodeVarintCustody(dAtA, i, uint64(len(m.Sig)))
- i--
- dAtA[i] = 0x12
- }
- if len(m.Vk) > 0 {
- i -= len(m.Vk)
- copy(dAtA[i:], m.Vk)
- i = encodeVarintCustody(dAtA, i, uint64(len(m.Vk)))
- 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 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 *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
- l = len(m.Vk)
- if l > 0 {
- n += 1 + l + sovCustody(uint64(l))
- }
- l = len(m.Sig)
- if l > 0 {
- n += 1 + l + sovCustody(uint64(l))
- }
- return n
-}
-
-func sovCustody(x uint64) (n int) {
- return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozCustody(x uint64) (n int) {
- return sovCustody(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *AuthorizeRequest) Unmarshal(dAtA []byte) 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: AuthorizeRequest: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: AuthorizeRequest: 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 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.Plan == nil {
- m.Plan = &v1alpha1.TransactionPlan{}
- }
- if err := m.Plan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- 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)
- }
- 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
- }
- m.PreAuthorizations = append(m.PreAuthorizations, &PreAuthorization{})
- if err := m.PreAuthorizations[len(m.PreAuthorizations)-1].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 *AuthorizeResponse) Unmarshal(dAtA []byte) 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: AuthorizeResponse: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: AuthorizeResponse: 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 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.Data == nil {
- m.Data = &v1alpha1.AuthorizationData{}
- }
- if err := m.Data.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 *PreAuthorization) Unmarshal(dAtA []byte) 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: PreAuthorization: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: PreAuthorization: illegal tag %d (wire type %d)", fieldNum, wire)
- }
- switch fieldNum {
- case 1:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Ed25519", 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
- }
- v := &PreAuthorization_Ed25519{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
- }
- m.PreAuthorization = &PreAuthorization_Ed25519_{v}
- 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 *PreAuthorization_Ed25519) Unmarshal(dAtA []byte) 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: Ed25519: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: Ed25519: 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 ErrIntOverflowCustody
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- byteLen |= int(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- if byteLen < 0 {
- return ErrInvalidLengthCustody
- }
- postIndex := iNdEx + byteLen
- if postIndex < 0 {
- return ErrInvalidLengthCustody
- }
- 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 Sig", wireType)
- }
- var byteLen int
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowCustody
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- byteLen |= int(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- if byteLen < 0 {
- return ErrInvalidLengthCustody
- }
- postIndex := iNdEx + byteLen
- if postIndex < 0 {
- return ErrInvalidLengthCustody
- }
- 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 := 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
- depth := 0
- for iNdEx < l {
- var wire uint64
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return 0, ErrIntOverflowCustody
- }
- 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, ErrIntOverflowCustody
- }
- 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, ErrIntOverflowCustody
- }
- 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, ErrInvalidLengthCustody
- }
- iNdEx += length
- case 3:
- depth++
- case 4:
- if depth == 0 {
- return 0, ErrUnexpectedEndOfGroupCustody
- }
- depth--
- case 5:
- iNdEx += 4
- default:
- return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
- }
- if iNdEx < 0 {
- return 0, ErrInvalidLengthCustody
- }
- if depth == 0 {
- return iNdEx, nil
- }
- }
- return 0, io.ErrUnexpectedEOF
-}
-
-var (
- ErrInvalidLengthCustody = fmt.Errorf("proto: negative length found during unmarshaling")
- ErrIntOverflowCustody = fmt.Errorf("proto: integer overflow")
- ErrUnexpectedEndOfGroupCustody = fmt.Errorf("proto: unexpected end of group")
-)
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/keys.go b/relayer/chains/penumbra/keys.go
index 0c6131fda..8c112c7e5 100644
--- a/relayer/chains/penumbra/keys.go
+++ b/relayer/chains/penumbra/keys.go
@@ -211,7 +211,7 @@ func CreateMnemonic() (string, error) {
}
// EncodeBech32AccAddr returns the string bech32 representation for the specified account address.
-// It returns an empty sting if the byte slice is 0-length.
+// It returns an empty string if the byte slice is 0-length.
// It returns an error if the bech32 conversion fails or the prefix is empty.
func (cc *PenumbraProvider) EncodeBech32AccAddr(addr sdk.AccAddress) (string, error) {
return sdk.Bech32ifyAddressBytes(cc.PCfg.AccountPrefix, addr)
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..20c64dde5 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,
@@ -165,7 +166,7 @@ func (cc *PenumbraProvider) QueryTendermintProof(ctx context.Context, height int
// ABCI queries at heights 1, 2 or less than or equal to 0 are not supported.
// Base app does not support queries for height less than or equal to 1.
// Therefore, a query at height 2 would be equivalent to a query at height 3.
- // A height of 0 will query with the lastest state.
+ // A height of 0 will query with the latest state.
if height != 0 && height <= 2 {
return nil, nil, clienttypes.Height{}, fmt.Errorf("proof queries at height <= 2 are not supported")
}
@@ -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",
@@ -851,6 +854,10 @@ func (cc *PenumbraProvider) QueryDenomTraces(ctx context.Context, offset, limit
return transfers.DenomTraces, nil
}
+func (cc *PenumbraProvider) QueryDenomHash(ctx context.Context, trace string) (string, error) {
+ panic("not implemented")
+}
+
func (cc *PenumbraProvider) QueryStakingParams(ctx context.Context) (*stakingtypes.Params, error) {
res, err := stakingtypes.NewQueryClient(cc).Params(ctx, &stakingtypes.QueryParamsRequest{})
if err != nil {
@@ -919,10 +926,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/tools/summoning/v1/summoning.pb.go b/relayer/chains/penumbra/tools/summoning/v1/summoning.pb.go
new file mode 100644
index 000000000..09a6b5897
--- /dev/null
+++ b/relayer/chains/penumbra/tools/summoning/v1/summoning.pb.go
@@ -0,0 +1,3693 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: penumbra/tools/summoning/v1/summoning.proto
+
+package summoningv1
+
+import (
+ context "context"
+ fmt "fmt"
+ grpc1 "github.com/cosmos/gogoproto/grpc"
+ proto "github.com/cosmos/gogoproto/proto"
+ v1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/keys/v1"
+ v11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/num/v1"
+ 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_71a21e7f4539269f, []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 *v1.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_71a21e7f4539269f, []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() *v1.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_71a21e7f4539269f, []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_71a21e7f4539269f, []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_71a21e7f4539269f, []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_71a21e7f4539269f, []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_71a21e7f4539269f, []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 *v11.Amount `protobuf:"bytes,3,opt,name=last_slot_bid,json=lastSlotBid,proto3" json:"last_slot_bid,omitempty"`
+ // The participant's current bid.
+ YourBid *v11.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_71a21e7f4539269f, []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() *v11.Amount {
+ if m != nil {
+ return m.LastSlotBid
+ }
+ return nil
+}
+
+func (m *ParticipateResponse_Position) GetYourBid() *v11.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_71a21e7f4539269f, []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_71a21e7f4539269f, []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.v1.ParticipateRequest")
+ proto.RegisterType((*ParticipateRequest_Identify)(nil), "penumbra.tools.summoning.v1.ParticipateRequest.Identify")
+ proto.RegisterType((*ParticipateRequest_Contribution)(nil), "penumbra.tools.summoning.v1.ParticipateRequest.Contribution")
+ proto.RegisterType((*CeremonyCrs)(nil), "penumbra.tools.summoning.v1.CeremonyCrs")
+ proto.RegisterType((*CeremonyLinkingProof)(nil), "penumbra.tools.summoning.v1.CeremonyLinkingProof")
+ proto.RegisterType((*CeremonyParentHashes)(nil), "penumbra.tools.summoning.v1.CeremonyParentHashes")
+ proto.RegisterType((*ParticipateResponse)(nil), "penumbra.tools.summoning.v1.ParticipateResponse")
+ proto.RegisterType((*ParticipateResponse_Position)(nil), "penumbra.tools.summoning.v1.ParticipateResponse.Position")
+ proto.RegisterType((*ParticipateResponse_ContributeNow)(nil), "penumbra.tools.summoning.v1.ParticipateResponse.ContributeNow")
+ proto.RegisterType((*ParticipateResponse_Confirm)(nil), "penumbra.tools.summoning.v1.ParticipateResponse.Confirm")
+}
+
+func init() {
+ proto.RegisterFile("penumbra/tools/summoning/v1/summoning.proto", fileDescriptor_71a21e7f4539269f)
+}
+
+var fileDescriptor_71a21e7f4539269f = []byte{
+ // 888 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x56, 0x4f, 0x8f, 0xe3, 0xb4,
+ 0x1b, 0x6e, 0x3a, 0x7f, 0xda, 0x9f, 0xa7, 0x9d, 0x1f, 0x32, 0xbb, 0x4b, 0x94, 0x65, 0xc3, 0x68,
+ 0x24, 0xc4, 0x20, 0xa4, 0x64, 0x3b, 0x08, 0x18, 0x0a, 0x42, 0x4b, 0xbb, 0x12, 0x45, 0x02, 0x14,
+ 0xd2, 0x51, 0x91, 0xd0, 0x48, 0x91, 0x9b, 0xb8, 0xad, 0xd9, 0xc4, 0x0e, 0xb6, 0xd3, 0x51, 0x8f,
+ 0xf0, 0x09, 0x10, 0x1f, 0x61, 0x8f, 0x48, 0x7c, 0x0f, 0xc4, 0x69, 0x8f, 0x7b, 0x44, 0x33, 0x37,
+ 0x3e, 0x01, 0x47, 0x64, 0xe7, 0x4f, 0x33, 0x0b, 0xaa, 0xa6, 0x5c, 0xf7, 0x54, 0xbf, 0xef, 0xf3,
+ 0x3e, 0x8f, 0xed, 0xd7, 0xe9, 0x63, 0x83, 0x77, 0x52, 0x4c, 0xb3, 0x64, 0xca, 0x91, 0x2b, 0x19,
+ 0x8b, 0x85, 0x2b, 0xb2, 0x24, 0x61, 0x94, 0xd0, 0xb9, 0xbb, 0xec, 0xad, 0x03, 0x27, 0xe5, 0x4c,
+ 0x32, 0x78, 0xbf, 0x2c, 0x76, 0x74, 0xb1, 0xb3, 0xc6, 0x97, 0x3d, 0xeb, 0xa8, 0x52, 0x0a, 0x19,
+ 0xc7, 0xee, 0x13, 0xbc, 0x12, 0x4a, 0x43, 0xfd, 0xe6, 0x74, 0xcb, 0xbe, 0x59, 0x41, 0xb3, 0x44,
+ 0x15, 0xd0, 0x2c, 0xc9, 0xf1, 0xe3, 0xa7, 0xbb, 0x00, 0x7a, 0x88, 0x4b, 0x12, 0x92, 0x14, 0x49,
+ 0xec, 0xe3, 0xef, 0x33, 0x2c, 0x24, 0x9c, 0x80, 0x36, 0x89, 0x30, 0x95, 0x64, 0xb6, 0x32, 0x8d,
+ 0x23, 0xe3, 0xe4, 0xe0, 0xf4, 0xcc, 0xd9, 0xb0, 0x10, 0xe7, 0x9f, 0x12, 0xce, 0xe7, 0x05, 0x7f,
+ 0xd4, 0xf0, 0x2b, 0x2d, 0x38, 0x05, 0x9d, 0x90, 0x51, 0xc9, 0xc9, 0x34, 0x93, 0x84, 0x51, 0xb3,
+ 0xa9, 0xb5, 0x3f, 0xde, 0x56, 0x7b, 0x58, 0xd3, 0x18, 0x35, 0xfc, 0x1b, 0x9a, 0xd6, 0x63, 0xd0,
+ 0x2e, 0xe7, 0x86, 0x67, 0xa0, 0x85, 0xa2, 0x88, 0x63, 0x21, 0x8a, 0x6d, 0xd8, 0xeb, 0xa9, 0x54,
+ 0x43, 0x1c, 0xdd, 0xaa, 0x65, 0xcf, 0xf9, 0x34, 0xaf, 0xf2, 0xcb, 0x72, 0xeb, 0xc7, 0x26, 0xe8,
+ 0xd4, 0xa7, 0x81, 0x03, 0xd0, 0xca, 0xd2, 0x08, 0x49, 0x1c, 0x15, 0x52, 0x27, 0x1b, 0x57, 0x3d,
+ 0xc4, 0x1c, 0x27, 0x8c, 0xae, 0x86, 0x5c, 0xf8, 0x25, 0x11, 0x4e, 0x40, 0x37, 0x1f, 0x06, 0x29,
+ 0x67, 0x6c, 0x26, 0x8a, 0xfd, 0xf7, 0x6e, 0xa5, 0xf4, 0x05, 0xa1, 0x4f, 0x08, 0x9d, 0x7b, 0x8a,
+ 0xe9, 0x77, 0x72, 0x1d, 0x1d, 0x08, 0xa5, 0x9b, 0x22, 0x8e, 0xa9, 0x0c, 0x16, 0x48, 0x2c, 0xb0,
+ 0x30, 0x77, 0xb6, 0xd0, 0xf5, 0x34, 0x73, 0xa4, 0x89, 0x7e, 0x27, 0xad, 0x45, 0x83, 0x3d, 0xb0,
+ 0x93, 0x88, 0xf9, 0xf1, 0x5f, 0x06, 0x38, 0xa8, 0xed, 0x07, 0xde, 0x01, 0x7b, 0x22, 0xc5, 0x34,
+ 0x32, 0xa3, 0x23, 0xe3, 0xa4, 0xe3, 0xe7, 0x01, 0xbc, 0x07, 0xf6, 0x59, 0x26, 0xd3, 0x4c, 0x9a,
+ 0x58, 0xa7, 0x8b, 0x08, 0xbe, 0x09, 0x0e, 0x23, 0x1c, 0xe3, 0x39, 0x92, 0x8c, 0x07, 0x4b, 0x26,
+ 0xb1, 0x39, 0xd3, 0x78, 0xb7, 0xca, 0x4e, 0x98, 0xc4, 0xf0, 0x6d, 0xf0, 0x4a, 0x46, 0x8b, 0x14,
+ 0x0e, 0xc2, 0x18, 0x91, 0xc4, 0x9c, 0xeb, 0xc2, 0xff, 0xaf, 0xf3, 0x43, 0x95, 0x86, 0x10, 0xec,
+ 0x8a, 0x4b, 0x94, 0x9a, 0x0b, 0x0d, 0xeb, 0x31, 0x7c, 0x00, 0x80, 0xfa, 0x2d, 0x88, 0x44, 0x23,
+ 0xff, 0x53, 0x99, 0x9c, 0xf2, 0x3e, 0x78, 0x8d, 0x66, 0x71, 0x4c, 0x66, 0x98, 0x07, 0x11, 0xe6,
+ 0x64, 0x89, 0xd4, 0xa1, 0x06, 0x21, 0x17, 0xe6, 0x77, 0xba, 0xf6, 0x6e, 0x09, 0x3f, 0xae, 0xd0,
+ 0x21, 0x17, 0xc7, 0x3f, 0x34, 0xc1, 0x9d, 0x7f, 0x3b, 0x80, 0x97, 0xb5, 0x07, 0xf5, 0x8f, 0xe5,
+ 0xa5, 0xea, 0xc1, 0x1e, 0x78, 0xf5, 0x86, 0x11, 0x89, 0x94, 0x51, 0x81, 0xe1, 0x37, 0xa0, 0x9d,
+ 0x32, 0x41, 0xb4, 0x99, 0xe5, 0xb6, 0xf0, 0xe1, 0xed, 0xcd, 0x2c, 0xd7, 0x70, 0xbc, 0x42, 0x40,
+ 0x39, 0x65, 0x29, 0x06, 0xe7, 0xe0, 0xb0, 0x72, 0x35, 0x1c, 0x50, 0x76, 0x59, 0x78, 0xc5, 0x27,
+ 0x5b, 0xcb, 0x57, 0x2e, 0x86, 0xbf, 0x62, 0x97, 0xa3, 0x86, 0xdf, 0x0d, 0xeb, 0x09, 0x78, 0x0e,
+ 0x5a, 0x21, 0xa3, 0x33, 0xc2, 0x93, 0xc2, 0x35, 0xce, 0xfe, 0xcb, 0x0c, 0x8a, 0x3f, 0x6a, 0xf8,
+ 0xa5, 0x94, 0xf5, 0xdc, 0x00, 0xed, 0x72, 0x5f, 0xd0, 0x7a, 0xa1, 0x49, 0xdd, 0xda, 0x3e, 0xdf,
+ 0x03, 0xf7, 0x42, 0x46, 0x29, 0x0e, 0x25, 0x8e, 0x82, 0xb4, 0x14, 0xa7, 0x32, 0xf7, 0xc6, 0xae,
+ 0x7f, 0xb7, 0x42, 0xbd, 0x1a, 0x08, 0x1f, 0x81, 0x6e, 0x8c, 0x84, 0x0c, 0x44, 0xcc, 0x64, 0x30,
+ 0x25, 0x51, 0xb1, 0xf6, 0xd7, 0x5f, 0xb0, 0x77, 0x75, 0xd1, 0x29, 0x77, 0x4f, 0x58, 0x46, 0xa5,
+ 0x7f, 0xa0, 0x28, 0xe3, 0x98, 0xc9, 0x01, 0x89, 0xe0, 0x07, 0xa0, 0xbd, 0x62, 0x19, 0xd7, 0xe4,
+ 0xdd, 0x5b, 0x90, 0x5b, 0xaa, 0x7a, 0x40, 0x22, 0xeb, 0x6b, 0xd0, 0xbd, 0xd1, 0x52, 0xf8, 0x08,
+ 0xec, 0xe7, 0xae, 0xb9, 0xf5, 0xc5, 0x50, 0xf0, 0xac, 0x07, 0xa0, 0x55, 0xf4, 0x50, 0x7f, 0xd3,
+ 0x31, 0xcb, 0xa5, 0x76, 0x7d, 0x3d, 0x2e, 0x6c, 0xf8, 0xf4, 0x67, 0x03, 0x58, 0x15, 0x9b, 0x31,
+ 0x1e, 0x11, 0xaa, 0xfe, 0x35, 0x63, 0xcc, 0x97, 0x24, 0xc4, 0x50, 0x82, 0x83, 0xda, 0xe1, 0x40,
+ 0x77, 0xcb, 0x4b, 0xd5, 0x7a, 0xb8, 0xed, 0xb9, 0x9f, 0x18, 0x0f, 0x8d, 0xc1, 0xaf, 0xcd, 0xdf,
+ 0xae, 0x6c, 0xe3, 0xd9, 0x95, 0x6d, 0xfc, 0x71, 0x65, 0x1b, 0x3f, 0x5d, 0xdb, 0x8d, 0x67, 0xd7,
+ 0x76, 0xe3, 0xf9, 0xb5, 0xdd, 0x00, 0x6f, 0x84, 0x2c, 0xd9, 0xa4, 0x39, 0x38, 0x1c, 0x97, 0x91,
+ 0xa7, 0x1e, 0x23, 0x9e, 0xf1, 0xed, 0x78, 0x4e, 0xe4, 0x22, 0x9b, 0x3a, 0x21, 0x4b, 0xdc, 0x90,
+ 0x89, 0x84, 0x09, 0x97, 0xe3, 0x18, 0xad, 0x30, 0x77, 0x97, 0xa7, 0xd5, 0x30, 0x5c, 0x20, 0x42,
+ 0x85, 0xbb, 0xe1, 0x19, 0xf5, 0x51, 0x15, 0x2c, 0x7b, 0x4f, 0x9b, 0x3b, 0xde, 0xf9, 0xf8, 0x97,
+ 0xe6, 0x7d, 0xaf, 0x5c, 0xca, 0xb9, 0x5e, 0x4a, 0x35, 0xb9, 0x33, 0xe9, 0xfd, 0xbe, 0x46, 0x2f,
+ 0x34, 0x7a, 0x51, 0xa1, 0x17, 0x93, 0xde, 0x55, 0xf3, 0xad, 0x0d, 0xe8, 0xc5, 0x67, 0xde, 0xe0,
+ 0x4b, 0x2c, 0x51, 0x84, 0x24, 0xfa, 0xb3, 0x69, 0x97, 0x95, 0xfd, 0xbe, 0x2e, 0xed, 0xf7, 0xab,
+ 0xda, 0x7e, 0x7f, 0xd2, 0x9b, 0xee, 0xeb, 0x77, 0xd7, 0xbb, 0x7f, 0x07, 0x00, 0x00, 0xff, 0xff,
+ 0xb2, 0x9e, 0x63, 0xb4, 0x05, 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.v1.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.v1.CeremonyCoordinatorService",
+ HandlerType: (*CeremonyCoordinatorServiceServer)(nil),
+ Methods: []grpc.MethodDesc{},
+ Streams: []grpc.StreamDesc{
+ {
+ StreamName: "Participate",
+ Handler: _CeremonyCoordinatorService_Participate_Handler,
+ ServerStreams: true,
+ ClientStreams: true,
+ },
+ },
+ Metadata: "penumbra/tools/summoning/v1/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 = &v1.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 = &v11.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 = &v11.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..b923a4fb2 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"
- penumbratypes "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/transaction/v1alpha1"
+ penumbrafee "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/fee/v1"
+ penumbraibctypes "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/ibc/v1"
+ penumbraasset "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/num/v1"
+ penumbratypes "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/transaction/v1"
+ penumbrardsa "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/decaf377_rdsa/v1"
+ penumbracrypto "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/tct/v1"
"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,13 @@ 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)
+ // TODO: this will need to be replaced with an RPC call to the SCT query service once it exists
+ path := fmt.Sprintf("sct/tree/anchor_by_height/%d", height)
req := abci.RequestQuery{
Path: "state/key",
@@ -260,49 +272,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 +309,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 +334,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 +589,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(),
@@ -936,7 +936,7 @@ func (cc *PenumbraProvider) MsgSubmitMisbehaviour(clientID string, misbehaviour
return NewPenumbraMessage(msg), nil
}
-// mustGetHeight takes the height inteface and returns the actual height
+// mustGetHeight takes the height interface and returns the actual height
func mustGetHeight(h ibcexported.Height) clienttypes.Height {
height, ok := h.(clienttypes.Height)
if !ok {
@@ -1389,7 +1389,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 +1626,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 +1887,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 +2021,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 +2041,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 +2065,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 +2073,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 +2097,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 +2268,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/v1/tendermint_proxy.pb.go b/relayer/chains/penumbra/util/tendermint_proxy/v1/tendermint_proxy.pb.go
new file mode 100644
index 000000000..fdb29c87f
--- /dev/null
+++ b/relayer/chains/penumbra/util/tendermint_proxy/v1/tendermint_proxy.pb.go
@@ -0,0 +1,4706 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: penumbra/util/tendermint_proxy/v1/tendermint_proxy.proto
+
+package tendermint_proxyv1
+
+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_bd0bcec0a31e257c, []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_bd0bcec0a31e257c, []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_bd0bcec0a31e257c, []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_bd0bcec0a31e257c, []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_bd0bcec0a31e257c, []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_bd0bcec0a31e257c, []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_bd0bcec0a31e257c, []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_bd0bcec0a31e257c, []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_bd0bcec0a31e257c, []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_bd0bcec0a31e257c, []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_bd0bcec0a31e257c, []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_bd0bcec0a31e257c, []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_bd0bcec0a31e257c, []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_bd0bcec0a31e257c, []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_bd0bcec0a31e257c, []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.v1.GetTxRequest")
+ proto.RegisterType((*GetTxResponse)(nil), "penumbra.util.tendermint_proxy.v1.GetTxResponse")
+ proto.RegisterType((*TxResult)(nil), "penumbra.util.tendermint_proxy.v1.TxResult")
+ proto.RegisterType((*Tag)(nil), "penumbra.util.tendermint_proxy.v1.Tag")
+ proto.RegisterType((*BroadcastTxAsyncRequest)(nil), "penumbra.util.tendermint_proxy.v1.BroadcastTxAsyncRequest")
+ proto.RegisterType((*BroadcastTxAsyncResponse)(nil), "penumbra.util.tendermint_proxy.v1.BroadcastTxAsyncResponse")
+ proto.RegisterType((*BroadcastTxSyncRequest)(nil), "penumbra.util.tendermint_proxy.v1.BroadcastTxSyncRequest")
+ proto.RegisterType((*BroadcastTxSyncResponse)(nil), "penumbra.util.tendermint_proxy.v1.BroadcastTxSyncResponse")
+ proto.RegisterType((*GetStatusRequest)(nil), "penumbra.util.tendermint_proxy.v1.GetStatusRequest")
+ proto.RegisterType((*GetStatusResponse)(nil), "penumbra.util.tendermint_proxy.v1.GetStatusResponse")
+ proto.RegisterType((*SyncInfo)(nil), "penumbra.util.tendermint_proxy.v1.SyncInfo")
+ proto.RegisterType((*ABCIQueryRequest)(nil), "penumbra.util.tendermint_proxy.v1.ABCIQueryRequest")
+ proto.RegisterType((*ABCIQueryResponse)(nil), "penumbra.util.tendermint_proxy.v1.ABCIQueryResponse")
+ proto.RegisterType((*GetBlockByHeightRequest)(nil), "penumbra.util.tendermint_proxy.v1.GetBlockByHeightRequest")
+ proto.RegisterType((*GetBlockByHeightResponse)(nil), "penumbra.util.tendermint_proxy.v1.GetBlockByHeightResponse")
+}
+
+func init() {
+ proto.RegisterFile("penumbra/util/tendermint_proxy/v1/tendermint_proxy.proto", fileDescriptor_bd0bcec0a31e257c)
+}
+
+var fileDescriptor_bd0bcec0a31e257c = []byte{
+ // 1186 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0xcf, 0x6f, 0x1b, 0xc5,
+ 0x17, 0xcf, 0xfa, 0x57, 0xed, 0x97, 0xa6, 0x4d, 0xf6, 0xdb, 0x6f, 0xea, 0x9a, 0xd6, 0x35, 0x8b,
+ 0xa8, 0x22, 0x7e, 0xec, 0x62, 0xb7, 0x87, 0xe2, 0x72, 0xa9, 0x5b, 0x91, 0x06, 0x09, 0x30, 0x1b,
+ 0x27, 0x48, 0x28, 0x92, 0x99, 0xec, 0x4e, 0xd6, 0xab, 0xae, 0x77, 0xa7, 0x3b, 0xb3, 0xc6, 0x3e,
+ 0x21, 0xae, 0x48, 0x48, 0x88, 0x3f, 0x81, 0x0b, 0x12, 0xfc, 0x23, 0x88, 0x53, 0x8f, 0x88, 0x0b,
+ 0x28, 0xb9, 0xf1, 0x0f, 0x70, 0x45, 0xf3, 0x63, 0xed, 0x8d, 0x9d, 0x28, 0x6e, 0x24, 0x6e, 0x6f,
+ 0xdf, 0xbc, 0xcf, 0x9b, 0xcf, 0xbc, 0x79, 0xef, 0x33, 0x36, 0x3c, 0x24, 0x38, 0x4c, 0x86, 0x87,
+ 0x31, 0xb2, 0x12, 0xe6, 0x07, 0x16, 0xc3, 0xa1, 0x8b, 0xe3, 0xa1, 0x1f, 0xb2, 0x3e, 0x89, 0xa3,
+ 0xf1, 0xc4, 0x1a, 0x35, 0x17, 0x7c, 0x26, 0x89, 0x23, 0x16, 0xe9, 0xaf, 0xa7, 0x48, 0x93, 0x23,
+ 0xcd, 0x85, 0xa8, 0x51, 0xb3, 0x76, 0xd7, 0x8b, 0x22, 0x2f, 0xc0, 0x96, 0x00, 0x1c, 0x26, 0x47,
+ 0x16, 0xf3, 0x87, 0x98, 0x32, 0x34, 0x24, 0x32, 0x47, 0xed, 0xce, 0x0c, 0x65, 0x39, 0xf1, 0x84,
+ 0xb0, 0x88, 0xc7, 0x46, 0x47, 0x6a, 0xb9, 0x96, 0x59, 0x26, 0x2d, 0x62, 0xb1, 0x09, 0xc1, 0x54,
+ 0xad, 0xdd, 0xce, 0xac, 0x09, 0xbf, 0x75, 0x18, 0x44, 0xce, 0xf3, 0x73, 0x57, 0xb3, 0xd8, 0xc6,
+ 0xc2, 0xea, 0x08, 0x05, 0xbe, 0x8b, 0x58, 0x14, 0xcb, 0x08, 0xe3, 0x21, 0x5c, 0xdd, 0xc6, 0xac,
+ 0x37, 0xb6, 0xf1, 0x8b, 0x04, 0x53, 0xa6, 0xeb, 0x50, 0x18, 0x20, 0x3a, 0xa8, 0x6a, 0x0d, 0x6d,
+ 0xeb, 0xaa, 0x2d, 0x6c, 0xfd, 0x06, 0x14, 0x49, 0x1c, 0x8d, 0x70, 0x35, 0xd7, 0xd0, 0xb6, 0xca,
+ 0xb6, 0xfc, 0x30, 0x7e, 0xd1, 0x60, 0x4d, 0x41, 0x29, 0x89, 0x42, 0x8a, 0xcf, 0xc4, 0x6e, 0x42,
+ 0x69, 0x80, 0x7d, 0x6f, 0xc0, 0x04, 0xb8, 0x60, 0xab, 0x2f, 0x9e, 0xd3, 0x0f, 0x5d, 0x3c, 0xae,
+ 0xe6, 0x85, 0x5b, 0x7e, 0xe8, 0xcf, 0xa0, 0xc2, 0xc6, 0xfd, 0x18, 0xd3, 0x24, 0x60, 0xd5, 0x42,
+ 0x43, 0xdb, 0x5a, 0x6d, 0xbd, 0x6d, 0x5e, 0x58, 0x7e, 0x53, 0x70, 0x48, 0x02, 0x66, 0x97, 0x99,
+ 0xb2, 0xf4, 0x6b, 0x90, 0x63, 0xe3, 0x6a, 0x51, 0x30, 0xc9, 0xb1, 0xb1, 0xf1, 0x83, 0x06, 0xe5,
+ 0x34, 0x4c, 0x5f, 0x87, 0x7c, 0x10, 0x79, 0x82, 0x67, 0xc5, 0xe6, 0xa6, 0x7e, 0x07, 0xc0, 0x43,
+ 0xb4, 0xff, 0x15, 0x0a, 0x19, 0x76, 0x15, 0xd5, 0x8a, 0x87, 0xe8, 0xe7, 0xc2, 0xa1, 0xdf, 0x82,
+ 0x32, 0x5f, 0x4e, 0x28, 0x76, 0x15, 0xe1, 0x2b, 0x1e, 0xa2, 0x7b, 0x14, 0xbb, 0x7a, 0x1b, 0x0a,
+ 0x0c, 0x79, 0xb4, 0x5a, 0x68, 0xe4, 0xb7, 0x56, 0x5b, 0xf7, 0x96, 0x61, 0x8b, 0x3c, 0x5b, 0x60,
+ 0x8c, 0x27, 0x90, 0xef, 0x21, 0x8f, 0xd3, 0x79, 0x8e, 0x27, 0xaa, 0x6c, 0xdc, 0xe4, 0xd5, 0x19,
+ 0xa1, 0x20, 0x91, 0x15, 0xbf, 0x6a, 0xcb, 0x8f, 0xd3, 0x35, 0x2b, 0xab, 0x9a, 0x19, 0xcf, 0xe0,
+ 0x66, 0x27, 0x8e, 0x90, 0xeb, 0x20, 0xca, 0x7a, 0xe3, 0xc7, 0x74, 0x12, 0x3a, 0xe9, 0x65, 0x6e,
+ 0x42, 0x89, 0xa0, 0x18, 0x0d, 0xa9, 0xca, 0xad, 0xbe, 0xf4, 0xff, 0x43, 0x29, 0xc6, 0x2f, 0xfa,
+ 0x7e, 0x7a, 0xd2, 0x62, 0x8c, 0x5f, 0xec, 0xb8, 0xc6, 0x00, 0xaa, 0x8b, 0x99, 0x66, 0x77, 0xeb,
+ 0x44, 0x2e, 0x16, 0x89, 0x0a, 0xb6, 0xb0, 0xb9, 0xcf, 0x45, 0x0c, 0x29, 0x92, 0xc2, 0x4e, 0x4b,
+ 0x9b, 0x9f, 0x95, 0x36, 0xed, 0x8a, 0xc2, 0xac, 0x2b, 0x8c, 0x6d, 0xd8, 0xcc, 0xec, 0xb4, 0x7b,
+ 0x79, 0xca, 0xde, 0xa9, 0xc3, 0xef, 0xfe, 0x77, 0x8c, 0x75, 0x58, 0xdf, 0xc6, 0x6c, 0x97, 0x21,
+ 0x96, 0x50, 0xc5, 0xd5, 0xf8, 0x53, 0x83, 0x8d, 0x8c, 0x53, 0xed, 0xfb, 0x01, 0x54, 0xc2, 0xc8,
+ 0xc5, 0x7d, 0x3f, 0x3c, 0x8a, 0xc4, 0xe6, 0xab, 0xad, 0xbb, 0x99, 0x3e, 0x30, 0x49, 0x8b, 0x98,
+ 0x4f, 0xf1, 0x11, 0x4a, 0x02, 0xf6, 0x49, 0xe4, 0xe2, 0x9d, 0xf0, 0x28, 0xb2, 0xcb, 0xa1, 0xb2,
+ 0xf8, 0x04, 0xf0, 0xba, 0x4b, 0x74, 0x6e, 0xe9, 0x09, 0xe0, 0x27, 0x97, 0x99, 0xa8, 0xb2, 0xf4,
+ 0x0e, 0x5c, 0x9b, 0x0e, 0xbb, 0x4c, 0x97, 0x17, 0xe9, 0x5e, 0xcb, 0x92, 0x91, 0x62, 0xb1, 0x9f,
+ 0xc6, 0xd9, 0x6b, 0x53, 0x08, 0xcf, 0x61, 0xfc, 0xa3, 0x41, 0x39, 0x4d, 0xad, 0xbf, 0x05, 0x1b,
+ 0x01, 0x62, 0x98, 0xb2, 0xbe, 0x10, 0xa0, 0x7e, 0x66, 0xd6, 0xaf, 0xcb, 0x85, 0x0e, 0xf7, 0x3f,
+ 0xe3, 0x63, 0x7f, 0x0f, 0x94, 0xab, 0x8f, 0x08, 0x91, 0x91, 0xb2, 0xe6, 0x6b, 0xd2, 0xfd, 0x98,
+ 0x10, 0x11, 0x67, 0xc2, 0xff, 0x4e, 0xe7, 0x94, 0x5a, 0x21, 0x67, 0x6c, 0x23, 0x9b, 0x55, 0xca,
+ 0xc6, 0x87, 0x73, 0x1c, 0xb8, 0xce, 0x2a, 0xa1, 0xa8, 0x99, 0x52, 0x84, 0xcd, 0x54, 0x84, 0xcd,
+ 0x5e, 0x2a, 0xc2, 0xa7, 0xf8, 0x71, 0xaf, 0x7e, 0x17, 0x56, 0x1d, 0xc4, 0x9c, 0x81, 0x1f, 0x7a,
+ 0xfd, 0x84, 0x54, 0x2b, 0x62, 0xa0, 0x20, 0x75, 0xed, 0x11, 0x63, 0x00, 0xeb, 0x8f, 0x3b, 0x4f,
+ 0x76, 0x3e, 0x4b, 0x70, 0x3c, 0xc9, 0x68, 0xa3, 0xe8, 0x1e, 0x2d, 0xd3, 0x3d, 0x3a, 0x14, 0x08,
+ 0x62, 0xf2, 0x74, 0x15, 0x5b, 0xd8, 0x19, 0xcd, 0xe3, 0xe7, 0xc8, 0x67, 0x35, 0x4f, 0xea, 0x68,
+ 0x21, 0xab, 0xa3, 0xdf, 0xe4, 0x60, 0x23, 0xb3, 0xd5, 0x19, 0xdd, 0xbb, 0xa6, 0xba, 0xf7, 0xcc,
+ 0x4e, 0x15, 0x37, 0x5b, 0x90, 0xbb, 0x73, 0x7b, 0xa6, 0x12, 0x45, 0xb1, 0xb9, 0x52, 0x56, 0xa5,
+ 0x31, 0xa5, 0x33, 0x34, 0xe6, 0x4a, 0x56, 0x63, 0x1e, 0x42, 0x45, 0x3c, 0x4c, 0xfd, 0x88, 0xd0,
+ 0x6a, 0x79, 0xb1, 0x61, 0xe4, 0xe3, 0x65, 0x76, 0x79, 0xcc, 0xa7, 0x84, 0xda, 0x65, 0xa2, 0xac,
+ 0xcc, 0xa9, 0x2b, 0xa7, 0x4e, 0x7d, 0x1b, 0x2a, 0x9c, 0x3d, 0x25, 0xc8, 0xc1, 0x55, 0x10, 0x44,
+ 0x67, 0x8e, 0x8f, 0x0a, 0xe5, 0xdc, 0x7a, 0xde, 0x68, 0xc2, 0xcd, 0x6d, 0x2c, 0xaf, 0xa7, 0x33,
+ 0x91, 0x57, 0x9d, 0x11, 0x04, 0x95, 0x56, 0xcb, 0xa6, 0x35, 0xbe, 0x86, 0xea, 0x22, 0x44, 0x15,
+ 0xef, 0x01, 0x94, 0x65, 0x7b, 0xf8, 0xae, 0x9a, 0xc0, 0x5b, 0x8b, 0x4d, 0x2f, 0xa0, 0x3b, 0x4f,
+ 0xed, 0x2b, 0x22, 0x74, 0xc7, 0xd5, 0xdf, 0x85, 0xa2, 0x30, 0xd5, 0xd8, 0xdd, 0x3c, 0x07, 0x62,
+ 0xcb, 0xa8, 0xd6, 0x4f, 0x25, 0xd8, 0xec, 0x4d, 0x23, 0xba, 0x7c, 0x12, 0x77, 0x71, 0x3c, 0xf2,
+ 0x1d, 0xac, 0x8f, 0xa1, 0x32, 0xd5, 0x05, 0xfd, 0xfe, 0x12, 0xe3, 0x3b, 0x2f, 0x2d, 0xb5, 0x07,
+ 0xaf, 0x06, 0x92, 0xe7, 0x36, 0x56, 0xf4, 0xef, 0x34, 0x58, 0x9f, 0xd7, 0x70, 0xbd, 0xbd, 0x44,
+ 0xb2, 0x73, 0x9e, 0x90, 0xda, 0xa3, 0x4b, 0x61, 0xa7, 0x7c, 0xbe, 0xd5, 0xe0, 0xfa, 0x9c, 0x40,
+ 0xeb, 0xef, 0xbf, 0x5a, 0xca, 0xcc, 0xeb, 0x50, 0x6b, 0x5f, 0x06, 0x3a, 0x25, 0x13, 0x40, 0x51,
+ 0xfc, 0x60, 0xd1, 0xad, 0xe5, 0xaa, 0x3b, 0xfd, 0x55, 0x54, 0x7b, 0x6f, 0x79, 0xc0, 0x74, 0xb7,
+ 0x31, 0x54, 0xa6, 0x63, 0xbd, 0x54, 0x13, 0xcc, 0xeb, 0xcd, 0x52, 0x4d, 0xb0, 0xa0, 0x1c, 0xaa,
+ 0x09, 0xe6, 0x67, 0x63, 0xa9, 0x26, 0x38, 0x67, 0x06, 0x97, 0x6a, 0x82, 0xf3, 0x86, 0xd1, 0x58,
+ 0xe9, 0xfc, 0x91, 0xfb, 0xf5, 0xb8, 0xae, 0xbd, 0x3c, 0xae, 0x6b, 0x7f, 0x1d, 0xd7, 0xb5, 0xef,
+ 0x4f, 0xea, 0x2b, 0x2f, 0x4f, 0xea, 0x2b, 0xbf, 0x9f, 0xd4, 0x57, 0xe0, 0x4d, 0x27, 0x1a, 0x5e,
+ 0x9c, 0xbc, 0x73, 0x63, 0x6e, 0xd0, 0xba, 0x5c, 0xe2, 0xbb, 0xda, 0x17, 0x5f, 0x7a, 0x3e, 0x1b,
+ 0x24, 0x87, 0xa6, 0x13, 0x0d, 0x2d, 0x27, 0xa2, 0xc3, 0x88, 0x5a, 0x31, 0x0e, 0xd0, 0x04, 0xc7,
+ 0xd6, 0xa8, 0x35, 0x35, 0x9d, 0x01, 0xf2, 0x43, 0x6a, 0x5d, 0xf8, 0x07, 0xe0, 0xd1, 0xbc, 0x6f,
+ 0xd4, 0xfc, 0x31, 0x97, 0xef, 0xee, 0xf5, 0x7e, 0xce, 0x35, 0xba, 0x29, 0xc7, 0x3d, 0xce, 0x71,
+ 0x8e, 0x8e, 0xb9, 0xdf, 0xfc, 0x6d, 0x16, 0x72, 0xc0, 0x43, 0x0e, 0xe6, 0x42, 0x0e, 0xf6, 0x9b,
+ 0xc7, 0xb9, 0x77, 0x2e, 0x0a, 0x39, 0xd8, 0xee, 0x76, 0x3e, 0xc6, 0x0c, 0xf1, 0xa7, 0xe5, 0xef,
+ 0xdc, 0x1b, 0x69, 0x78, 0xbb, 0xcd, 0xe3, 0xdb, 0xed, 0x39, 0x40, 0xbb, 0xbd, 0xdf, 0x3c, 0x2c,
+ 0x89, 0xe7, 0xee, 0xfe, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x94, 0x8b, 0xa7, 0xe6, 0xe0, 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
+
+// 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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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.v1.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/v1/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/v1/view.pb.go
similarity index 60%
rename from relayer/chains/penumbra/view/v1alpha1/view.pb.go
rename to relayer/chains/penumbra/view/v1/view.pb.go
index 35056567e..1822d37a9 100644
--- a/relayer/chains/penumbra/view/v1alpha1/view.pb.go
+++ b/relayer/chains/penumbra/view/v1/view.pb.go
@@ -1,19 +1,27 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: penumbra/view/v1alpha1/view.proto
+// source: penumbra/view/v1/view.proto
-package viewv1alpha1
+package viewv1
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/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"
- v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/transaction/v1alpha1"
+ v111 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/app/v1"
+ v16 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/asset/v1"
+ v110 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/dex/v1"
+ v14 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/fee/v1"
+ v13 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/ibc/v1"
+ v15 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/sct/v1"
+ v112 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/shielded_pool/v1"
+ v19 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/stake/v1"
+ v12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/keys/v1"
+ v18 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/num/v1"
+ v1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/transaction/v1"
+ v11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/txhash/v1"
+ v17 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/tct/v1"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
@@ -33,18 +41,52 @@ var _ = math.Inf
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+type DelegationsByAddressIndexRequest_Filter int32
+
+const (
+ // By default, returns delegations for all active validators. For validators
+ // that the given address index has no delegation tokens for, a `ValueView`
+ // with a balance of `0` will be returned.
+ DelegationsByAddressIndexRequest_FILTER_UNSPECIFIED DelegationsByAddressIndexRequest_Filter = 0
+ // Returns only delegations to active validators that the given address
+ // index holds delegation tokens for.
+ DelegationsByAddressIndexRequest_FILTER_ALL_ACTIVE_WITH_NONZERO_BALANCES DelegationsByAddressIndexRequest_Filter = 1
+ // Return delegations for all validators, whether active or not. For
+ // validators that the given address index has no delegation tokens for, a
+ // `ValueView` with a balance of `0` will be returned.
+ DelegationsByAddressIndexRequest_FILTER_ALL DelegationsByAddressIndexRequest_Filter = 2
+)
+
+var DelegationsByAddressIndexRequest_Filter_name = map[int32]string{
+ 0: "FILTER_UNSPECIFIED",
+ 1: "FILTER_ALL_ACTIVE_WITH_NONZERO_BALANCES",
+ 2: "FILTER_ALL",
+}
+
+var DelegationsByAddressIndexRequest_Filter_value = map[string]int32{
+ "FILTER_UNSPECIFIED": 0,
+ "FILTER_ALL_ACTIVE_WITH_NONZERO_BALANCES": 1,
+ "FILTER_ALL": 2,
+}
+
+func (x DelegationsByAddressIndexRequest_Filter) String() string {
+ return proto.EnumName(DelegationsByAddressIndexRequest_Filter_name, int32(x))
+}
+
+func (DelegationsByAddressIndexRequest_Filter) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_dba93d04e42ddfc3, []int{55, 0}
+}
+
type AuthorizeAndBuildRequest struct {
// The transaction plan to authorize and build.
- TransactionPlan *v1alpha1.TransactionPlan `protobuf:"bytes,1,opt,name=transaction_plan,json=transactionPlan,proto3" json:"transaction_plan,omitempty"`
- // The authorization data to use to authorize the transaction plan.
- AuthorizationData *v1alpha1.AuthorizationData `protobuf:"bytes,2,opt,name=authorization_data,json=authorizationData,proto3" json:"authorization_data,omitempty"`
+ TransactionPlan *v1.TransactionPlan `protobuf:"bytes,1,opt,name=transaction_plan,json=transactionPlan,proto3" json:"transaction_plan,omitempty"`
}
func (m *AuthorizeAndBuildRequest) Reset() { *m = AuthorizeAndBuildRequest{} }
func (m *AuthorizeAndBuildRequest) String() string { return proto.CompactTextString(m) }
func (*AuthorizeAndBuildRequest) ProtoMessage() {}
func (*AuthorizeAndBuildRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_0aa947b204e6a7c2, []int{0}
+ return fileDescriptor_dba93d04e42ddfc3, []int{0}
}
func (m *AuthorizeAndBuildRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -73,30 +115,25 @@ func (m *AuthorizeAndBuildRequest) XXX_DiscardUnknown() {
var xxx_messageInfo_AuthorizeAndBuildRequest proto.InternalMessageInfo
-func (m *AuthorizeAndBuildRequest) GetTransactionPlan() *v1alpha1.TransactionPlan {
+func (m *AuthorizeAndBuildRequest) GetTransactionPlan() *v1.TransactionPlan {
if m != nil {
return m.TransactionPlan
}
return nil
}
-func (m *AuthorizeAndBuildRequest) GetAuthorizationData() *v1alpha1.AuthorizationData {
- if m != nil {
- return m.AuthorizationData
- }
- return nil
-}
-
type AuthorizeAndBuildResponse struct {
- // The transaction that was built.
- Transaction *v1alpha1.Transaction `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"`
+ // Types that are valid to be assigned to Status:
+ // *AuthorizeAndBuildResponse_BuildProgress_
+ // *AuthorizeAndBuildResponse_Complete_
+ Status isAuthorizeAndBuildResponse_Status `protobuf_oneof:"status"`
}
func (m *AuthorizeAndBuildResponse) Reset() { *m = AuthorizeAndBuildResponse{} }
func (m *AuthorizeAndBuildResponse) String() string { return proto.CompactTextString(m) }
func (*AuthorizeAndBuildResponse) ProtoMessage() {}
func (*AuthorizeAndBuildResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_0aa947b204e6a7c2, []int{1}
+ return fileDescriptor_dba93d04e42ddfc3, []int{1}
}
func (m *AuthorizeAndBuildResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -125,7 +162,139 @@ func (m *AuthorizeAndBuildResponse) XXX_DiscardUnknown() {
var xxx_messageInfo_AuthorizeAndBuildResponse proto.InternalMessageInfo
-func (m *AuthorizeAndBuildResponse) GetTransaction() *v1alpha1.Transaction {
+type isAuthorizeAndBuildResponse_Status interface {
+ isAuthorizeAndBuildResponse_Status()
+ MarshalTo([]byte) (int, error)
+ Size() int
+}
+
+type AuthorizeAndBuildResponse_BuildProgress_ struct {
+ BuildProgress *AuthorizeAndBuildResponse_BuildProgress `protobuf:"bytes,1,opt,name=build_progress,json=buildProgress,proto3,oneof" json:"build_progress,omitempty"`
+}
+type AuthorizeAndBuildResponse_Complete_ struct {
+ Complete *AuthorizeAndBuildResponse_Complete `protobuf:"bytes,2,opt,name=complete,proto3,oneof" json:"complete,omitempty"`
+}
+
+func (*AuthorizeAndBuildResponse_BuildProgress_) isAuthorizeAndBuildResponse_Status() {}
+func (*AuthorizeAndBuildResponse_Complete_) isAuthorizeAndBuildResponse_Status() {}
+
+func (m *AuthorizeAndBuildResponse) GetStatus() isAuthorizeAndBuildResponse_Status {
+ if m != nil {
+ return m.Status
+ }
+ return nil
+}
+
+func (m *AuthorizeAndBuildResponse) GetBuildProgress() *AuthorizeAndBuildResponse_BuildProgress {
+ if x, ok := m.GetStatus().(*AuthorizeAndBuildResponse_BuildProgress_); ok {
+ return x.BuildProgress
+ }
+ return nil
+}
+
+func (m *AuthorizeAndBuildResponse) GetComplete() *AuthorizeAndBuildResponse_Complete {
+ if x, ok := m.GetStatus().(*AuthorizeAndBuildResponse_Complete_); ok {
+ return x.Complete
+ }
+ return nil
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*AuthorizeAndBuildResponse) XXX_OneofWrappers() []interface{} {
+ return []interface{}{
+ (*AuthorizeAndBuildResponse_BuildProgress_)(nil),
+ (*AuthorizeAndBuildResponse_Complete_)(nil),
+ }
+}
+
+// Signals that building is in progress.
+type AuthorizeAndBuildResponse_BuildProgress struct {
+ // An approximate progress of the build, from 0 to 1.
+ Progress float32 `protobuf:"fixed32,1,opt,name=progress,proto3" json:"progress,omitempty"`
+}
+
+func (m *AuthorizeAndBuildResponse_BuildProgress) Reset() {
+ *m = AuthorizeAndBuildResponse_BuildProgress{}
+}
+func (m *AuthorizeAndBuildResponse_BuildProgress) String() string { return proto.CompactTextString(m) }
+func (*AuthorizeAndBuildResponse_BuildProgress) ProtoMessage() {}
+func (*AuthorizeAndBuildResponse_BuildProgress) Descriptor() ([]byte, []int) {
+ return fileDescriptor_dba93d04e42ddfc3, []int{1, 0}
+}
+func (m *AuthorizeAndBuildResponse_BuildProgress) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *AuthorizeAndBuildResponse_BuildProgress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_AuthorizeAndBuildResponse_BuildProgress.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *AuthorizeAndBuildResponse_BuildProgress) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_AuthorizeAndBuildResponse_BuildProgress.Merge(m, src)
+}
+func (m *AuthorizeAndBuildResponse_BuildProgress) XXX_Size() int {
+ return m.Size()
+}
+func (m *AuthorizeAndBuildResponse_BuildProgress) XXX_DiscardUnknown() {
+ xxx_messageInfo_AuthorizeAndBuildResponse_BuildProgress.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AuthorizeAndBuildResponse_BuildProgress proto.InternalMessageInfo
+
+func (m *AuthorizeAndBuildResponse_BuildProgress) GetProgress() float32 {
+ if m != nil {
+ return m.Progress
+ }
+ return 0
+}
+
+// Signals that the transaction is complete.
+type AuthorizeAndBuildResponse_Complete struct {
+ // The finished transaction.
+ Transaction *v1.Transaction `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"`
+}
+
+func (m *AuthorizeAndBuildResponse_Complete) Reset() { *m = AuthorizeAndBuildResponse_Complete{} }
+func (m *AuthorizeAndBuildResponse_Complete) String() string { return proto.CompactTextString(m) }
+func (*AuthorizeAndBuildResponse_Complete) ProtoMessage() {}
+func (*AuthorizeAndBuildResponse_Complete) Descriptor() ([]byte, []int) {
+ return fileDescriptor_dba93d04e42ddfc3, []int{1, 1}
+}
+func (m *AuthorizeAndBuildResponse_Complete) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *AuthorizeAndBuildResponse_Complete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_AuthorizeAndBuildResponse_Complete.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *AuthorizeAndBuildResponse_Complete) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_AuthorizeAndBuildResponse_Complete.Merge(m, src)
+}
+func (m *AuthorizeAndBuildResponse_Complete) XXX_Size() int {
+ return m.Size()
+}
+func (m *AuthorizeAndBuildResponse_Complete) XXX_DiscardUnknown() {
+ xxx_messageInfo_AuthorizeAndBuildResponse_Complete.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AuthorizeAndBuildResponse_Complete proto.InternalMessageInfo
+
+func (m *AuthorizeAndBuildResponse_Complete) GetTransaction() *v1.Transaction {
if m != nil {
return m.Transaction
}
@@ -134,7 +303,7 @@ func (m *AuthorizeAndBuildResponse) GetTransaction() *v1alpha1.Transaction {
type BroadcastTransactionRequest struct {
// The transaction to broadcast.
- Transaction *v1alpha1.Transaction `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"`
+ Transaction *v1.Transaction `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"`
// If true, wait for the view service to detect the transaction during sync.
AwaitDetection bool `protobuf:"varint,2,opt,name=await_detection,json=awaitDetection,proto3" json:"await_detection,omitempty"`
}
@@ -143,7 +312,7 @@ func (m *BroadcastTransactionRequest) Reset() { *m = BroadcastTransactio
func (m *BroadcastTransactionRequest) String() string { return proto.CompactTextString(m) }
func (*BroadcastTransactionRequest) ProtoMessage() {}
func (*BroadcastTransactionRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_0aa947b204e6a7c2, []int{2}
+ return fileDescriptor_dba93d04e42ddfc3, []int{2}
}
func (m *BroadcastTransactionRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -172,7 +341,7 @@ func (m *BroadcastTransactionRequest) XXX_DiscardUnknown() {
var xxx_messageInfo_BroadcastTransactionRequest proto.InternalMessageInfo
-func (m *BroadcastTransactionRequest) GetTransaction() *v1alpha1.Transaction {
+func (m *BroadcastTransactionRequest) GetTransaction() *v1.Transaction {
if m != nil {
return m.Transaction
}
@@ -187,18 +356,17 @@ 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"`
- // 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"`
+ // Types that are valid to be assigned to Status:
+ // *BroadcastTransactionResponse_BroadcastSuccess_
+ // *BroadcastTransactionResponse_Confirmed_
+ Status isBroadcastTransactionResponse_Status `protobuf_oneof:"status"`
}
func (m *BroadcastTransactionResponse) Reset() { *m = BroadcastTransactionResponse{} }
func (m *BroadcastTransactionResponse) String() string { return proto.CompactTextString(m) }
func (*BroadcastTransactionResponse) ProtoMessage() {}
func (*BroadcastTransactionResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_0aa947b204e6a7c2, []int{3}
+ return fileDescriptor_dba93d04e42ddfc3, []int{3}
}
func (m *BroadcastTransactionResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -227,14 +395,154 @@ func (m *BroadcastTransactionResponse) XXX_DiscardUnknown() {
var xxx_messageInfo_BroadcastTransactionResponse proto.InternalMessageInfo
-func (m *BroadcastTransactionResponse) GetId() *v1alpha1.Id {
+type isBroadcastTransactionResponse_Status interface {
+ isBroadcastTransactionResponse_Status()
+ MarshalTo([]byte) (int, error)
+ Size() int
+}
+
+type BroadcastTransactionResponse_BroadcastSuccess_ struct {
+ BroadcastSuccess *BroadcastTransactionResponse_BroadcastSuccess `protobuf:"bytes,1,opt,name=broadcast_success,json=broadcastSuccess,proto3,oneof" json:"broadcast_success,omitempty"`
+}
+type BroadcastTransactionResponse_Confirmed_ struct {
+ Confirmed *BroadcastTransactionResponse_Confirmed `protobuf:"bytes,2,opt,name=confirmed,proto3,oneof" json:"confirmed,omitempty"`
+}
+
+func (*BroadcastTransactionResponse_BroadcastSuccess_) isBroadcastTransactionResponse_Status() {}
+func (*BroadcastTransactionResponse_Confirmed_) isBroadcastTransactionResponse_Status() {}
+
+func (m *BroadcastTransactionResponse) GetStatus() isBroadcastTransactionResponse_Status {
+ if m != nil {
+ return m.Status
+ }
+ return nil
+}
+
+func (m *BroadcastTransactionResponse) GetBroadcastSuccess() *BroadcastTransactionResponse_BroadcastSuccess {
+ if x, ok := m.GetStatus().(*BroadcastTransactionResponse_BroadcastSuccess_); ok {
+ return x.BroadcastSuccess
+ }
+ return nil
+}
+
+func (m *BroadcastTransactionResponse) GetConfirmed() *BroadcastTransactionResponse_Confirmed {
+ if x, ok := m.GetStatus().(*BroadcastTransactionResponse_Confirmed_); ok {
+ return x.Confirmed
+ }
+ return nil
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*BroadcastTransactionResponse) XXX_OneofWrappers() []interface{} {
+ return []interface{}{
+ (*BroadcastTransactionResponse_BroadcastSuccess_)(nil),
+ (*BroadcastTransactionResponse_Confirmed_)(nil),
+ }
+}
+
+// Signals that the transaction was broadcast successfully (but has not been confirmed).
+type BroadcastTransactionResponse_BroadcastSuccess struct {
+ // The hash of the transaction that was broadcast.
+ Id *v11.TransactionId `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+}
+
+func (m *BroadcastTransactionResponse_BroadcastSuccess) Reset() {
+ *m = BroadcastTransactionResponse_BroadcastSuccess{}
+}
+func (m *BroadcastTransactionResponse_BroadcastSuccess) String() string {
+ return proto.CompactTextString(m)
+}
+func (*BroadcastTransactionResponse_BroadcastSuccess) ProtoMessage() {}
+func (*BroadcastTransactionResponse_BroadcastSuccess) Descriptor() ([]byte, []int) {
+ return fileDescriptor_dba93d04e42ddfc3, []int{3, 0}
+}
+func (m *BroadcastTransactionResponse_BroadcastSuccess) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *BroadcastTransactionResponse_BroadcastSuccess) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_BroadcastTransactionResponse_BroadcastSuccess.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *BroadcastTransactionResponse_BroadcastSuccess) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_BroadcastTransactionResponse_BroadcastSuccess.Merge(m, src)
+}
+func (m *BroadcastTransactionResponse_BroadcastSuccess) XXX_Size() int {
+ return m.Size()
+}
+func (m *BroadcastTransactionResponse_BroadcastSuccess) XXX_DiscardUnknown() {
+ xxx_messageInfo_BroadcastTransactionResponse_BroadcastSuccess.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BroadcastTransactionResponse_BroadcastSuccess proto.InternalMessageInfo
+
+func (m *BroadcastTransactionResponse_BroadcastSuccess) GetId() *v11.TransactionId {
+ if m != nil {
+ return m.Id
+ }
+ return nil
+}
+
+// Signals that the transaction has been confirmed on-chain and detected by the view server.
+//
+// Will not be sent unless await_detection was true.
+type BroadcastTransactionResponse_Confirmed struct {
+ // The hash of the transaction that was broadcast.
+ Id *v11.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.
+ DetectionHeight uint64 `protobuf:"varint,2,opt,name=detection_height,json=detectionHeight,proto3" json:"detection_height,omitempty"`
+}
+
+func (m *BroadcastTransactionResponse_Confirmed) Reset() {
+ *m = BroadcastTransactionResponse_Confirmed{}
+}
+func (m *BroadcastTransactionResponse_Confirmed) String() string { return proto.CompactTextString(m) }
+func (*BroadcastTransactionResponse_Confirmed) ProtoMessage() {}
+func (*BroadcastTransactionResponse_Confirmed) Descriptor() ([]byte, []int) {
+ return fileDescriptor_dba93d04e42ddfc3, []int{3, 1}
+}
+func (m *BroadcastTransactionResponse_Confirmed) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *BroadcastTransactionResponse_Confirmed) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_BroadcastTransactionResponse_Confirmed.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *BroadcastTransactionResponse_Confirmed) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_BroadcastTransactionResponse_Confirmed.Merge(m, src)
+}
+func (m *BroadcastTransactionResponse_Confirmed) XXX_Size() int {
+ return m.Size()
+}
+func (m *BroadcastTransactionResponse_Confirmed) XXX_DiscardUnknown() {
+ xxx_messageInfo_BroadcastTransactionResponse_Confirmed.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BroadcastTransactionResponse_Confirmed proto.InternalMessageInfo
+
+func (m *BroadcastTransactionResponse_Confirmed) GetId() *v11.TransactionId {
if m != nil {
return m.Id
}
return nil
}
-func (m *BroadcastTransactionResponse) GetDetectionHeight() uint64 {
+func (m *BroadcastTransactionResponse_Confirmed) GetDetectionHeight() uint64 {
if m != nil {
return m.DetectionHeight
}
@@ -244,27 +552,40 @@ func (m *BroadcastTransactionResponse) GetDetectionHeight() uint64 {
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
- 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"`
+ // The memo for the requested TransactionPlan.
+ // The memo must be unspecified unless `outputs` is nonempty.
+ Memo *v1.MemoPlaintext `protobuf:"bytes,3,opt,name=memo,proto3" json:"memo,omitempty"`
+ // If present, only spends funds from the given account.
+ Source *v12.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"`
+ UndelegationClaims []*TransactionPlannerRequest_UndelegateClaim `protobuf:"bytes,51,rep,name=undelegation_claims,json=undelegationClaims,proto3" json:"undelegation_claims,omitempty"`
+ IbcRelayActions []*v13.IbcRelay `protobuf:"bytes,60,rep,name=ibc_relay_actions,json=ibcRelayActions,proto3" json:"ibc_relay_actions,omitempty"`
+ Ics20Withdrawals []*v13.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"`
+ // Specifies either that the planner should compute fees automatically or that it should use a fixed fee amount.
+ //
+ // Types that are valid to be assigned to FeeMode:
+ // *TransactionPlannerRequest_AutoFee
+ // *TransactionPlannerRequest_ManualFee
+ FeeMode isTransactionPlannerRequest_FeeMode `protobuf_oneof:"fee_mode"`
+ // The epoch index of the transaction being planned.
+ EpochIndex uint64 `protobuf:"varint,200,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"` // Deprecated: Do not use.
+ // The epoch of the transaction being planned.
+ Epoch *v15.Epoch `protobuf:"bytes,201,opt,name=epoch,proto3" json:"epoch,omitempty"`
}
func (m *TransactionPlannerRequest) Reset() { *m = TransactionPlannerRequest{} }
func (m *TransactionPlannerRequest) String() string { return proto.CompactTextString(m) }
func (*TransactionPlannerRequest) ProtoMessage() {}
func (*TransactionPlannerRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_0aa947b204e6a7c2, []int{4}
+ return fileDescriptor_dba93d04e42ddfc3, []int{4}
}
func (m *TransactionPlannerRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -293,21 +614,25 @@ func (m *TransactionPlannerRequest) XXX_DiscardUnknown() {
var xxx_messageInfo_TransactionPlannerRequest proto.InternalMessageInfo
-type isTransactionPlannerRequest_XAccountGroupId interface {
- isTransactionPlannerRequest_XAccountGroupId()
+type isTransactionPlannerRequest_FeeMode interface {
+ isTransactionPlannerRequest_FeeMode()
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"`
+type TransactionPlannerRequest_AutoFee struct {
+ AutoFee *v14.FeeTier `protobuf:"bytes,100,opt,name=auto_fee,json=autoFee,proto3,oneof" json:"auto_fee,omitempty"`
+}
+type TransactionPlannerRequest_ManualFee struct {
+ ManualFee *v14.Fee `protobuf:"bytes,101,opt,name=manual_fee,json=manualFee,proto3,oneof" json:"manual_fee,omitempty"`
}
-func (*TransactionPlannerRequest_AccountGroupId) isTransactionPlannerRequest_XAccountGroupId() {}
+func (*TransactionPlannerRequest_AutoFee) isTransactionPlannerRequest_FeeMode() {}
+func (*TransactionPlannerRequest_ManualFee) isTransactionPlannerRequest_FeeMode() {}
-func (m *TransactionPlannerRequest) GetXAccountGroupId() isTransactionPlannerRequest_XAccountGroupId {
+func (m *TransactionPlannerRequest) GetFeeMode() isTransactionPlannerRequest_FeeMode {
if m != nil {
- return m.XAccountGroupId
+ return m.FeeMode
}
return nil
}
@@ -319,23 +644,16 @@ func (m *TransactionPlannerRequest) GetExpiryHeight() uint64 {
return 0
}
-func (m *TransactionPlannerRequest) GetFee() *v1alpha11.Fee {
- if m != nil {
- return m.Fee
- }
- return nil
-}
-
-func (m *TransactionPlannerRequest) GetMemo() *v1alpha1.MemoPlaintext {
+func (m *TransactionPlannerRequest) GetMemo() *v1.MemoPlaintext {
if m != nil {
return m.Memo
}
return nil
}
-func (m *TransactionPlannerRequest) GetAccountGroupId() *v1alpha11.AccountGroupId {
- if x, ok := m.GetXAccountGroupId().(*TransactionPlannerRequest_AccountGroupId); ok {
- return x.AccountGroupId
+func (m *TransactionPlannerRequest) GetSource() *v12.AddressIndex {
+ if m != nil {
+ return m.Source
}
return nil
}
@@ -375,9 +693,73 @@ func (m *TransactionPlannerRequest) GetUndelegations() []*TransactionPlannerRequ
return nil
}
-func (m *TransactionPlannerRequest) GetIbcActions() []*v1alpha12.IbcAction {
+func (m *TransactionPlannerRequest) GetUndelegationClaims() []*TransactionPlannerRequest_UndelegateClaim {
+ if m != nil {
+ return m.UndelegationClaims
+ }
+ return nil
+}
+
+func (m *TransactionPlannerRequest) GetIbcRelayActions() []*v13.IbcRelay {
+ if m != nil {
+ return m.IbcRelayActions
+ }
+ return nil
+}
+
+func (m *TransactionPlannerRequest) GetIcs20Withdrawals() []*v13.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.PositionCloses
+ }
+ return nil
+}
+
+func (m *TransactionPlannerRequest) GetPositionWithdraws() []*TransactionPlannerRequest_PositionWithdraw {
+ if m != nil {
+ return m.PositionWithdraws
+ }
+ return nil
+}
+
+func (m *TransactionPlannerRequest) GetAutoFee() *v14.FeeTier {
+ if x, ok := m.GetFeeMode().(*TransactionPlannerRequest_AutoFee); ok {
+ return x.AutoFee
+ }
+ return nil
+}
+
+func (m *TransactionPlannerRequest) GetManualFee() *v14.Fee {
+ if x, ok := m.GetFeeMode().(*TransactionPlannerRequest_ManualFee); ok {
+ return x.ManualFee
+ }
+ return nil
+}
+
+// Deprecated: Do not use.
+func (m *TransactionPlannerRequest) GetEpochIndex() uint64 {
+ if m != nil {
+ return m.EpochIndex
+ }
+ return 0
+}
+
+func (m *TransactionPlannerRequest) GetEpoch() *v15.Epoch {
if m != nil {
- return m.IbcActions
+ return m.Epoch
}
return nil
}
@@ -385,23 +767,24 @@ func (m *TransactionPlannerRequest) GetIbcActions() []*v1alpha12.IbcAction {
// XXX_OneofWrappers is for the internal use of the proto package.
func (*TransactionPlannerRequest) XXX_OneofWrappers() []interface{} {
return []interface{}{
- (*TransactionPlannerRequest_AccountGroupId)(nil),
+ (*TransactionPlannerRequest_AutoFee)(nil),
+ (*TransactionPlannerRequest_ManualFee)(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 *v16.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 *v12.Address `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}
func (m *TransactionPlannerRequest_Output) Reset() { *m = TransactionPlannerRequest_Output{} }
func (m *TransactionPlannerRequest_Output) String() string { return proto.CompactTextString(m) }
func (*TransactionPlannerRequest_Output) ProtoMessage() {}
func (*TransactionPlannerRequest_Output) Descriptor() ([]byte, []int) {
- return fileDescriptor_0aa947b204e6a7c2, []int{4, 0}
+ return fileDescriptor_dba93d04e42ddfc3, []int{4, 0}
}
func (m *TransactionPlannerRequest_Output) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -430,14 +813,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() *v16.Value {
if m != nil {
return m.Value
}
return nil
}
-func (m *TransactionPlannerRequest_Output) GetAddress() *v1alpha11.Address {
+func (m *TransactionPlannerRequest_Output) GetAddress() *v12.Address {
if m != nil {
return m.Address
}
@@ -445,19 +828,21 @@ 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 *v16.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 *v16.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 *v14.Fee `protobuf:"bytes,3,opt,name=fee,proto3" json:"fee,omitempty"`
+ // The address to which swap claim output will be sent.
+ ClaimAddress *v12.Address `protobuf:"bytes,4,opt,name=claim_address,json=claimAddress,proto3" json:"claim_address,omitempty"`
}
func (m *TransactionPlannerRequest_Swap) Reset() { *m = TransactionPlannerRequest_Swap{} }
func (m *TransactionPlannerRequest_Swap) String() string { return proto.CompactTextString(m) }
func (*TransactionPlannerRequest_Swap) ProtoMessage() {}
func (*TransactionPlannerRequest_Swap) Descriptor() ([]byte, []int) {
- return fileDescriptor_0aa947b204e6a7c2, []int{4, 1}
+ return fileDescriptor_dba93d04e42ddfc3, []int{4, 1}
}
func (m *TransactionPlannerRequest_Swap) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -486,39 +871,46 @@ 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() *v16.Value {
if m != nil {
return m.Value
}
return nil
}
-func (m *TransactionPlannerRequest_Swap) GetTargetAsset() *v1alpha11.AssetId {
+func (m *TransactionPlannerRequest_Swap) GetTargetAsset() *v16.AssetId {
if m != nil {
return m.TargetAsset
}
return nil
}
-func (m *TransactionPlannerRequest_Swap) GetFee() *v1alpha11.Fee {
+func (m *TransactionPlannerRequest_Swap) GetFee() *v14.Fee {
if m != nil {
return m.Fee
}
return nil
}
+func (m *TransactionPlannerRequest_Swap) GetClaimAddress() *v12.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.v1.Swap.body.payload.commitment.
+ SwapCommitment *v17.StateCommitment `protobuf:"bytes,1,opt,name=swap_commitment,json=swapCommitment,proto3" json:"swap_commitment,omitempty"`
}
func (m *TransactionPlannerRequest_SwapClaim) Reset() { *m = TransactionPlannerRequest_SwapClaim{} }
func (m *TransactionPlannerRequest_SwapClaim) String() string { return proto.CompactTextString(m) }
func (*TransactionPlannerRequest_SwapClaim) ProtoMessage() {}
func (*TransactionPlannerRequest_SwapClaim) Descriptor() ([]byte, []int) {
- return fileDescriptor_0aa947b204e6a7c2, []int{4, 2}
+ return fileDescriptor_dba93d04e42ddfc3, []int{4, 2}
}
func (m *TransactionPlannerRequest_SwapClaim) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -547,7 +939,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() *v17.StateCommitment {
if m != nil {
return m.SwapCommitment
}
@@ -555,15 +947,15 @@ 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 *v18.Amount `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount,omitempty"`
+ RateData *v19.RateData `protobuf:"bytes,3,opt,name=rate_data,json=rateData,proto3" json:"rate_data,omitempty"`
}
func (m *TransactionPlannerRequest_Delegate) Reset() { *m = TransactionPlannerRequest_Delegate{} }
func (m *TransactionPlannerRequest_Delegate) String() string { return proto.CompactTextString(m) }
func (*TransactionPlannerRequest_Delegate) ProtoMessage() {}
func (*TransactionPlannerRequest_Delegate) Descriptor() ([]byte, []int) {
- return fileDescriptor_0aa947b204e6a7c2, []int{4, 3}
+ return fileDescriptor_dba93d04e42ddfc3, []int{4, 3}
}
func (m *TransactionPlannerRequest_Delegate) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -592,14 +984,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() *v18.Amount {
if m != nil {
return m.Amount
}
return nil
}
-func (m *TransactionPlannerRequest_Delegate) GetRateData() *v1alpha13.RateData {
+func (m *TransactionPlannerRequest_Delegate) GetRateData() *v19.RateData {
if m != nil {
return m.RateData
}
@@ -607,15 +999,15 @@ 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 *v16.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
+ RateData *v19.RateData `protobuf:"bytes,2,opt,name=rate_data,json=rateData,proto3" json:"rate_data,omitempty"`
}
func (m *TransactionPlannerRequest_Undelegate) Reset() { *m = TransactionPlannerRequest_Undelegate{} }
func (m *TransactionPlannerRequest_Undelegate) String() string { return proto.CompactTextString(m) }
func (*TransactionPlannerRequest_Undelegate) ProtoMessage() {}
func (*TransactionPlannerRequest_Undelegate) Descriptor() ([]byte, []int) {
- return fileDescriptor_0aa947b204e6a7c2, []int{4, 4}
+ return fileDescriptor_dba93d04e42ddfc3, []int{4, 4}
}
func (m *TransactionPlannerRequest_Undelegate) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -644,36 +1036,51 @@ 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() *v16.Value {
if m != nil {
return m.Value
}
return nil
}
-func (m *TransactionPlannerRequest_Undelegate) GetRateData() *v1alpha13.RateData {
+func (m *TransactionPlannerRequest_Undelegate) GetRateData() *v19.RateData {
if m != nil {
return m.RateData
}
return nil
}
-type TransactionPlannerResponse struct {
- Plan *v1alpha1.TransactionPlan `protobuf:"bytes,1,opt,name=plan,proto3" json:"plan,omitempty"`
+type TransactionPlannerRequest_UndelegateClaim struct {
+ // The identity key of the validator to finish undelegating from.
+ ValidatorIdentity *v12.IdentityKey `protobuf:"bytes,1,opt,name=validator_identity,json=validatorIdentity,proto3" json:"validator_identity,omitempty"`
+ // The epoch in which unbonding began, used to verify the penalty.
+ StartEpochIndex uint64 `protobuf:"varint,2,opt,name=start_epoch_index,json=startEpochIndex,proto3" json:"start_epoch_index,omitempty"` // Deprecated: Do not use.
+ // The penalty applied to undelegation, in bps^2 (10e-8).
+ // In the happy path (no slashing), this is 0.
+ Penalty *v19.Penalty `protobuf:"bytes,3,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 *v18.Amount `protobuf:"bytes,4,opt,name=unbonding_amount,json=unbondingAmount,proto3" json:"unbonding_amount,omitempty"`
+ // The height at which unbonding began.
+ UnbondingStartHeight uint64 `protobuf:"varint,5,opt,name=unbonding_start_height,json=unbondingStartHeight,proto3" json:"unbonding_start_height,omitempty"`
}
-func (m *TransactionPlannerResponse) Reset() { *m = TransactionPlannerResponse{} }
-func (m *TransactionPlannerResponse) String() string { return proto.CompactTextString(m) }
-func (*TransactionPlannerResponse) ProtoMessage() {}
-func (*TransactionPlannerResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_0aa947b204e6a7c2, []int{5}
+func (m *TransactionPlannerRequest_UndelegateClaim) Reset() {
+ *m = TransactionPlannerRequest_UndelegateClaim{}
}
-func (m *TransactionPlannerResponse) XXX_Unmarshal(b []byte) error {
+func (m *TransactionPlannerRequest_UndelegateClaim) String() string {
+ return proto.CompactTextString(m)
+}
+func (*TransactionPlannerRequest_UndelegateClaim) ProtoMessage() {}
+func (*TransactionPlannerRequest_UndelegateClaim) Descriptor() ([]byte, []int) {
+ return fileDescriptor_dba93d04e42ddfc3, []int{4, 5}
+}
+func (m *TransactionPlannerRequest_UndelegateClaim) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
-func (m *TransactionPlannerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *TransactionPlannerRequest_UndelegateClaim) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
- return xxx_messageInfo_TransactionPlannerResponse.Marshal(b, m, deterministic)
+ return xxx_messageInfo_TransactionPlannerRequest_UndelegateClaim.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
@@ -683,35 +1090,271 @@ func (m *TransactionPlannerResponse) XXX_Marshal(b []byte, deterministic bool) (
return b[:n], nil
}
}
-func (m *TransactionPlannerResponse) XXX_Merge(src proto.Message) {
- xxx_messageInfo_TransactionPlannerResponse.Merge(m, src)
+func (m *TransactionPlannerRequest_UndelegateClaim) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_TransactionPlannerRequest_UndelegateClaim.Merge(m, src)
}
-func (m *TransactionPlannerResponse) XXX_Size() int {
+func (m *TransactionPlannerRequest_UndelegateClaim) XXX_Size() int {
return m.Size()
}
-func (m *TransactionPlannerResponse) XXX_DiscardUnknown() {
- xxx_messageInfo_TransactionPlannerResponse.DiscardUnknown(m)
+func (m *TransactionPlannerRequest_UndelegateClaim) XXX_DiscardUnknown() {
+ xxx_messageInfo_TransactionPlannerRequest_UndelegateClaim.DiscardUnknown(m)
}
-var xxx_messageInfo_TransactionPlannerResponse proto.InternalMessageInfo
+var xxx_messageInfo_TransactionPlannerRequest_UndelegateClaim proto.InternalMessageInfo
-func (m *TransactionPlannerResponse) GetPlan() *v1alpha1.TransactionPlan {
+func (m *TransactionPlannerRequest_UndelegateClaim) GetValidatorIdentity() *v12.IdentityKey {
if m != nil {
- return m.Plan
+ return m.ValidatorIdentity
}
return nil
}
-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"`
+// Deprecated: Do not use.
+func (m *TransactionPlannerRequest_UndelegateClaim) GetStartEpochIndex() uint64 {
+ if m != nil {
+ return m.StartEpochIndex
+ }
+ return 0
}
-func (m *AddressByIndexRequest) Reset() { *m = AddressByIndexRequest{} }
-func (m *AddressByIndexRequest) String() string { return proto.CompactTextString(m) }
+func (m *TransactionPlannerRequest_UndelegateClaim) GetPenalty() *v19.Penalty {
+ if m != nil {
+ return m.Penalty
+ }
+ return nil
+}
+
+func (m *TransactionPlannerRequest_UndelegateClaim) GetUnbondingAmount() *v18.Amount {
+ if m != nil {
+ return m.UnbondingAmount
+ }
+ return nil
+}
+
+func (m *TransactionPlannerRequest_UndelegateClaim) GetUnbondingStartHeight() uint64 {
+ if m != nil {
+ return m.UnbondingStartHeight
+ }
+ return 0
+}
+
+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 *v110.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_dba93d04e42ddfc3, []int{4, 6}
+}
+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() *v110.Position {
+ if m != nil {
+ return m.Position
+ }
+ return nil
+}
+
+type TransactionPlannerRequest_PositionClose struct {
+ // The position to close.
+ PositionId *v110.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_dba93d04e42ddfc3, []int{4, 7}
+}
+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() *v110.PositionId {
+ if m != nil {
+ return m.PositionId
+ }
+ return nil
+}
+
+type TransactionPlannerRequest_PositionWithdraw struct {
+ // The position to withdraw.
+ PositionId *v110.PositionId `protobuf:"bytes,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"`
+ // The position's final reserves.
+ Reserves *v110.Reserves `protobuf:"bytes,2,opt,name=reserves,proto3" json:"reserves,omitempty"`
+ // The trading pair of the position.
+ TradingPair *v110.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_dba93d04e42ddfc3, []int{4, 8}
+}
+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() *v110.PositionId {
+ if m != nil {
+ return m.PositionId
+ }
+ return nil
+}
+
+func (m *TransactionPlannerRequest_PositionWithdraw) GetReserves() *v110.Reserves {
+ if m != nil {
+ return m.Reserves
+ }
+ return nil
+}
+
+func (m *TransactionPlannerRequest_PositionWithdraw) GetTradingPair() *v110.TradingPair {
+ if m != nil {
+ return m.TradingPair
+ }
+ return nil
+}
+
+type TransactionPlannerResponse struct {
+ Plan *v1.TransactionPlan `protobuf:"bytes,1,opt,name=plan,proto3" json:"plan,omitempty"`
+}
+
+func (m *TransactionPlannerResponse) Reset() { *m = TransactionPlannerResponse{} }
+func (m *TransactionPlannerResponse) String() string { return proto.CompactTextString(m) }
+func (*TransactionPlannerResponse) ProtoMessage() {}
+func (*TransactionPlannerResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_dba93d04e42ddfc3, []int{5}
+}
+func (m *TransactionPlannerResponse) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *TransactionPlannerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_TransactionPlannerResponse.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *TransactionPlannerResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_TransactionPlannerResponse.Merge(m, src)
+}
+func (m *TransactionPlannerResponse) XXX_Size() int {
+ return m.Size()
+}
+func (m *TransactionPlannerResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_TransactionPlannerResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TransactionPlannerResponse proto.InternalMessageInfo
+
+func (m *TransactionPlannerResponse) GetPlan() *v1.TransactionPlan {
+ if m != nil {
+ return m.Plan
+ }
+ return nil
+}
+
+type AddressByIndexRequest struct {
+ AddressIndex *v12.AddressIndex `protobuf:"bytes,1,opt,name=address_index,json=addressIndex,proto3" json:"address_index,omitempty"`
+}
+
+func (m *AddressByIndexRequest) Reset() { *m = AddressByIndexRequest{} }
+func (m *AddressByIndexRequest) String() string { return proto.CompactTextString(m) }
func (*AddressByIndexRequest) ProtoMessage() {}
func (*AddressByIndexRequest) Descriptor() ([]byte, []int) {
- return fileDescriptor_0aa947b204e6a7c2, []int{6}
+ return fileDescriptor_dba93d04e42ddfc3, []int{6}
}
func (m *AddressByIndexRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -740,29 +1383,22 @@ func (m *AddressByIndexRequest) XXX_DiscardUnknown() {
var xxx_messageInfo_AddressByIndexRequest proto.InternalMessageInfo
-func (m *AddressByIndexRequest) GetAddressIndex() *v1alpha11.AddressIndex {
+func (m *AddressByIndexRequest) GetAddressIndex() *v12.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 *v12.Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}
func (m *AddressByIndexResponse) Reset() { *m = AddressByIndexResponse{} }
func (m *AddressByIndexResponse) String() string { return proto.CompactTextString(m) }
func (*AddressByIndexResponse) ProtoMessage() {}
func (*AddressByIndexResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_0aa947b204e6a7c2, []int{7}
+ return fileDescriptor_dba93d04e42ddfc3, []int{7}
}
func (m *AddressByIndexResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -791,22 +1427,102 @@ func (m *AddressByIndexResponse) XXX_DiscardUnknown() {
var xxx_messageInfo_AddressByIndexResponse proto.InternalMessageInfo
-func (m *AddressByIndexResponse) GetAddress() *v1alpha11.Address {
+func (m *AddressByIndexResponse) GetAddress() *v12.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_dba93d04e42ddfc3, []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 *v12.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_dba93d04e42ddfc3, []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() *v12.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 *v12.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_dba93d04e42ddfc3, []int{10}
}
func (m *IndexByAddressRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -835,7 +1551,7 @@ func (m *IndexByAddressRequest) XXX_DiscardUnknown() {
var xxx_messageInfo_IndexByAddressRequest proto.InternalMessageInfo
-func (m *IndexByAddressRequest) GetAddress() *v1alpha11.Address {
+func (m *IndexByAddressRequest) GetAddress() *v12.Address {
if m != nil {
return m.Address
}
@@ -843,16 +1559,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 *v12.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_dba93d04e42ddfc3, []int{11}
}
func (m *IndexByAddressResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -881,49 +1596,22 @@ 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() *v12.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"`
- DisplayConfirm bool `protobuf:"varint,2,opt,name=display_confirm,json=displayConfirm,proto3" json:"display_confirm,omitempty"`
+ AddressIndex *v12.AddressIndex `protobuf:"bytes,1,opt,name=address_index,json=addressIndex,proto3" json:"address_index,omitempty"`
}
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_dba93d04e42ddfc3, []int{12}
}
func (m *EphemeralAddressRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -952,29 +1640,22 @@ func (m *EphemeralAddressRequest) XXX_DiscardUnknown() {
var xxx_messageInfo_EphemeralAddressRequest proto.InternalMessageInfo
-func (m *EphemeralAddressRequest) GetAddressIndex() *v1alpha11.AddressIndex {
+func (m *EphemeralAddressRequest) GetAddressIndex() *v12.AddressIndex {
if m != nil {
return m.AddressIndex
}
return nil
}
-func (m *EphemeralAddressRequest) GetDisplayConfirm() bool {
- if m != nil {
- return m.DisplayConfirm
- }
- return false
-}
-
type EphemeralAddressResponse struct {
- Address *v1alpha11.Address `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
+ Address *v12.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_dba93d04e42ddfc3, []int{13}
}
func (m *EphemeralAddressResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1003,7 +1684,7 @@ func (m *EphemeralAddressResponse) XXX_DiscardUnknown() {
var xxx_messageInfo_EphemeralAddressResponse proto.InternalMessageInfo
-func (m *EphemeralAddressResponse) GetAddress() *v1alpha11.Address {
+func (m *EphemeralAddressResponse) GetAddress() *v12.Address {
if m != nil {
return m.Address
}
@@ -1012,16 +1693,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 *v12.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 *v16.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_dba93d04e42ddfc3, []int{14}
}
func (m *BalancesRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1050,14 +1731,14 @@ func (m *BalancesRequest) XXX_DiscardUnknown() {
var xxx_messageInfo_BalancesRequest proto.InternalMessageInfo
-func (m *BalancesRequest) GetAccountFilter() *v1alpha11.AddressIndex {
+func (m *BalancesRequest) GetAccountFilter() *v12.AddressIndex {
if m != nil {
return m.AccountFilter
}
return nil
}
-func (m *BalancesRequest) GetAssetIdFilter() *v1alpha11.AssetId {
+func (m *BalancesRequest) GetAssetIdFilter() *v16.AssetId {
if m != nil {
return m.AssetIdFilter
}
@@ -1065,15 +1746,24 @@ 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"`
+ // Deprecated: use `account_address` instead.
+ Account *v12.AddressIndex `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"` // Deprecated: Do not use.
+ // Deprecated: use `balance_view` instead.
+ Balance *v16.Value `protobuf:"bytes,2,opt,name=balance,proto3" json:"balance,omitempty"` // Deprecated: Do not use.
+ // The default address for the account.
+ //
+ // Note that the returned balance is for all funds sent to the account,
+ // not just funds sent to its default address.
+ AccountAddress *v12.AddressView `protobuf:"bytes,3,opt,name=account_address,json=accountAddress,proto3" json:"account_address,omitempty"`
+ // The account's balance, with metadata.
+ BalanceView *v16.ValueView `protobuf:"bytes,4,opt,name=balance_view,json=balanceView,proto3" json:"balance_view,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_dba93d04e42ddfc3, []int{15}
}
func (m *BalancesResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1102,37 +1792,52 @@ func (m *BalancesResponse) XXX_DiscardUnknown() {
var xxx_messageInfo_BalancesResponse proto.InternalMessageInfo
-func (m *BalancesResponse) GetAccount() *v1alpha11.AddressIndex {
+// Deprecated: Do not use.
+func (m *BalancesResponse) GetAccount() *v12.AddressIndex {
if m != nil {
return m.Account
}
return nil
}
-func (m *BalancesResponse) GetBalance() *v1alpha11.Value {
+// Deprecated: Do not use.
+func (m *BalancesResponse) GetBalance() *v16.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"`
+func (m *BalancesResponse) GetAccountAddress() *v12.AddressView {
+ if m != nil {
+ return m.AccountAddress
+ }
+ return nil
+}
+
+func (m *BalancesResponse) GetBalanceView() *v16.ValueView {
+ if m != nil {
+ return m.BalanceView
+ }
+ return nil
+}
+
+// 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_dba93d04e42ddfc3, []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,199 +1847,33 @@ 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)
-}
-
-var xxx_messageInfo_ViewAuthToken proto.InternalMessageInfo
-
-func (m *ViewAuthToken) GetInner() []byte {
- if m != nil {
- return m.Inner
- }
- return nil
-}
-
-type ViewAuthRequest struct {
- Fvk *v1alpha11.FullViewingKey `protobuf:"bytes,1,opt,name=fvk,proto3" json:"fvk,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 *ViewAuthRequest) XXX_Unmarshal(b []byte) error {
- return m.Unmarshal(b)
-}
-func (m *ViewAuthRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- if deterministic {
- return xxx_messageInfo_ViewAuthRequest.Marshal(b, m, deterministic)
- } else {
- b = b[:cap(b)]
- n, err := m.MarshalToSizedBuffer(b)
- if err != nil {
- return nil, err
- }
- return b[:n], nil
- }
-}
-func (m *ViewAuthRequest) XXX_Merge(src proto.Message) {
- xxx_messageInfo_ViewAuthRequest.Merge(m, src)
-}
-func (m *ViewAuthRequest) XXX_Size() int {
- return m.Size()
-}
-func (m *ViewAuthRequest) XXX_DiscardUnknown() {
- xxx_messageInfo_ViewAuthRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ViewAuthRequest proto.InternalMessageInfo
-
-func (m *ViewAuthRequest) GetFvk() *v1alpha11.FullViewingKey {
- if m != nil {
- return m.Fvk
- }
- return nil
-}
-
-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)
+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"`
+ // 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,2,opt,name=catching_up,json=catchingUp,proto3" json:"catching_up,omitempty"`
+ CatchingUp bool `protobuf:"varint,3,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}
+ return fileDescriptor_dba93d04e42ddfc3, []int{17}
}
func (m *StatusResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1363,9 +1902,16 @@ func (m *StatusResponse) XXX_DiscardUnknown() {
var xxx_messageInfo_StatusResponse proto.InternalMessageInfo
-func (m *StatusResponse) GetSyncHeight() uint64 {
+func (m *StatusResponse) GetFullSyncHeight() uint64 {
+ if m != nil {
+ return m.FullSyncHeight
+ }
+ return 0
+}
+
+func (m *StatusResponse) GetPartialSyncHeight() uint64 {
if m != nil {
- return m.SyncHeight
+ return m.PartialSyncHeight
}
return 0
}
@@ -1379,16 +1925,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_dba93d04e42ddfc3, []int{18}
}
func (m *StatusStreamRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1417,50 +1960,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_dba93d04e42ddfc3, []int{19}
}
func (m *StatusStreamResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1496,9 +2010,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 +2032,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 *v16.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.v1.
+ AddressIndex *v12.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 *v18.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_dba93d04e42ddfc3, []int{20}
}
func (m *NotesRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1556,25 +2074,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 +2081,40 @@ func (m *NotesRequest) GetIncludeSpent() bool {
return false
}
-func (m *NotesRequest) GetAssetId() *v1alpha11.AssetId {
+func (m *NotesRequest) GetAssetId() *v16.AssetId {
if m != nil {
return m.AssetId
}
return nil
}
-func (m *NotesRequest) GetAddressIndex() *v1alpha11.AddressIndex {
+func (m *NotesRequest) GetAddressIndex() *v12.AddressIndex {
if m != nil {
return m.AddressIndex
}
return nil
}
-func (m *NotesRequest) GetAmountToSpend() *v1alpha11.Amount {
+func (m *NotesRequest) GetAmountToSpend() *v18.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 *v12.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_dba93d04e42ddfc3, []int{21}
}
func (m *NotesForVotingRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1661,25 +2143,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 +2150,23 @@ func (m *NotesForVotingRequest) GetVotableAtHeight() uint64 {
return 0
}
-func (m *NotesForVotingRequest) GetAddressIndex() *v1alpha11.AddressIndex {
+func (m *NotesForVotingRequest) GetAddressIndex() *v12.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"`
// 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"`
+ TransactionPlan *v1.TransactionPlan `protobuf:"bytes,3,opt,name=transaction_plan,json=transactionPlan,proto3" json:"transaction_plan,omitempty"`
}
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_dba93d04e42ddfc3, []int{22}
}
func (m *WitnessRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1751,62 +2195,22 @@ 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 {
- if m != nil {
- return m.NoteCommitments
- }
- return nil
-}
-
-func (m *WitnessRequest) GetTransactionPlan() *v1alpha1.TransactionPlan {
+func (m *WitnessRequest) GetTransactionPlan() *v1.TransactionPlan {
if m != nil {
return m.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"`
+ WitnessData *v1.WitnessData `protobuf:"bytes,1,opt,name=witness_data,json=witnessData,proto3" json:"witness_data,omitempty"`
}
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_dba93d04e42ddfc3, []int{23}
}
func (m *WitnessResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1835,7 +2239,7 @@ func (m *WitnessResponse) XXX_DiscardUnknown() {
var xxx_messageInfo_WitnessResponse proto.InternalMessageInfo
-func (m *WitnessResponse) GetWitnessData() *v1alpha1.WitnessData {
+func (m *WitnessResponse) GetWitnessData() *v1.WitnessData {
if m != nil {
return m.WitnessData
}
@@ -1843,15 +2247,15 @@ func (m *WitnessResponse) GetWitnessData() *v1alpha1.WitnessData {
}
type WitnessAndBuildRequest struct {
- TransactionPlan *v1alpha1.TransactionPlan `protobuf:"bytes,1,opt,name=transaction_plan,json=transactionPlan,proto3" json:"transaction_plan,omitempty"`
- AuthorizationData *v1alpha1.AuthorizationData `protobuf:"bytes,2,opt,name=authorization_data,json=authorizationData,proto3" json:"authorization_data,omitempty"`
+ TransactionPlan *v1.TransactionPlan `protobuf:"bytes,1,opt,name=transaction_plan,json=transactionPlan,proto3" json:"transaction_plan,omitempty"`
+ AuthorizationData *v1.AuthorizationData `protobuf:"bytes,2,opt,name=authorization_data,json=authorizationData,proto3" json:"authorization_data,omitempty"`
}
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_dba93d04e42ddfc3, []int{24}
}
func (m *WitnessAndBuildRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1880,14 +2284,14 @@ func (m *WitnessAndBuildRequest) XXX_DiscardUnknown() {
var xxx_messageInfo_WitnessAndBuildRequest proto.InternalMessageInfo
-func (m *WitnessAndBuildRequest) GetTransactionPlan() *v1alpha1.TransactionPlan {
+func (m *WitnessAndBuildRequest) GetTransactionPlan() *v1.TransactionPlan {
if m != nil {
return m.TransactionPlan
}
return nil
}
-func (m *WitnessAndBuildRequest) GetAuthorizationData() *v1alpha1.AuthorizationData {
+func (m *WitnessAndBuildRequest) GetAuthorizationData() *v1.AuthorizationData {
if m != nil {
return m.AuthorizationData
}
@@ -1895,14 +2299,17 @@ func (m *WitnessAndBuildRequest) GetAuthorizationData() *v1alpha1.AuthorizationD
}
type WitnessAndBuildResponse struct {
- Transaction *v1alpha1.Transaction `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"`
+ // Types that are valid to be assigned to Status:
+ // *WitnessAndBuildResponse_BuildProgress_
+ // *WitnessAndBuildResponse_Complete_
+ Status isWitnessAndBuildResponse_Status `protobuf_oneof:"status"`
}
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_dba93d04e42ddfc3, []int{25}
}
func (m *WitnessAndBuildResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1931,42 +2338,172 @@ func (m *WitnessAndBuildResponse) XXX_DiscardUnknown() {
var xxx_messageInfo_WitnessAndBuildResponse proto.InternalMessageInfo
-func (m *WitnessAndBuildResponse) GetTransaction() *v1alpha1.Transaction {
+type isWitnessAndBuildResponse_Status interface {
+ isWitnessAndBuildResponse_Status()
+ MarshalTo([]byte) (int, error)
+ Size() int
+}
+
+type WitnessAndBuildResponse_BuildProgress_ struct {
+ BuildProgress *WitnessAndBuildResponse_BuildProgress `protobuf:"bytes,1,opt,name=build_progress,json=buildProgress,proto3,oneof" json:"build_progress,omitempty"`
+}
+type WitnessAndBuildResponse_Complete_ struct {
+ Complete *WitnessAndBuildResponse_Complete `protobuf:"bytes,2,opt,name=complete,proto3,oneof" json:"complete,omitempty"`
+}
+
+func (*WitnessAndBuildResponse_BuildProgress_) isWitnessAndBuildResponse_Status() {}
+func (*WitnessAndBuildResponse_Complete_) isWitnessAndBuildResponse_Status() {}
+
+func (m *WitnessAndBuildResponse) GetStatus() isWitnessAndBuildResponse_Status {
if m != nil {
- return m.Transaction
+ return m.Status
}
return nil
}
-// Requests all assets known to the view service.
-type AssetsRequest struct {
- // If set to false (default), returns all assets, regardless of whether the rest of the fields of
- // 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"`
- // 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.
- IncludeUnbondingTokens bool `protobuf:"varint,4,opt,name=include_unbonding_tokens,json=includeUnbondingTokens,proto3" json:"include_unbonding_tokens,omitempty"`
- // Include all LP NFTs in the response.
- IncludeLpNfts bool `protobuf:"varint,5,opt,name=include_lp_nfts,json=includeLpNfts,proto3" json:"include_lp_nfts,omitempty"`
- // Include all proposal NFTs in the response.
- IncludeProposalNfts bool `protobuf:"varint,6,opt,name=include_proposal_nfts,json=includeProposalNfts,proto3" json:"include_proposal_nfts,omitempty"`
- // Include all voting receipt tokens in the response.
- IncludeVotingReceiptTokens bool `protobuf:"varint,7,opt,name=include_voting_receipt_tokens,json=includeVotingReceiptTokens,proto3" json:"include_voting_receipt_tokens,omitempty"`
+func (m *WitnessAndBuildResponse) GetBuildProgress() *WitnessAndBuildResponse_BuildProgress {
+ if x, ok := m.GetStatus().(*WitnessAndBuildResponse_BuildProgress_); ok {
+ return x.BuildProgress
+ }
+ return nil
}
-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}
+func (m *WitnessAndBuildResponse) GetComplete() *WitnessAndBuildResponse_Complete {
+ if x, ok := m.GetStatus().(*WitnessAndBuildResponse_Complete_); ok {
+ return x.Complete
+ }
+ return nil
}
-func (m *AssetsRequest) XXX_Unmarshal(b []byte) error {
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*WitnessAndBuildResponse) XXX_OneofWrappers() []interface{} {
+ return []interface{}{
+ (*WitnessAndBuildResponse_BuildProgress_)(nil),
+ (*WitnessAndBuildResponse_Complete_)(nil),
+ }
+}
+
+// Signals that building is in progress.
+type WitnessAndBuildResponse_BuildProgress struct {
+ // An approximate progress of the build, from 0 to 1.
+ Progress float32 `protobuf:"fixed32,1,opt,name=progress,proto3" json:"progress,omitempty"`
+}
+
+func (m *WitnessAndBuildResponse_BuildProgress) Reset() { *m = WitnessAndBuildResponse_BuildProgress{} }
+func (m *WitnessAndBuildResponse_BuildProgress) String() string { return proto.CompactTextString(m) }
+func (*WitnessAndBuildResponse_BuildProgress) ProtoMessage() {}
+func (*WitnessAndBuildResponse_BuildProgress) Descriptor() ([]byte, []int) {
+ return fileDescriptor_dba93d04e42ddfc3, []int{25, 0}
+}
+func (m *WitnessAndBuildResponse_BuildProgress) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
-func (m *AssetsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *WitnessAndBuildResponse_BuildProgress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_WitnessAndBuildResponse_BuildProgress.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *WitnessAndBuildResponse_BuildProgress) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_WitnessAndBuildResponse_BuildProgress.Merge(m, src)
+}
+func (m *WitnessAndBuildResponse_BuildProgress) XXX_Size() int {
+ return m.Size()
+}
+func (m *WitnessAndBuildResponse_BuildProgress) XXX_DiscardUnknown() {
+ xxx_messageInfo_WitnessAndBuildResponse_BuildProgress.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_WitnessAndBuildResponse_BuildProgress proto.InternalMessageInfo
+
+func (m *WitnessAndBuildResponse_BuildProgress) GetProgress() float32 {
+ if m != nil {
+ return m.Progress
+ }
+ return 0
+}
+
+// Signals that the transaction is complete.
+type WitnessAndBuildResponse_Complete struct {
+ // The finished transaction.
+ Transaction *v1.Transaction `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"`
+}
+
+func (m *WitnessAndBuildResponse_Complete) Reset() { *m = WitnessAndBuildResponse_Complete{} }
+func (m *WitnessAndBuildResponse_Complete) String() string { return proto.CompactTextString(m) }
+func (*WitnessAndBuildResponse_Complete) ProtoMessage() {}
+func (*WitnessAndBuildResponse_Complete) Descriptor() ([]byte, []int) {
+ return fileDescriptor_dba93d04e42ddfc3, []int{25, 1}
+}
+func (m *WitnessAndBuildResponse_Complete) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *WitnessAndBuildResponse_Complete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_WitnessAndBuildResponse_Complete.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *WitnessAndBuildResponse_Complete) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_WitnessAndBuildResponse_Complete.Merge(m, src)
+}
+func (m *WitnessAndBuildResponse_Complete) XXX_Size() int {
+ return m.Size()
+}
+func (m *WitnessAndBuildResponse_Complete) XXX_DiscardUnknown() {
+ xxx_messageInfo_WitnessAndBuildResponse_Complete.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_WitnessAndBuildResponse_Complete proto.InternalMessageInfo
+
+func (m *WitnessAndBuildResponse_Complete) GetTransaction() *v1.Transaction {
+ if m != nil {
+ return m.Transaction
+ }
+ return nil
+}
+
+// Requests all assets known to the view service.
+type AssetsRequest struct {
+ // If set to false (default), returns all assets, regardless of whether the rest of the fields of
+ // 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 []*v16.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.
+ IncludeUnbondingTokens bool `protobuf:"varint,4,opt,name=include_unbonding_tokens,json=includeUnbondingTokens,proto3" json:"include_unbonding_tokens,omitempty"`
+ // Include all LP NFTs in the response.
+ IncludeLpNfts bool `protobuf:"varint,5,opt,name=include_lp_nfts,json=includeLpNfts,proto3" json:"include_lp_nfts,omitempty"`
+ // Include all proposal NFTs in the response.
+ IncludeProposalNfts bool `protobuf:"varint,6,opt,name=include_proposal_nfts,json=includeProposalNfts,proto3" json:"include_proposal_nfts,omitempty"`
+ // Include all voting receipt tokens in the response.
+ IncludeVotingReceiptTokens bool `protobuf:"varint,7,opt,name=include_voting_receipt_tokens,json=includeVotingReceiptTokens,proto3" json:"include_voting_receipt_tokens,omitempty"`
+}
+
+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_dba93d04e42ddfc3, []int{26}
+}
+func (m *AssetsRequest) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *AssetsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_AssetsRequest.Marshal(b, m, deterministic)
} else {
@@ -1997,7 +2534,7 @@ func (m *AssetsRequest) GetFiltered() bool {
return false
}
-func (m *AssetsRequest) GetIncludeSpecificDenominations() []*v1alpha11.Denom {
+func (m *AssetsRequest) GetIncludeSpecificDenominations() []*v16.Denom {
if m != nil {
return m.IncludeSpecificDenominations
}
@@ -2041,14 +2578,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 *v16.Metadata `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_dba93d04e42ddfc3, []int{27}
}
func (m *AssetsResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -2077,29 +2614,29 @@ func (m *AssetsResponse) XXX_DiscardUnknown() {
var xxx_messageInfo_AssetsResponse proto.InternalMessageInfo
-func (m *AssetsResponse) GetDenomMetadata() *v1alpha11.DenomMetadata {
+func (m *AssetsResponse) GetDenomMetadata() *v16.Metadata {
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_dba93d04e42ddfc3, []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 +2646,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 *v111.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_dba93d04e42ddfc3, []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,25 +2683,106 @@ 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() *v111.AppParameters {
if m != nil {
return m.Parameters
}
return nil
}
+// Requests the current gas prices from the view service.
+type GasPricesRequest struct {
+}
+
+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_dba93d04e42ddfc3, []int{30}
+}
+func (m *GasPricesRequest) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *GasPricesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_GasPricesRequest.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *GasPricesRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_GasPricesRequest.Merge(m, src)
+}
+func (m *GasPricesRequest) XXX_Size() int {
+ return m.Size()
+}
+func (m *GasPricesRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_GasPricesRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GasPricesRequest proto.InternalMessageInfo
+
+type GasPricesResponse struct {
+ GasPrices *v14.GasPrices `protobuf:"bytes,1,opt,name=gas_prices,json=gasPrices,proto3" json:"gas_prices,omitempty"`
+}
+
+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_dba93d04e42ddfc3, []int{31}
+}
+func (m *GasPricesResponse) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *GasPricesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_GasPricesResponse.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *GasPricesResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_GasPricesResponse.Merge(m, src)
+}
+func (m *GasPricesResponse) XXX_Size() int {
+ return m.Size()
+}
+func (m *GasPricesResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_GasPricesResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GasPricesResponse proto.InternalMessageInfo
+
+func (m *GasPricesResponse) GetGasPrices() *v14.GasPrices {
+ if m != nil {
+ return m.GasPrices
+ }
+ return nil
+}
+
// Requests the current FMD parameters from the view service.
type FMDParametersRequest struct {
}
@@ -2173,7 +2791,7 @@ 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}
+ return fileDescriptor_dba93d04e42ddfc3, []int{32}
}
func (m *FMDParametersRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -2203,14 +2821,14 @@ func (m *FMDParametersRequest) XXX_DiscardUnknown() {
var xxx_messageInfo_FMDParametersRequest proto.InternalMessageInfo
type FMDParametersResponse struct {
- Parameters *v1alpha14.FmdParameters `protobuf:"bytes,1,opt,name=parameters,proto3" json:"parameters,omitempty"`
+ Parameters *v112.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{32}
+ return fileDescriptor_dba93d04e42ddfc3, []int{33}
}
func (m *FMDParametersResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -2239,7 +2857,7 @@ func (m *FMDParametersResponse) XXX_DiscardUnknown() {
var xxx_messageInfo_FMDParametersResponse proto.InternalMessageInfo
-func (m *FMDParametersResponse) GetParameters() *v1alpha14.FmdParameters {
+func (m *FMDParametersResponse) GetParameters() *v112.FmdParameters {
if m != nil {
return m.Parameters
}
@@ -2247,19 +2865,16 @@ func (m *FMDParametersResponse) GetParameters() *v1alpha14.FmdParameters {
}
type NoteByCommitmentRequest struct {
- NoteCommitment *v1alpha11.StateCommitment `protobuf:"bytes,2,opt,name=note_commitment,json=noteCommitment,proto3" json:"note_commitment,omitempty"`
+ NoteCommitment *v17.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"`
}
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_dba93d04e42ddfc3, []int{34}
}
func (m *NoteByCommitmentRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -2288,26 +2903,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() *v17.StateCommitment {
if m != nil {
return m.NoteCommitment
}
@@ -2321,20 +2917,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 +2925,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_dba93d04e42ddfc3, []int{35}
}
func (m *NoteByCommitmentResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -2380,19 +2962,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 *v17.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_dba93d04e42ddfc3, []int{36}
}
func (m *SwapByCommitmentRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -2421,26 +3000,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() *v17.StateCommitment {
if m != nil {
return m.SwapCommitment
}
@@ -2454,20 +3014,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 +3022,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_dba93d04e42ddfc3, []int{37}
}
func (m *SwapByCommitmentResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -2512,19 +3058,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_dba93d04e42ddfc3, []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_dba93d04e42ddfc3, []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 *v15.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_dba93d04e42ddfc3, []int{40}
}
func (m *NullifierStatusRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -2553,26 +3176,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() *v15.Nullifier {
if m != nil {
return m.Nullifier
}
@@ -2586,20 +3190,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 +3198,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_dba93d04e42ddfc3, []int{41}
}
func (m *NullifierStatusResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -2646,14 +3236,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 *v11.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_dba93d04e42ddfc3, []int{42}
}
func (m *TransactionInfoByHashRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -2682,7 +3272,7 @@ func (m *TransactionInfoByHashRequest) XXX_DiscardUnknown() {
var xxx_messageInfo_TransactionInfoByHashRequest proto.InternalMessageInfo
-func (m *TransactionInfoByHashRequest) GetId() *v1alpha1.Id {
+func (m *TransactionInfoByHashRequest) GetId() *v11.TransactionId {
if m != nil {
return m.Id
}
@@ -2690,19 +3280,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_dba93d04e42ddfc3, []int{43}
}
func (m *TransactionInfoRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -2731,81 +3319,38 @@ 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 *v11.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"`
+ Transaction *v1.Transaction `protobuf:"bytes,3,opt,name=transaction,proto3" json:"transaction,omitempty"`
// The transaction perspective, as seen by this view server.
- Perspective *v1alpha1.TransactionPerspective `protobuf:"bytes,4,opt,name=perspective,proto3" json:"perspective,omitempty"`
+ Perspective *v1.TransactionPerspective `protobuf:"bytes,4,opt,name=perspective,proto3" json:"perspective,omitempty"`
// A precomputed transaction view of `transaction` from `perspective`, included for convenience of clients that don't have support for viewing transactions on their own.
- View *v1alpha1.TransactionView `protobuf:"bytes,5,opt,name=view,proto3" json:"view,omitempty"`
+ View *v1.TransactionView `protobuf:"bytes,5,opt,name=view,proto3" json:"view,omitempty"`
}
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_dba93d04e42ddfc3, []int{44}
}
func (m *TransactionInfo) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -2834,67 +3379,41 @@ 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() *v11.TransactionId {
if m != nil {
return m.Id
}
return nil
}
-func (m *TransactionInfo) GetTransaction() *v1alpha1.Transaction {
+func (m *TransactionInfo) GetTransaction() *v1.Transaction {
if m != nil {
return m.Transaction
}
return nil
}
-func (m *TransactionInfo) GetPerspective() *v1alpha1.TransactionPerspective {
+func (m *TransactionInfo) GetPerspective() *v1.TransactionPerspective {
if m != nil {
return m.Perspective
}
return nil
}
-func (m *TransactionInfo) GetView() *v1alpha1.TransactionView {
+func (m *TransactionInfo) GetView() *v1.TransactionView {
if m != nil {
return m.View
}
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 +3422,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_dba93d04e42ddfc3, []int{45}
}
func (m *TransactionInfoResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -2947,7 +3466,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_dba93d04e42ddfc3, []int{46}
}
func (m *TransactionInfoByHashResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -2991,7 +3510,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_dba93d04e42ddfc3, []int{47}
}
func (m *NotesResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -3028,15 +3547,15 @@ 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"`
+ NoteRecord *SpendableNoteRecord `protobuf:"bytes,1,opt,name=note_record,json=noteRecord,proto3" json:"note_record,omitempty"`
+ IdentityKey *v12.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_dba93d04e42ddfc3, []int{48}
}
func (m *NotesForVotingResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -3072,7 +3591,7 @@ func (m *NotesForVotingResponse) GetNoteRecord() *SpendableNoteRecord {
return nil
}
-func (m *NotesForVotingResponse) GetIdentityKey() *v1alpha11.IdentityKey {
+func (m *NotesForVotingResponse) GetIdentityKey() *v12.IdentityKey {
if m != nil {
return m.IdentityKey
}
@@ -3082,29 +3601,30 @@ 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 *v17.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 *v112.Note `protobuf:"bytes,2,opt,name=note,proto3" json:"note,omitempty"`
+ // A precomputed decryption of the note's address incore.component.dex.v1.
+ AddressIndex *v12.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 *v15.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 *v15.CommitmentSource `protobuf:"bytes,8,opt,name=source,proto3" json:"source,omitempty"`
+ // The sender's return address, if known.
+ ReturnAddress *v12.AddressView `protobuf:"bytes,9,opt,name=return_address,json=returnAddress,proto3" json:"return_address,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_dba93d04e42ddfc3, []int{49}
}
func (m *SpendableNoteRecord) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -3133,47 +3653,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 {
- if m != nil {
- return m.XHeightSpent
- }
- return nil
-}
-
-func (m *SpendableNoteRecord) GetNoteCommitment() *v1alpha11.StateCommitment {
+func (m *SpendableNoteRecord) GetNoteCommitment() *v17.StateCommitment {
if m != nil {
return m.NoteCommitment
}
return nil
}
-func (m *SpendableNoteRecord) GetNote() *v1alpha11.Note {
+func (m *SpendableNoteRecord) GetNote() *v112.Note {
if m != nil {
return m.Note
}
return nil
}
-func (m *SpendableNoteRecord) GetAddressIndex() *v1alpha11.AddressIndex {
+func (m *SpendableNoteRecord) GetAddressIndex() *v12.AddressIndex {
if m != nil {
return m.AddressIndex
}
return nil
}
-func (m *SpendableNoteRecord) GetNullifier() *v1alpha11.Nullifier {
+func (m *SpendableNoteRecord) GetNullifier() *v15.Nullifier {
if m != nil {
return m.Nullifier
}
@@ -3188,8 +3689,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 +3702,35 @@ func (m *SpendableNoteRecord) GetPosition() uint64 {
return 0
}
-func (m *SpendableNoteRecord) GetSource() *v1alpha14.NoteSource {
+func (m *SpendableNoteRecord) GetSource() *v15.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),
+func (m *SpendableNoteRecord) GetReturnAddress() *v12.AddressView {
+ if m != nil {
+ return m.ReturnAddress
}
+ return 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"`
- 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"`
+ SwapCommitment *v17.StateCommitment `protobuf:"bytes,1,opt,name=swap_commitment,json=swapCommitment,proto3" json:"swap_commitment,omitempty"`
+ Swap *v110.SwapPlaintext `protobuf:"bytes,2,opt,name=swap,proto3" json:"swap,omitempty"`
+ Position uint64 `protobuf:"varint,3,opt,name=position,proto3" json:"position,omitempty"`
+ Nullifier *v15.Nullifier `protobuf:"bytes,4,opt,name=nullifier,proto3" json:"nullifier,omitempty"`
+ OutputData *v110.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 *v15.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_dba93d04e42ddfc3, []int{50}
}
func (m *SwapRecord) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -3260,33 +3759,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() *v17.StateCommitment {
if m != nil {
return m.SwapCommitment
}
return nil
}
-func (m *SwapRecord) GetSwap() *v1alpha15.SwapPlaintext {
+func (m *SwapRecord) GetSwap() *v110.SwapPlaintext {
if m != nil {
return m.Swap
}
@@ -3300,14 +3780,14 @@ func (m *SwapRecord) GetPosition() uint64 {
return 0
}
-func (m *SwapRecord) GetNullifier() *v1alpha11.Nullifier {
+func (m *SwapRecord) GetNullifier() *v15.Nullifier {
if m != nil {
return m.Nullifier
}
return nil
}
-func (m *SwapRecord) GetOutputData() *v1alpha15.BatchSwapOutputData {
+func (m *SwapRecord) GetOutputData() *v110.BatchSwapOutputData {
if m != nil {
return m.OutputData
}
@@ -3315,40 +3795,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() *v15.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 *v110.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 *v110.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_dba93d04e42ddfc3, []int{51}
}
func (m *OwnedPositionIdsRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -3377,78 +3848,232 @@ func (m *OwnedPositionIdsRequest) XXX_DiscardUnknown() {
var xxx_messageInfo_OwnedPositionIdsRequest proto.InternalMessageInfo
-type isOwnedPositionIdsRequest_XPositionState interface {
- isOwnedPositionIdsRequest_XPositionState()
- MarshalTo([]byte) (int, error)
- Size() int
+func (m *OwnedPositionIdsRequest) GetPositionState() *v110.PositionState {
+ if m != nil {
+ return m.PositionState
+ }
+ return nil
}
-type isOwnedPositionIdsRequest_XTradingPair interface {
- isOwnedPositionIdsRequest_XTradingPair()
- MarshalTo([]byte) (int, error)
- Size() int
+
+func (m *OwnedPositionIdsRequest) GetTradingPair() *v110.TradingPair {
+ if m != nil {
+ return m.TradingPair
+ }
+ return nil
+}
+
+type OwnedPositionIdsResponse struct {
+ PositionId *v110.PositionId `protobuf:"bytes,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"`
}
-type OwnedPositionIdsRequest_PositionState struct {
- PositionState *v1alpha15.PositionState `protobuf:"bytes,1,opt,name=position_state,json=positionState,proto3,oneof" json:"position_state,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_dba93d04e42ddfc3, []int{52}
+}
+func (m *OwnedPositionIdsResponse) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *OwnedPositionIdsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_OwnedPositionIdsResponse.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *OwnedPositionIdsResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_OwnedPositionIdsResponse.Merge(m, src)
+}
+func (m *OwnedPositionIdsResponse) XXX_Size() int {
+ return m.Size()
}
-type OwnedPositionIdsRequest_TradingPair struct {
- TradingPair *v1alpha15.TradingPair `protobuf:"bytes,2,opt,name=trading_pair,json=tradingPair,proto3,oneof" json:"trading_pair,omitempty"`
+func (m *OwnedPositionIdsResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_OwnedPositionIdsResponse.DiscardUnknown(m)
}
-func (*OwnedPositionIdsRequest_PositionState) isOwnedPositionIdsRequest_XPositionState() {}
-func (*OwnedPositionIdsRequest_TradingPair) isOwnedPositionIdsRequest_XTradingPair() {}
+var xxx_messageInfo_OwnedPositionIdsResponse proto.InternalMessageInfo
-func (m *OwnedPositionIdsRequest) GetXPositionState() isOwnedPositionIdsRequest_XPositionState {
+func (m *OwnedPositionIdsResponse) GetPositionId() *v110.PositionId {
if m != nil {
- return m.XPositionState
+ return m.PositionId
}
return nil
}
-func (m *OwnedPositionIdsRequest) GetXTradingPair() isOwnedPositionIdsRequest_XTradingPair {
+
+// Requests information on an asset by asset id
+type AssetMetadataByIdRequest struct {
+ // The asset id to request information on.
+ AssetId *v16.AssetId `protobuf:"bytes,2,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"`
+}
+
+func (m *AssetMetadataByIdRequest) Reset() { *m = AssetMetadataByIdRequest{} }
+func (m *AssetMetadataByIdRequest) String() string { return proto.CompactTextString(m) }
+func (*AssetMetadataByIdRequest) ProtoMessage() {}
+func (*AssetMetadataByIdRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_dba93d04e42ddfc3, []int{53}
+}
+func (m *AssetMetadataByIdRequest) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *AssetMetadataByIdRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_AssetMetadataByIdRequest.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *AssetMetadataByIdRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_AssetMetadataByIdRequest.Merge(m, src)
+}
+func (m *AssetMetadataByIdRequest) XXX_Size() int {
+ return m.Size()
+}
+func (m *AssetMetadataByIdRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_AssetMetadataByIdRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AssetMetadataByIdRequest proto.InternalMessageInfo
+
+func (m *AssetMetadataByIdRequest) GetAssetId() *v16.AssetId {
if m != nil {
- return m.XTradingPair
+ return m.AssetId
}
return nil
}
-func (m *OwnedPositionIdsRequest) GetPositionState() *v1alpha15.PositionState {
- if x, ok := m.GetXPositionState().(*OwnedPositionIdsRequest_PositionState); ok {
- return x.PositionState
+type AssetMetadataByIdResponse struct {
+ // If present, information on the requested asset.
+ //
+ // If the requested asset was unknown, this field will not be present.
+ DenomMetadata *v16.Metadata `protobuf:"bytes,1,opt,name=denom_metadata,json=denomMetadata,proto3" json:"denom_metadata,omitempty"`
+}
+
+func (m *AssetMetadataByIdResponse) Reset() { *m = AssetMetadataByIdResponse{} }
+func (m *AssetMetadataByIdResponse) String() string { return proto.CompactTextString(m) }
+func (*AssetMetadataByIdResponse) ProtoMessage() {}
+func (*AssetMetadataByIdResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_dba93d04e42ddfc3, []int{54}
+}
+func (m *AssetMetadataByIdResponse) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *AssetMetadataByIdResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_AssetMetadataByIdResponse.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *AssetMetadataByIdResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_AssetMetadataByIdResponse.Merge(m, src)
+}
+func (m *AssetMetadataByIdResponse) XXX_Size() int {
+ return m.Size()
+}
+func (m *AssetMetadataByIdResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_AssetMetadataByIdResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AssetMetadataByIdResponse proto.InternalMessageInfo
+
+func (m *AssetMetadataByIdResponse) GetDenomMetadata() *v16.Metadata {
+ if m != nil {
+ return m.DenomMetadata
}
return nil
}
-func (m *OwnedPositionIdsRequest) GetTradingPair() *v1alpha15.TradingPair {
- if x, ok := m.GetXTradingPair().(*OwnedPositionIdsRequest_TradingPair); ok {
- return x.TradingPair
+// Requests `ValueView`s of delegation tokens for the given address index. The
+// returned `ValueView`s will include the `ValidatorInfo` for the delegated
+// validator in their `extended_metadata` fields.
+type DelegationsByAddressIndexRequest struct {
+ // The address index to fetch delegation balances for.
+ AddressIndex *v12.AddressIndex `protobuf:"bytes,1,opt,name=address_index,json=addressIndex,proto3" json:"address_index,omitempty"`
+ Filter DelegationsByAddressIndexRequest_Filter `protobuf:"varint,2,opt,name=filter,proto3,enum=penumbra.view.v1.DelegationsByAddressIndexRequest_Filter" json:"filter,omitempty"`
+}
+
+func (m *DelegationsByAddressIndexRequest) Reset() { *m = DelegationsByAddressIndexRequest{} }
+func (m *DelegationsByAddressIndexRequest) String() string { return proto.CompactTextString(m) }
+func (*DelegationsByAddressIndexRequest) ProtoMessage() {}
+func (*DelegationsByAddressIndexRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_dba93d04e42ddfc3, []int{55}
+}
+func (m *DelegationsByAddressIndexRequest) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *DelegationsByAddressIndexRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_DelegationsByAddressIndexRequest.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *DelegationsByAddressIndexRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_DelegationsByAddressIndexRequest.Merge(m, src)
+}
+func (m *DelegationsByAddressIndexRequest) XXX_Size() int {
+ return m.Size()
+}
+func (m *DelegationsByAddressIndexRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_DelegationsByAddressIndexRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DelegationsByAddressIndexRequest proto.InternalMessageInfo
+
+func (m *DelegationsByAddressIndexRequest) GetAddressIndex() *v12.AddressIndex {
+ if m != nil {
+ return m.AddressIndex
}
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),
+func (m *DelegationsByAddressIndexRequest) GetFilter() DelegationsByAddressIndexRequest_Filter {
+ if m != nil {
+ return m.Filter
}
+ return DelegationsByAddressIndexRequest_FILTER_UNSPECIFIED
}
-type OwnedPositionIdsResponse struct {
- PositionId *v1alpha15.PositionId `protobuf:"bytes,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"`
+// Contains a `ValueView` of delegation tokens for the requested address index.
+// The `ValueView` includes the `ValidatorInfo` for the delegated validator in
+// cits `extended_metadata` field.
+type DelegationsByAddressIndexResponse struct {
+ ValueView *v16.ValueView `protobuf:"bytes,1,opt,name=value_view,json=valueView,proto3" json:"value_view,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}
+func (m *DelegationsByAddressIndexResponse) Reset() { *m = DelegationsByAddressIndexResponse{} }
+func (m *DelegationsByAddressIndexResponse) String() string { return proto.CompactTextString(m) }
+func (*DelegationsByAddressIndexResponse) ProtoMessage() {}
+func (*DelegationsByAddressIndexResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_dba93d04e42ddfc3, []int{56}
}
-func (m *OwnedPositionIdsResponse) XXX_Unmarshal(b []byte) error {
+func (m *DelegationsByAddressIndexResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
-func (m *OwnedPositionIdsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *DelegationsByAddressIndexResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
- return xxx_messageInfo_OwnedPositionIdsResponse.Marshal(b, m, deterministic)
+ return xxx_messageInfo_DelegationsByAddressIndexResponse.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
@@ -3458,275 +4083,346 @@ func (m *OwnedPositionIdsResponse) XXX_Marshal(b []byte, deterministic bool) ([]
return b[:n], nil
}
}
-func (m *OwnedPositionIdsResponse) XXX_Merge(src proto.Message) {
- xxx_messageInfo_OwnedPositionIdsResponse.Merge(m, src)
+func (m *DelegationsByAddressIndexResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_DelegationsByAddressIndexResponse.Merge(m, src)
}
-func (m *OwnedPositionIdsResponse) XXX_Size() int {
+func (m *DelegationsByAddressIndexResponse) XXX_Size() int {
return m.Size()
}
-func (m *OwnedPositionIdsResponse) XXX_DiscardUnknown() {
- xxx_messageInfo_OwnedPositionIdsResponse.DiscardUnknown(m)
+func (m *DelegationsByAddressIndexResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_DelegationsByAddressIndexResponse.DiscardUnknown(m)
}
-var xxx_messageInfo_OwnedPositionIdsResponse proto.InternalMessageInfo
+var xxx_messageInfo_DelegationsByAddressIndexResponse proto.InternalMessageInfo
-func (m *OwnedPositionIdsResponse) GetPositionId() *v1alpha15.PositionId {
+func (m *DelegationsByAddressIndexResponse) GetValueView() *v16.ValueView {
if m != nil {
- return m.PositionId
+ return m.ValueView
}
return nil
}
func init() {
- proto.RegisterType((*AuthorizeAndBuildRequest)(nil), "penumbra.view.v1alpha1.AuthorizeAndBuildRequest")
- proto.RegisterType((*AuthorizeAndBuildResponse)(nil), "penumbra.view.v1alpha1.AuthorizeAndBuildResponse")
- proto.RegisterType((*BroadcastTransactionRequest)(nil), "penumbra.view.v1alpha1.BroadcastTransactionRequest")
- proto.RegisterType((*BroadcastTransactionResponse)(nil), "penumbra.view.v1alpha1.BroadcastTransactionResponse")
- proto.RegisterType((*TransactionPlannerRequest)(nil), "penumbra.view.v1alpha1.TransactionPlannerRequest")
- proto.RegisterType((*TransactionPlannerRequest_Output)(nil), "penumbra.view.v1alpha1.TransactionPlannerRequest.Output")
- proto.RegisterType((*TransactionPlannerRequest_Swap)(nil), "penumbra.view.v1alpha1.TransactionPlannerRequest.Swap")
- 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((*TransactionPlannerResponse)(nil), "penumbra.view.v1alpha1.TransactionPlannerResponse")
- proto.RegisterType((*AddressByIndexRequest)(nil), "penumbra.view.v1alpha1.AddressByIndexRequest")
- proto.RegisterType((*AddressByIndexResponse)(nil), "penumbra.view.v1alpha1.AddressByIndexResponse")
- 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")
- proto.RegisterType((*StatusStreamResponse)(nil), "penumbra.view.v1alpha1.StatusStreamResponse")
- proto.RegisterType((*NotesRequest)(nil), "penumbra.view.v1alpha1.NotesRequest")
- proto.RegisterType((*NotesForVotingRequest)(nil), "penumbra.view.v1alpha1.NotesForVotingRequest")
- proto.RegisterType((*WitnessRequest)(nil), "penumbra.view.v1alpha1.WitnessRequest")
- proto.RegisterType((*WitnessResponse)(nil), "penumbra.view.v1alpha1.WitnessResponse")
- proto.RegisterType((*WitnessAndBuildRequest)(nil), "penumbra.view.v1alpha1.WitnessAndBuildRequest")
- 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((*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((*NullifierStatusRequest)(nil), "penumbra.view.v1alpha1.NullifierStatusRequest")
- proto.RegisterType((*NullifierStatusResponse)(nil), "penumbra.view.v1alpha1.NullifierStatusResponse")
- proto.RegisterType((*TransactionInfoByHashRequest)(nil), "penumbra.view.v1alpha1.TransactionInfoByHashRequest")
- proto.RegisterType((*TransactionInfoRequest)(nil), "penumbra.view.v1alpha1.TransactionInfoRequest")
- proto.RegisterType((*TransactionInfo)(nil), "penumbra.view.v1alpha1.TransactionInfo")
- proto.RegisterType((*TransactionInfoResponse)(nil), "penumbra.view.v1alpha1.TransactionInfoResponse")
- proto.RegisterType((*TransactionInfoByHashResponse)(nil), "penumbra.view.v1alpha1.TransactionInfoByHashResponse")
- proto.RegisterType((*NotesResponse)(nil), "penumbra.view.v1alpha1.NotesResponse")
- proto.RegisterType((*NotesForVotingResponse)(nil), "penumbra.view.v1alpha1.NotesForVotingResponse")
- proto.RegisterType((*SpendableNoteRecord)(nil), "penumbra.view.v1alpha1.SpendableNoteRecord")
- proto.RegisterType((*SwapRecord)(nil), "penumbra.view.v1alpha1.SwapRecord")
- proto.RegisterType((*OwnedPositionIdsRequest)(nil), "penumbra.view.v1alpha1.OwnedPositionIdsRequest")
- proto.RegisterType((*OwnedPositionIdsResponse)(nil), "penumbra.view.v1alpha1.OwnedPositionIdsResponse")
-}
-
-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,
+ proto.RegisterEnum("penumbra.view.v1.DelegationsByAddressIndexRequest_Filter", DelegationsByAddressIndexRequest_Filter_name, DelegationsByAddressIndexRequest_Filter_value)
+ proto.RegisterType((*AuthorizeAndBuildRequest)(nil), "penumbra.view.v1.AuthorizeAndBuildRequest")
+ proto.RegisterType((*AuthorizeAndBuildResponse)(nil), "penumbra.view.v1.AuthorizeAndBuildResponse")
+ proto.RegisterType((*AuthorizeAndBuildResponse_BuildProgress)(nil), "penumbra.view.v1.AuthorizeAndBuildResponse.BuildProgress")
+ proto.RegisterType((*AuthorizeAndBuildResponse_Complete)(nil), "penumbra.view.v1.AuthorizeAndBuildResponse.Complete")
+ proto.RegisterType((*BroadcastTransactionRequest)(nil), "penumbra.view.v1.BroadcastTransactionRequest")
+ proto.RegisterType((*BroadcastTransactionResponse)(nil), "penumbra.view.v1.BroadcastTransactionResponse")
+ proto.RegisterType((*BroadcastTransactionResponse_BroadcastSuccess)(nil), "penumbra.view.v1.BroadcastTransactionResponse.BroadcastSuccess")
+ proto.RegisterType((*BroadcastTransactionResponse_Confirmed)(nil), "penumbra.view.v1.BroadcastTransactionResponse.Confirmed")
+ proto.RegisterType((*TransactionPlannerRequest)(nil), "penumbra.view.v1.TransactionPlannerRequest")
+ proto.RegisterType((*TransactionPlannerRequest_Output)(nil), "penumbra.view.v1.TransactionPlannerRequest.Output")
+ proto.RegisterType((*TransactionPlannerRequest_Swap)(nil), "penumbra.view.v1.TransactionPlannerRequest.Swap")
+ proto.RegisterType((*TransactionPlannerRequest_SwapClaim)(nil), "penumbra.view.v1.TransactionPlannerRequest.SwapClaim")
+ proto.RegisterType((*TransactionPlannerRequest_Delegate)(nil), "penumbra.view.v1.TransactionPlannerRequest.Delegate")
+ proto.RegisterType((*TransactionPlannerRequest_Undelegate)(nil), "penumbra.view.v1.TransactionPlannerRequest.Undelegate")
+ proto.RegisterType((*TransactionPlannerRequest_UndelegateClaim)(nil), "penumbra.view.v1.TransactionPlannerRequest.UndelegateClaim")
+ proto.RegisterType((*TransactionPlannerRequest_PositionOpen)(nil), "penumbra.view.v1.TransactionPlannerRequest.PositionOpen")
+ proto.RegisterType((*TransactionPlannerRequest_PositionClose)(nil), "penumbra.view.v1.TransactionPlannerRequest.PositionClose")
+ proto.RegisterType((*TransactionPlannerRequest_PositionWithdraw)(nil), "penumbra.view.v1.TransactionPlannerRequest.PositionWithdraw")
+ proto.RegisterType((*TransactionPlannerResponse)(nil), "penumbra.view.v1.TransactionPlannerResponse")
+ proto.RegisterType((*AddressByIndexRequest)(nil), "penumbra.view.v1.AddressByIndexRequest")
+ proto.RegisterType((*AddressByIndexResponse)(nil), "penumbra.view.v1.AddressByIndexResponse")
+ proto.RegisterType((*WalletIdRequest)(nil), "penumbra.view.v1.WalletIdRequest")
+ proto.RegisterType((*WalletIdResponse)(nil), "penumbra.view.v1.WalletIdResponse")
+ proto.RegisterType((*IndexByAddressRequest)(nil), "penumbra.view.v1.IndexByAddressRequest")
+ proto.RegisterType((*IndexByAddressResponse)(nil), "penumbra.view.v1.IndexByAddressResponse")
+ proto.RegisterType((*EphemeralAddressRequest)(nil), "penumbra.view.v1.EphemeralAddressRequest")
+ proto.RegisterType((*EphemeralAddressResponse)(nil), "penumbra.view.v1.EphemeralAddressResponse")
+ proto.RegisterType((*BalancesRequest)(nil), "penumbra.view.v1.BalancesRequest")
+ proto.RegisterType((*BalancesResponse)(nil), "penumbra.view.v1.BalancesResponse")
+ proto.RegisterType((*StatusRequest)(nil), "penumbra.view.v1.StatusRequest")
+ proto.RegisterType((*StatusResponse)(nil), "penumbra.view.v1.StatusResponse")
+ proto.RegisterType((*StatusStreamRequest)(nil), "penumbra.view.v1.StatusStreamRequest")
+ proto.RegisterType((*StatusStreamResponse)(nil), "penumbra.view.v1.StatusStreamResponse")
+ proto.RegisterType((*NotesRequest)(nil), "penumbra.view.v1.NotesRequest")
+ proto.RegisterType((*NotesForVotingRequest)(nil), "penumbra.view.v1.NotesForVotingRequest")
+ proto.RegisterType((*WitnessRequest)(nil), "penumbra.view.v1.WitnessRequest")
+ proto.RegisterType((*WitnessResponse)(nil), "penumbra.view.v1.WitnessResponse")
+ proto.RegisterType((*WitnessAndBuildRequest)(nil), "penumbra.view.v1.WitnessAndBuildRequest")
+ proto.RegisterType((*WitnessAndBuildResponse)(nil), "penumbra.view.v1.WitnessAndBuildResponse")
+ proto.RegisterType((*WitnessAndBuildResponse_BuildProgress)(nil), "penumbra.view.v1.WitnessAndBuildResponse.BuildProgress")
+ proto.RegisterType((*WitnessAndBuildResponse_Complete)(nil), "penumbra.view.v1.WitnessAndBuildResponse.Complete")
+ proto.RegisterType((*AssetsRequest)(nil), "penumbra.view.v1.AssetsRequest")
+ proto.RegisterType((*AssetsResponse)(nil), "penumbra.view.v1.AssetsResponse")
+ proto.RegisterType((*AppParametersRequest)(nil), "penumbra.view.v1.AppParametersRequest")
+ proto.RegisterType((*AppParametersResponse)(nil), "penumbra.view.v1.AppParametersResponse")
+ proto.RegisterType((*GasPricesRequest)(nil), "penumbra.view.v1.GasPricesRequest")
+ proto.RegisterType((*GasPricesResponse)(nil), "penumbra.view.v1.GasPricesResponse")
+ proto.RegisterType((*FMDParametersRequest)(nil), "penumbra.view.v1.FMDParametersRequest")
+ proto.RegisterType((*FMDParametersResponse)(nil), "penumbra.view.v1.FMDParametersResponse")
+ proto.RegisterType((*NoteByCommitmentRequest)(nil), "penumbra.view.v1.NoteByCommitmentRequest")
+ proto.RegisterType((*NoteByCommitmentResponse)(nil), "penumbra.view.v1.NoteByCommitmentResponse")
+ proto.RegisterType((*SwapByCommitmentRequest)(nil), "penumbra.view.v1.SwapByCommitmentRequest")
+ proto.RegisterType((*SwapByCommitmentResponse)(nil), "penumbra.view.v1.SwapByCommitmentResponse")
+ proto.RegisterType((*UnclaimedSwapsRequest)(nil), "penumbra.view.v1.UnclaimedSwapsRequest")
+ proto.RegisterType((*UnclaimedSwapsResponse)(nil), "penumbra.view.v1.UnclaimedSwapsResponse")
+ proto.RegisterType((*NullifierStatusRequest)(nil), "penumbra.view.v1.NullifierStatusRequest")
+ proto.RegisterType((*NullifierStatusResponse)(nil), "penumbra.view.v1.NullifierStatusResponse")
+ proto.RegisterType((*TransactionInfoByHashRequest)(nil), "penumbra.view.v1.TransactionInfoByHashRequest")
+ proto.RegisterType((*TransactionInfoRequest)(nil), "penumbra.view.v1.TransactionInfoRequest")
+ proto.RegisterType((*TransactionInfo)(nil), "penumbra.view.v1.TransactionInfo")
+ proto.RegisterType((*TransactionInfoResponse)(nil), "penumbra.view.v1.TransactionInfoResponse")
+ proto.RegisterType((*TransactionInfoByHashResponse)(nil), "penumbra.view.v1.TransactionInfoByHashResponse")
+ proto.RegisterType((*NotesResponse)(nil), "penumbra.view.v1.NotesResponse")
+ proto.RegisterType((*NotesForVotingResponse)(nil), "penumbra.view.v1.NotesForVotingResponse")
+ proto.RegisterType((*SpendableNoteRecord)(nil), "penumbra.view.v1.SpendableNoteRecord")
+ proto.RegisterType((*SwapRecord)(nil), "penumbra.view.v1.SwapRecord")
+ proto.RegisterType((*OwnedPositionIdsRequest)(nil), "penumbra.view.v1.OwnedPositionIdsRequest")
+ proto.RegisterType((*OwnedPositionIdsResponse)(nil), "penumbra.view.v1.OwnedPositionIdsResponse")
+ proto.RegisterType((*AssetMetadataByIdRequest)(nil), "penumbra.view.v1.AssetMetadataByIdRequest")
+ proto.RegisterType((*AssetMetadataByIdResponse)(nil), "penumbra.view.v1.AssetMetadataByIdResponse")
+ proto.RegisterType((*DelegationsByAddressIndexRequest)(nil), "penumbra.view.v1.DelegationsByAddressIndexRequest")
+ proto.RegisterType((*DelegationsByAddressIndexResponse)(nil), "penumbra.view.v1.DelegationsByAddressIndexResponse")
+}
+
+func init() { proto.RegisterFile("penumbra/view/v1/view.proto", fileDescriptor_dba93d04e42ddfc3) }
+
+var fileDescriptor_dba93d04e42ddfc3 = []byte{
+ // 3847 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x3b, 0x4d, 0x6f, 0x1b, 0x49,
+ 0x76, 0x6a, 0x4a, 0x96, 0xa8, 0x27, 0xf1, 0x43, 0x65, 0x4b, 0xa2, 0xb9, 0x1e, 0xd9, 0xee, 0xd9,
+ 0x19, 0x7f, 0xed, 0x52, 0x1f, 0xf6, 0xee, 0xce, 0x78, 0x1c, 0x6c, 0x44, 0x7d, 0x58, 0x9a, 0xf1,
+ 0xc8, 0x9c, 0x96, 0x2c, 0x4f, 0x26, 0x9e, 0x74, 0x8a, 0xdd, 0x25, 0xa9, 0x63, 0xb2, 0xbb, 0xd3,
+ 0x5d, 0xa4, 0xa4, 0xfc, 0x80, 0x00, 0xd9, 0x20, 0x40, 0x80, 0xe4, 0x9c, 0x43, 0x80, 0x4d, 0x82,
+ 0x04, 0xc8, 0x2d, 0x87, 0x9c, 0x72, 0xdd, 0x0d, 0x10, 0x60, 0x91, 0xd3, 0x5e, 0x02, 0x0c, 0x66,
+ 0x6e, 0xb9, 0xe7, 0x94, 0x43, 0x82, 0xfa, 0xe8, 0x66, 0x77, 0xb3, 0x5b, 0x24, 0x65, 0x25, 0xc0,
+ 0x9e, 0x58, 0xf5, 0xea, 0x7d, 0xd5, 0xab, 0xaa, 0x57, 0xaf, 0xde, 0x6b, 0xc2, 0xf7, 0x5c, 0x62,
+ 0x77, 0xda, 0x4d, 0x0f, 0x2f, 0x77, 0x2d, 0x72, 0xba, 0xdc, 0x5d, 0xe5, 0xbf, 0x35, 0xd7, 0x73,
+ 0xa8, 0x83, 0xca, 0xc1, 0x60, 0x8d, 0x03, 0xbb, 0xab, 0xd5, 0xa5, 0x10, 0xdd, 0x70, 0x3c, 0xb2,
+ 0x8c, 0x5d, 0x97, 0x91, 0x60, 0xd7, 0x15, 0x14, 0x55, 0x35, 0x31, 0xee, 0xfb, 0x84, 0x72, 0x0c,
+ 0xd6, 0x90, 0x38, 0xf7, 0xe3, 0x38, 0x86, 0xd3, 0x76, 0x1d, 0x9b, 0xd8, 0x74, 0xd9, 0x24, 0x67,
+ 0x0c, 0xd7, 0x24, 0x67, 0x83, 0x30, 0x8f, 0x08, 0x61, 0x98, 0x47, 0x84, 0x0c, 0xc2, 0xb4, 0x9a,
+ 0x06, 0xc3, 0xb4, 0x9a, 0xc6, 0x20, 0x4c, 0xdf, 0xe0, 0x9a, 0xfa, 0x46, 0xa0, 0xe7, 0xb3, 0x4c,
+ 0xcc, 0x13, 0x8b, 0xb4, 0x4c, 0x62, 0xea, 0xae, 0xe3, 0xb4, 0x38, 0x4d, 0x14, 0x20, 0xa9, 0x7f,
+ 0x90, 0x49, 0x4d, 0xf1, 0x5b, 0xae, 0x3d, 0x6f, 0x48, 0xec, 0x3b, 0x71, 0xec, 0xb7, 0xe4, 0xdc,
+ 0x67, 0x28, 0xec, 0x57, 0x62, 0x24, 0x2c, 0x6f, 0x77, 0xda, 0x0c, 0xc1, 0xee, 0xb4, 0xe5, 0x78,
+ 0x2d, 0x3e, 0x4e, 0x3d, 0x6c, 0xfb, 0xd8, 0xa0, 0x96, 0x63, 0x33, 0xbc, 0x48, 0x57, 0xe2, 0x7f,
+ 0x3f, 0x81, 0x7f, 0x76, 0x82, 0xfd, 0x13, 0x8e, 0xca, 0x5b, 0xfd, 0x7a, 0x79, 0xe7, 0x2e, 0x75,
+ 0x96, 0xa9, 0xb0, 0x12, 0x0d, 0xac, 0xa4, 0x52, 0xa8, 0xac, 0x77, 0xe8, 0x89, 0xe3, 0x59, 0x7f,
+ 0x44, 0xd6, 0x6d, 0xb3, 0xde, 0xb1, 0x5a, 0xa6, 0x46, 0xfe, 0xb0, 0x43, 0x7c, 0x8a, 0xbe, 0x84,
+ 0x72, 0x44, 0xb0, 0xee, 0xb6, 0xb0, 0x5d, 0x51, 0xee, 0x28, 0xf7, 0x67, 0xd6, 0x7e, 0x18, 0xaa,
+ 0x5b, 0x63, 0xe2, 0x6b, 0x51, 0xfd, 0xba, 0xab, 0xb5, 0x83, 0x5e, 0xb7, 0xd1, 0xc2, 0xb6, 0x56,
+ 0xa2, 0x71, 0x80, 0xfa, 0x5d, 0x0e, 0x6e, 0xa6, 0x88, 0xf5, 0x5d, 0xc7, 0xf6, 0x09, 0x6a, 0x42,
+ 0xb1, 0xc9, 0x00, 0xba, 0xeb, 0x39, 0xc7, 0x1e, 0xf1, 0x7d, 0x29, 0xf5, 0xe3, 0x5a, 0x72, 0x43,
+ 0xd7, 0x32, 0x99, 0xd4, 0x78, 0xaf, 0x21, 0x19, 0xec, 0x8c, 0x69, 0x85, 0x66, 0x14, 0x80, 0x34,
+ 0xc8, 0xb3, 0x35, 0x6d, 0x11, 0x4a, 0x2a, 0x39, 0xce, 0xfd, 0xc9, 0x28, 0xdc, 0x37, 0x24, 0xed,
+ 0xce, 0x98, 0x16, 0xf2, 0xa9, 0x3e, 0x82, 0x42, 0x4c, 0x2a, 0xaa, 0x42, 0x3e, 0x36, 0x85, 0x9c,
+ 0x16, 0xf6, 0xab, 0xaf, 0x21, 0x1f, 0x30, 0x41, 0x9f, 0xc1, 0x4c, 0xc4, 0x42, 0x72, 0xb6, 0x0f,
+ 0x86, 0xb6, 0xb1, 0x16, 0xa5, 0xae, 0xe7, 0x61, 0xd2, 0xa7, 0x98, 0x76, 0x7c, 0xf5, 0x2f, 0x14,
+ 0xf8, 0x5e, 0xdd, 0x73, 0xb0, 0x69, 0x60, 0x9f, 0x46, 0xf1, 0xe5, 0xfa, 0x5e, 0xa5, 0x58, 0x74,
+ 0x0f, 0x4a, 0xf8, 0x14, 0x5b, 0x54, 0x37, 0x09, 0x25, 0x82, 0x21, 0xb3, 0x6b, 0x5e, 0x2b, 0x72,
+ 0xf0, 0x66, 0x00, 0x55, 0xff, 0x71, 0x1c, 0x6e, 0xa5, 0x6b, 0x25, 0x97, 0xdf, 0x86, 0xb9, 0x66,
+ 0x30, 0xae, 0xfb, 0x1d, 0xc3, 0xe8, 0xed, 0x80, 0x9f, 0xf6, 0xaf, 0xd1, 0x45, 0xac, 0x7a, 0x83,
+ 0xfb, 0x82, 0xcd, 0xce, 0x98, 0x56, 0x6e, 0x26, 0x60, 0xe8, 0x4b, 0x98, 0x36, 0x1c, 0xfb, 0xc8,
+ 0xf2, 0xda, 0xc4, 0x94, 0x7b, 0xe1, 0xa3, 0x11, 0xe5, 0x6c, 0x04, 0xf4, 0x3b, 0x63, 0x5a, 0x8f,
+ 0x59, 0xf5, 0x53, 0x28, 0x27, 0x35, 0x40, 0x3f, 0x86, 0x9c, 0x65, 0xca, 0xe9, 0x7c, 0x98, 0xb4,
+ 0xb5, 0x38, 0xbb, 0x71, 0x33, 0xef, 0x9a, 0x5a, 0xce, 0x32, 0xab, 0x36, 0x4c, 0x87, 0x52, 0x2e,
+ 0xcb, 0x04, 0x3d, 0x80, 0x72, 0xb8, 0x3c, 0xfa, 0x09, 0xb1, 0x8e, 0x4f, 0x28, 0x9f, 0xf1, 0x84,
+ 0x56, 0x0a, 0xe1, 0x3b, 0x1c, 0x1c, 0xd9, 0x46, 0x7f, 0xb7, 0x08, 0x37, 0x13, 0x27, 0xda, 0x26,
+ 0x5e, 0xb0, 0x89, 0xde, 0x87, 0x02, 0x39, 0x73, 0x2d, 0xef, 0x3c, 0xe0, 0xa7, 0x70, 0x7e, 0xb3,
+ 0x02, 0x28, 0x98, 0xa1, 0x9f, 0xc2, 0x44, 0x9b, 0xb4, 0x9d, 0xca, 0x38, 0xd7, 0xf8, 0xd1, 0xc5,
+ 0x5b, 0xec, 0x73, 0xd2, 0x76, 0x1a, 0x2d, 0x6c, 0xd9, 0x94, 0x9c, 0x51, 0x8d, 0x13, 0xa2, 0x4f,
+ 0x60, 0xd2, 0x77, 0x3a, 0x9e, 0x41, 0x2a, 0x13, 0x9c, 0xc5, 0xfb, 0x09, 0x16, 0xdc, 0xd3, 0xb2,
+ 0x13, 0x6b, 0x9a, 0xec, 0x74, 0xed, 0xda, 0x26, 0x39, 0xd3, 0x24, 0x09, 0x7a, 0x01, 0x53, 0x4e,
+ 0x87, 0xba, 0x1d, 0xea, 0x57, 0x6e, 0xdc, 0x19, 0xbf, 0x3f, 0xb3, 0xb6, 0xd6, 0xbf, 0xbc, 0x99,
+ 0x13, 0xac, 0xbd, 0xe4, 0xa4, 0x5a, 0xc0, 0x02, 0x6d, 0xc3, 0x35, 0xff, 0x14, 0xbb, 0x7e, 0x65,
+ 0x89, 0xf3, 0x5a, 0x19, 0x85, 0xd7, 0xfe, 0x29, 0x76, 0x35, 0x41, 0x8e, 0x0e, 0x61, 0x86, 0x35,
+ 0x74, 0xa3, 0x85, 0xad, 0xb6, 0x5f, 0xb9, 0xcd, 0xb9, 0xfd, 0x68, 0x54, 0x6e, 0x1b, 0x8c, 0x5a,
+ 0x03, 0x3f, 0x68, 0x72, 0xbe, 0x26, 0x69, 0x91, 0x63, 0xcc, 0x28, 0xfc, 0xca, 0x7d, 0xce, 0xf7,
+ 0xc9, 0x28, 0x7c, 0x37, 0x05, 0x39, 0xd1, 0xa2, 0x8c, 0xd0, 0x1b, 0x28, 0x74, 0xec, 0x28, 0xe7,
+ 0x35, 0xce, 0xf9, 0xc7, 0xa3, 0x70, 0x7e, 0x15, 0x30, 0x20, 0x5a, 0x9c, 0x19, 0x6a, 0xc1, 0xf5,
+ 0x28, 0x20, 0xb0, 0xca, 0x63, 0x2e, 0xe3, 0x93, 0xcb, 0xc9, 0x10, 0xb6, 0x41, 0x51, 0xbe, 0xd2,
+ 0x46, 0x07, 0x30, 0x67, 0x35, 0x0d, 0xdd, 0x23, 0x2d, 0x7c, 0xae, 0x0b, 0x2e, 0x7e, 0xe5, 0x19,
+ 0x97, 0x75, 0x3f, 0xb1, 0xb3, 0xc2, 0x9b, 0xbf, 0xc6, 0x82, 0x90, 0xee, 0x6a, 0x6d, 0xb7, 0x69,
+ 0x68, 0x8c, 0x4e, 0x2b, 0x59, 0xb2, 0xb5, 0x6e, 0x04, 0x16, 0x9a, 0xb3, 0x0c, 0x7f, 0x6d, 0x45,
+ 0x3f, 0xb5, 0xe8, 0x89, 0xe9, 0xe1, 0x53, 0xdc, 0xf2, 0x2b, 0xbf, 0xc5, 0xb9, 0x2e, 0x0f, 0xe4,
+ 0xca, 0x08, 0x5f, 0x87, 0x74, 0x5a, 0xd9, 0x8a, 0x03, 0x7c, 0xa4, 0x43, 0xd1, 0x75, 0x7c, 0x8b,
+ 0x5b, 0xc7, 0x71, 0x89, 0xed, 0x57, 0xb6, 0x39, 0xeb, 0x8f, 0x46, 0x31, 0x4e, 0x43, 0x72, 0x78,
+ 0xe9, 0x12, 0x5b, 0x2b, 0xb8, 0x91, 0x9e, 0x8f, 0x9a, 0x50, 0x0a, 0x05, 0x18, 0x2d, 0xc7, 0x27,
+ 0x7e, 0xe5, 0x39, 0x97, 0xf0, 0xf1, 0x65, 0x24, 0x6c, 0x30, 0x0e, 0x5a, 0xa8, 0x32, 0xef, 0xfa,
+ 0xe8, 0x2d, 0xa0, 0x50, 0x46, 0x60, 0x25, 0xbf, 0xb2, 0xc3, 0xc5, 0x3c, 0xbb, 0x8c, 0x98, 0xc0,
+ 0x42, 0xda, 0x9c, 0x9b, 0x80, 0xf8, 0x68, 0x13, 0xf2, 0xb8, 0x43, 0x1d, 0xfd, 0x88, 0x90, 0x8a,
+ 0xc9, 0xdd, 0xc6, 0xbd, 0xcc, 0x65, 0x60, 0xb1, 0x68, 0x77, 0xb5, 0xb6, 0x4d, 0xc8, 0x81, 0x45,
+ 0xbc, 0x9d, 0x31, 0x6d, 0x8a, 0x91, 0x6e, 0x13, 0x82, 0x36, 0x01, 0xda, 0xd8, 0xee, 0xe0, 0x16,
+ 0xe7, 0x43, 0x52, 0xdd, 0x4f, 0x1a, 0x1f, 0x76, 0x15, 0x08, 0x42, 0xc6, 0xe5, 0xfb, 0x30, 0x43,
+ 0x5c, 0xc7, 0x38, 0xd1, 0x2d, 0xe6, 0x9a, 0x2a, 0xbf, 0xe0, 0x5e, 0xb2, 0x9e, 0xab, 0x28, 0x1a,
+ 0x70, 0x38, 0xf7, 0x58, 0xe8, 0x19, 0x5c, 0xe3, 0xbd, 0xca, 0x2f, 0x85, 0x6f, 0xff, 0x20, 0x53,
+ 0x0e, 0x8b, 0x73, 0xbb, 0xab, 0xb5, 0x2d, 0x86, 0xad, 0x09, 0xa2, 0xea, 0x29, 0x4c, 0x0a, 0x67,
+ 0x85, 0x1e, 0xc3, 0xb5, 0x2e, 0x6e, 0x75, 0x88, 0xbc, 0x22, 0xde, 0x4b, 0xb0, 0x11, 0xe1, 0x7c,
+ 0x77, 0xb5, 0x76, 0xc8, 0x90, 0x34, 0x81, 0x8b, 0x3e, 0x82, 0x29, 0x2c, 0xdc, 0xa7, 0xbc, 0x05,
+ 0x97, 0x2e, 0x76, 0xb2, 0x5a, 0x80, 0x5e, 0xfd, 0x6f, 0x05, 0x26, 0x98, 0x33, 0xba, 0x9c, 0xdc,
+ 0x3a, 0xcc, 0x52, 0xec, 0x1d, 0x13, 0xaa, 0xf3, 0x71, 0x29, 0xfc, 0x76, 0x16, 0xed, 0x3a, 0x6b,
+ 0xec, 0x9a, 0xda, 0x8c, 0x20, 0xe2, 0x5d, 0xf4, 0x23, 0x18, 0x67, 0xab, 0x33, 0x3e, 0xf4, 0xea,
+ 0x68, 0x0c, 0x1f, 0x6d, 0x40, 0x81, 0x3b, 0x1a, 0x3d, 0x98, 0xf8, 0xc4, 0x50, 0x13, 0x9f, 0xe5,
+ 0x44, 0xb2, 0x57, 0xfd, 0x1a, 0xa6, 0x43, 0x4f, 0x8c, 0x1a, 0x50, 0x12, 0x5e, 0xdd, 0x69, 0xb7,
+ 0x2d, 0xda, 0x26, 0x36, 0x95, 0xb6, 0x88, 0x6e, 0x3d, 0x1e, 0x8b, 0xd7, 0xa8, 0x58, 0xc2, 0x7d,
+ 0xca, 0x5c, 0x55, 0x88, 0xae, 0x15, 0xb9, 0x2f, 0x0f, 0xfb, 0xd5, 0x3f, 0x51, 0x20, 0x1f, 0x78,
+ 0x64, 0xf4, 0x04, 0x26, 0x71, 0xdb, 0xe9, 0x84, 0x5c, 0x6f, 0x25, 0x34, 0x65, 0x0f, 0x0a, 0xa6,
+ 0x28, 0xc7, 0xd1, 0x24, 0x2e, 0x7a, 0x0e, 0xd3, 0x1e, 0xa6, 0x44, 0x37, 0x31, 0xc5, 0xd2, 0x46,
+ 0x0f, 0xb3, 0x77, 0x16, 0x7f, 0xd7, 0x74, 0x57, 0x6b, 0x1a, 0xa6, 0x64, 0x13, 0x53, 0xac, 0xe5,
+ 0x3d, 0xd9, 0xaa, 0xfe, 0x4c, 0x01, 0xe8, 0xf9, 0xd7, 0xcb, 0x2d, 0x77, 0x4c, 0x99, 0xdc, 0x3b,
+ 0x28, 0xf3, 0xeb, 0x1c, 0x94, 0x12, 0xce, 0x1e, 0x7d, 0x01, 0xa8, 0x8b, 0x5b, 0x96, 0x89, 0xa9,
+ 0xe3, 0xe9, 0x96, 0x49, 0x6c, 0x6a, 0xd1, 0x73, 0xa9, 0x9e, 0x9a, 0xb1, 0xaa, 0xbb, 0x12, 0xed,
+ 0x33, 0x72, 0xae, 0xcd, 0x85, 0xd4, 0x01, 0x14, 0xd5, 0x60, 0xce, 0xa7, 0xd8, 0xa3, 0x7a, 0xf4,
+ 0xfc, 0xe6, 0xc2, 0xe3, 0x5b, 0xe2, 0x83, 0x5b, 0xbd, 0x33, 0xbc, 0x01, 0x53, 0x2e, 0xb1, 0x71,
+ 0x8b, 0x9e, 0x4b, 0x53, 0x3f, 0x18, 0x3c, 0xbb, 0x86, 0x20, 0xd0, 0x02, 0x4a, 0xf4, 0x1c, 0xca,
+ 0x1d, 0xbb, 0xe9, 0xd8, 0xa6, 0x65, 0x1f, 0xeb, 0x72, 0xc5, 0x27, 0x86, 0x58, 0xf1, 0x52, 0x48,
+ 0x25, 0x00, 0xe8, 0x09, 0x2c, 0xf4, 0x18, 0x89, 0x79, 0xc8, 0x38, 0xed, 0x1a, 0x8f, 0xd3, 0x6e,
+ 0x84, 0xa3, 0xfb, 0x6c, 0x50, 0xc4, 0x6b, 0xd5, 0x03, 0x98, 0x8d, 0xde, 0x14, 0xcc, 0x93, 0x06,
+ 0xee, 0x55, 0x1a, 0x33, 0xfb, 0x9a, 0x64, 0xef, 0x7f, 0x36, 0x25, 0x89, 0xaf, 0x85, 0x94, 0xd5,
+ 0x37, 0x50, 0x88, 0xdd, 0x0e, 0xec, 0x01, 0x12, 0xde, 0x06, 0x61, 0x3c, 0xfb, 0x70, 0x58, 0xce,
+ 0xbb, 0xa6, 0x06, 0x6e, 0xd8, 0xae, 0xfe, 0x97, 0x02, 0xe5, 0xe4, 0xad, 0x70, 0xa5, 0x12, 0x98,
+ 0x15, 0x3c, 0xe2, 0x13, 0xaf, 0x4b, 0x02, 0x0f, 0x39, 0xd0, 0x0a, 0x9a, 0xc4, 0xd7, 0x42, 0x4a,
+ 0xb4, 0x07, 0xb3, 0xd4, 0xc3, 0x7c, 0x3d, 0x5c, 0x6c, 0x79, 0x19, 0x31, 0x71, 0x1f, 0xa7, 0x03,
+ 0x41, 0xd3, 0xc0, 0x96, 0xc7, 0x1f, 0x5e, 0x41, 0xa7, 0x0e, 0x90, 0x3f, 0x22, 0x44, 0x6f, 0x3b,
+ 0x26, 0x51, 0x75, 0xa8, 0xa6, 0x5d, 0x99, 0xf2, 0x61, 0xb5, 0x0e, 0x13, 0x97, 0x7f, 0xc3, 0x73,
+ 0x52, 0x15, 0xc3, 0xbc, 0x74, 0x7b, 0xf5, 0x73, 0x11, 0x64, 0xcb, 0x67, 0xc0, 0x0e, 0x14, 0xa4,
+ 0x0f, 0x95, 0x27, 0x44, 0x19, 0x3e, 0x4e, 0x9f, 0xc5, 0x91, 0x9e, 0xaa, 0xc1, 0x42, 0x52, 0x84,
+ 0xd4, 0x3f, 0x72, 0x41, 0x29, 0x23, 0x5d, 0x50, 0xea, 0x1c, 0x94, 0x5e, 0xe3, 0x56, 0x8b, 0xdf,
+ 0x1b, 0x42, 0x61, 0xb5, 0x01, 0xe5, 0x1e, 0x48, 0x0a, 0x78, 0x06, 0xd3, 0xa7, 0x1c, 0xd6, 0xdb,
+ 0x2b, 0xb7, 0x33, 0x44, 0x84, 0xb4, 0xf9, 0x53, 0xd9, 0x52, 0xbf, 0x80, 0x79, 0xae, 0x6f, 0xfd,
+ 0x3c, 0x90, 0x2f, 0x6d, 0x73, 0x79, 0xbd, 0x9b, 0xb0, 0x90, 0x64, 0x29, 0x55, 0xbd, 0x3a, 0x7b,
+ 0x1b, 0xb0, 0xb8, 0xe5, 0x9e, 0x90, 0x36, 0xf1, 0x70, 0x2b, 0xa1, 0xf8, 0xd5, 0x09, 0x39, 0x80,
+ 0x4a, 0xbf, 0x90, 0x77, 0x5e, 0xd6, 0xbf, 0x51, 0xa0, 0x54, 0xc7, 0x2d, 0x6c, 0x1b, 0x24, 0xd4,
+ 0xf9, 0x53, 0x28, 0x62, 0xc3, 0x60, 0xbe, 0x4f, 0x3f, 0xb2, 0x5a, 0x94, 0x78, 0xa3, 0x28, 0x5d,
+ 0x90, 0xa4, 0xdb, 0x9c, 0x12, 0x3d, 0x87, 0x12, 0xbf, 0xc3, 0x74, 0xcb, 0x0c, 0x98, 0x0d, 0x19,
+ 0x9c, 0x14, 0xb0, 0x68, 0x08, 0x46, 0xea, 0xcf, 0x73, 0x50, 0xee, 0x29, 0x1a, 0x1e, 0xc7, 0x29,
+ 0x29, 0x6e, 0x04, 0x15, 0xf9, 0x9d, 0x13, 0xd0, 0xa1, 0x4f, 0x60, 0xaa, 0x29, 0xd8, 0x4a, 0xc5,
+ 0x2e, 0xbe, 0x82, 0x05, 0xb1, 0xa4, 0x40, 0x9f, 0x41, 0x29, 0xb0, 0x54, 0x60, 0xff, 0xf1, 0x0b,
+ 0x2f, 0x4a, 0xa9, 0xc7, 0xa1, 0x45, 0x4e, 0xb5, 0xc0, 0xc8, 0x12, 0x86, 0x36, 0x61, 0x56, 0xf2,
+ 0xd5, 0x59, 0xf0, 0x2e, 0x2f, 0xab, 0xbb, 0x17, 0xaa, 0xc3, 0x19, 0xcd, 0x48, 0x32, 0xd6, 0x51,
+ 0x4b, 0x50, 0xd8, 0xe7, 0x49, 0x87, 0xe0, 0x94, 0xfe, 0xa9, 0x02, 0xc5, 0x00, 0x22, 0xcd, 0x76,
+ 0x1f, 0xca, 0x47, 0x9d, 0x56, 0x4b, 0xf7, 0xcf, 0x6d, 0x23, 0x9e, 0x73, 0x28, 0x32, 0xf8, 0xfe,
+ 0xb9, 0x6d, 0xc8, 0xac, 0x43, 0x0d, 0xae, 0xbb, 0xd8, 0xa3, 0x16, 0x8e, 0x23, 0x8b, 0x84, 0xc7,
+ 0x9c, 0x1c, 0x8a, 0xe0, 0xdf, 0x86, 0x19, 0x03, 0x53, 0xe3, 0x84, 0xb9, 0xe6, 0x8e, 0xcb, 0x8d,
+ 0x91, 0xd7, 0x20, 0x00, 0xbd, 0x72, 0xd5, 0x79, 0xb8, 0x2e, 0x94, 0xd9, 0xa7, 0x1e, 0xc1, 0xed,
+ 0x40, 0xc9, 0x7f, 0x50, 0xe0, 0x46, 0x1c, 0x2e, 0x55, 0xfd, 0x18, 0x6e, 0xb6, 0x30, 0x25, 0x3e,
+ 0xd5, 0xdf, 0xda, 0xce, 0xa9, 0xad, 0x37, 0x5b, 0x8e, 0xf1, 0x36, 0xae, 0xf3, 0x82, 0x40, 0xf8,
+ 0x8c, 0x8d, 0xd7, 0xd9, 0xb0, 0xd4, 0x25, 0x6d, 0x96, 0xb9, 0x51, 0x66, 0x39, 0x9e, 0x31, 0x4b,
+ 0xf5, 0x7f, 0x14, 0x98, 0xdd, 0x73, 0x68, 0xef, 0xc4, 0xbc, 0x0f, 0x05, 0xcb, 0x36, 0x5a, 0x1d,
+ 0x93, 0xe8, 0xbe, 0xcb, 0x02, 0x56, 0x91, 0xb7, 0x9b, 0x95, 0xc0, 0x7d, 0x06, 0x43, 0x4f, 0x21,
+ 0x1f, 0x1c, 0x05, 0xb9, 0x4b, 0x06, 0x9e, 0x81, 0x29, 0x79, 0x06, 0xfa, 0xdd, 0xc8, 0xc4, 0x25,
+ 0xdd, 0x08, 0xda, 0x84, 0x92, 0x08, 0x86, 0x74, 0xea, 0x70, 0x65, 0xcd, 0xca, 0xe4, 0x10, 0x51,
+ 0x51, 0x41, 0x10, 0x1d, 0x38, 0x6c, 0x2e, 0xa6, 0xfa, 0x67, 0x0a, 0xcc, 0x73, 0x0b, 0x6c, 0x3b,
+ 0xde, 0xa1, 0x43, 0x2d, 0xfb, 0x38, 0x30, 0xc5, 0x43, 0x98, 0xeb, 0x3a, 0x14, 0x37, 0x5b, 0x44,
+ 0xc7, 0x34, 0xbe, 0x50, 0x25, 0x39, 0xb0, 0x2e, 0x63, 0xa4, 0xfe, 0x59, 0x8d, 0x5f, 0xd6, 0x39,
+ 0xfe, 0x01, 0x14, 0x5f, 0x5b, 0xd4, 0x8e, 0x38, 0xde, 0xb4, 0xcc, 0xfb, 0xf8, 0x95, 0x64, 0xde,
+ 0x75, 0x28, 0x85, 0xb2, 0xe4, 0x2e, 0x7d, 0x01, 0xb3, 0xa7, 0x02, 0x24, 0x62, 0xf2, 0xa1, 0xf2,
+ 0xc0, 0x92, 0x09, 0x0f, 0xc9, 0x67, 0x4e, 0x7b, 0x1d, 0xf5, 0xdf, 0x15, 0x58, 0x90, 0x83, 0xff,
+ 0x6f, 0xf5, 0x04, 0xf4, 0x7b, 0x80, 0xb0, 0xcc, 0xd5, 0x8b, 0xf4, 0x51, 0xe4, 0x71, 0xb1, 0x7c,
+ 0x31, 0xef, 0xf5, 0x28, 0x1d, 0x9f, 0xce, 0x1c, 0x4e, 0x82, 0xd4, 0xff, 0xc8, 0xc1, 0x62, 0xdf,
+ 0xa4, 0xa4, 0xf9, 0x7e, 0x3f, 0xa3, 0x5a, 0xf1, 0x93, 0xfe, 0x74, 0x46, 0x06, 0x8b, 0x41, 0xb5,
+ 0x8a, 0x46, 0x5f, 0xad, 0x62, 0x6d, 0x78, 0xde, 0xbf, 0x11, 0x95, 0x8a, 0x9f, 0x8f, 0x43, 0x81,
+ 0xbb, 0x8d, 0xf0, 0x04, 0x54, 0x21, 0x2f, 0x6e, 0x5c, 0x22, 0x22, 0xb1, 0xbc, 0x16, 0xf6, 0x91,
+ 0x01, 0x4b, 0x11, 0x87, 0x65, 0x58, 0x47, 0x96, 0xa1, 0x9b, 0xc4, 0x76, 0xda, 0x96, 0x2d, 0x53,
+ 0x93, 0x39, 0x9e, 0x50, 0xca, 0xbc, 0x0c, 0x37, 0x19, 0xb2, 0x76, 0xab, 0xe7, 0xe0, 0x38, 0x8f,
+ 0xcd, 0x28, 0x0b, 0xf4, 0x14, 0x6e, 0x06, 0x42, 0x22, 0x69, 0x49, 0xea, 0xbc, 0x25, 0xb6, 0x2f,
+ 0xaf, 0x86, 0x45, 0x89, 0xb0, 0x19, 0x8e, 0x1f, 0xf0, 0x61, 0xf4, 0x11, 0x54, 0x02, 0xda, 0xde,
+ 0xe3, 0x4b, 0x92, 0x4e, 0x70, 0xd2, 0x05, 0x39, 0xfe, 0x2a, 0x18, 0x96, 0x94, 0x1f, 0x42, 0x29,
+ 0xa0, 0x6c, 0xb9, 0xba, 0x7d, 0x44, 0x7d, 0xfe, 0x4e, 0xcb, 0x6b, 0x81, 0x8b, 0x7e, 0xe1, 0xee,
+ 0x1d, 0x51, 0x1f, 0xad, 0xc1, 0x7c, 0x80, 0xe7, 0x7a, 0x8e, 0xeb, 0xf8, 0xb8, 0x25, 0xb0, 0x27,
+ 0x39, 0xf6, 0x75, 0x39, 0xd8, 0x90, 0x63, 0x9c, 0x66, 0x1d, 0xde, 0x0b, 0x68, 0xba, 0xdc, 0xeb,
+ 0xe9, 0x1e, 0x31, 0x88, 0xe5, 0xd2, 0x40, 0xb5, 0x29, 0x4e, 0x5b, 0x95, 0x48, 0x81, 0x67, 0xe4,
+ 0x28, 0x42, 0x3d, 0xf5, 0x77, 0xa0, 0x18, 0x2c, 0x93, 0xdc, 0xfd, 0xcf, 0xa1, 0xc8, 0x4d, 0xaf,
+ 0xb7, 0x09, 0xc5, 0x91, 0x53, 0x77, 0x27, 0xcb, 0xf6, 0x9f, 0x4b, 0x3c, 0xad, 0xc0, 0xe9, 0x82,
+ 0xae, 0xba, 0x00, 0x37, 0xd6, 0x5d, 0xb7, 0x81, 0x3d, 0xdc, 0x26, 0x94, 0x78, 0x61, 0x04, 0xf0,
+ 0x06, 0xe6, 0x13, 0x70, 0x29, 0x79, 0x03, 0xc0, 0x0d, 0xa1, 0x19, 0x11, 0x14, 0x76, 0x5d, 0x7e,
+ 0xc6, 0x63, 0x0c, 0x22, 0x64, 0x2a, 0x82, 0xf2, 0x73, 0xec, 0x37, 0x3c, 0xab, 0x17, 0x41, 0xaa,
+ 0x5f, 0xc3, 0x5c, 0x04, 0x16, 0xc6, 0xdb, 0x70, 0x8c, 0x7d, 0xdd, 0xe5, 0xd0, 0x8c, 0x7d, 0xdf,
+ 0x97, 0x67, 0xea, 0xb1, 0x99, 0x3e, 0x0e, 0x9a, 0x6c, 0xa2, 0xdb, 0x9f, 0x6f, 0xf6, 0x4f, 0xd4,
+ 0x85, 0xf9, 0x04, 0x5c, 0x8a, 0x7e, 0x9d, 0x32, 0xd1, 0x9f, 0x64, 0xe7, 0x14, 0x62, 0xc5, 0xec,
+ 0xee, 0x6a, 0x6d, 0xbb, 0x6d, 0x66, 0x4c, 0xfe, 0x2f, 0x15, 0x58, 0x64, 0xf7, 0x60, 0xfd, 0x3c,
+ 0x92, 0x7e, 0x92, 0xe7, 0xaf, 0x01, 0x25, 0xdb, 0xa1, 0x24, 0x9a, 0xc7, 0xca, 0x8d, 0x98, 0xc7,
+ 0x62, 0xf4, 0xbd, 0x7e, 0x5a, 0x81, 0x70, 0x3c, 0xb5, 0x40, 0x78, 0x02, 0x95, 0x7e, 0xad, 0xc2,
+ 0xbb, 0xaa, 0xc8, 0xaf, 0x7d, 0x7e, 0x45, 0x33, 0x01, 0x95, 0xbe, 0x44, 0x69, 0xe0, 0x10, 0xf7,
+ 0x03, 0x3c, 0xc6, 0x4c, 0x23, 0x86, 0xe3, 0x99, 0x5a, 0xc1, 0x8f, 0x02, 0xb9, 0x01, 0xf6, 0x4f,
+ 0xb1, 0x9b, 0x61, 0x80, 0x64, 0x22, 0x2f, 0xf7, 0x4e, 0x89, 0xbc, 0xe1, 0x0d, 0xf0, 0x02, 0x2a,
+ 0xfd, 0x5a, 0x49, 0x03, 0xac, 0xc0, 0x04, 0x63, 0xdb, 0x9f, 0xfe, 0x0b, 0xa7, 0x7d, 0x8a, 0x5d,
+ 0x39, 0x5b, 0x8e, 0xa9, 0x2e, 0xc2, 0xfc, 0x2b, 0x9b, 0x27, 0x2c, 0x89, 0xc9, 0x06, 0xc3, 0x0d,
+ 0xf7, 0x29, 0x2c, 0x24, 0x07, 0x2e, 0x2d, 0xe4, 0x67, 0x0a, 0x2c, 0xec, 0x75, 0x5a, 0x2d, 0xeb,
+ 0xc8, 0x22, 0x5e, 0x2c, 0x84, 0x47, 0xcf, 0x61, 0xda, 0x0e, 0x46, 0xa4, 0x09, 0x1f, 0x0c, 0x4a,
+ 0x6b, 0x87, 0xac, 0xb4, 0x1e, 0xed, 0xf0, 0xf6, 0x5b, 0x86, 0xc5, 0x3e, 0x5d, 0xe4, 0xcc, 0x6e,
+ 0xc0, 0x35, 0x11, 0xe3, 0x8a, 0x3b, 0x45, 0x74, 0xd4, 0x43, 0xb8, 0x15, 0xad, 0x95, 0xda, 0x47,
+ 0x4e, 0xfd, 0x7c, 0x07, 0xfb, 0x27, 0xc1, 0x14, 0x44, 0xb9, 0x35, 0x37, 0x6a, 0xb9, 0x55, 0xfd,
+ 0x0a, 0x16, 0x12, 0x7c, 0x03, 0x8e, 0x77, 0x61, 0x36, 0x96, 0x8c, 0x13, 0x31, 0xe6, 0x8c, 0xdf,
+ 0xcb, 0xc1, 0xa1, 0xf7, 0x00, 0x88, 0x6d, 0xc6, 0x63, 0xff, 0x69, 0x62, 0x9b, 0x32, 0x8c, 0xff,
+ 0x65, 0x0e, 0x4a, 0x09, 0xe6, 0x68, 0x01, 0x26, 0x63, 0xfc, 0x64, 0xef, 0xb2, 0xfa, 0x27, 0x6f,
+ 0xfb, 0xf1, 0x77, 0xfa, 0x40, 0xe0, 0x10, 0x66, 0x5c, 0xe2, 0xb1, 0x0b, 0x9b, 0x5a, 0xdd, 0xa0,
+ 0x8e, 0xfb, 0x64, 0xf8, 0xc0, 0xaf, 0x47, 0xab, 0x45, 0x19, 0xa1, 0x75, 0x98, 0xe0, 0x2f, 0xce,
+ 0x6b, 0x23, 0x46, 0x92, 0xfc, 0xf5, 0xc9, 0x49, 0xd5, 0x57, 0xb0, 0xd8, 0xb7, 0x4e, 0x72, 0xc3,
+ 0x3c, 0x85, 0x29, 0x7a, 0xa6, 0x5b, 0xf6, 0x91, 0x23, 0x4f, 0xc3, 0xdd, 0x0b, 0xab, 0x54, 0x9c,
+ 0x76, 0x92, 0x9e, 0xb1, 0x5f, 0xf5, 0x77, 0xe1, 0xbd, 0x8c, 0x6d, 0x75, 0x05, 0xcc, 0x5f, 0x43,
+ 0x41, 0xbe, 0xe2, 0x24, 0xb3, 0x6d, 0x98, 0xe1, 0x1e, 0xdb, 0xe3, 0xe7, 0x72, 0x34, 0xbf, 0x08,
+ 0x76, 0xd8, 0x56, 0xff, 0x96, 0x1d, 0xe5, 0xc4, 0xeb, 0xe8, 0x6a, 0x45, 0xa0, 0x2d, 0x98, 0x0d,
+ 0x72, 0xf3, 0xfa, 0x5b, 0x72, 0x2e, 0x77, 0xe6, 0x30, 0xf9, 0xf9, 0x19, 0xab, 0xd7, 0x51, 0xff,
+ 0x79, 0x02, 0xae, 0xa7, 0x88, 0x4a, 0xbb, 0xbb, 0x94, 0x77, 0xbb, 0xbb, 0xea, 0x30, 0xc1, 0x2f,
+ 0x1b, 0xa1, 0x68, 0x6d, 0xf8, 0xcb, 0x97, 0x6b, 0xc5, 0x69, 0xaf, 0xee, 0xbd, 0x18, 0xf7, 0xa8,
+ 0x13, 0xef, 0xe0, 0x51, 0x3f, 0x80, 0xa2, 0xf0, 0x10, 0xba, 0xe1, 0x11, 0x4c, 0x89, 0x29, 0x8b,
+ 0x02, 0x05, 0x01, 0xdd, 0x10, 0x40, 0xe6, 0xac, 0x24, 0x9a, 0xf0, 0x9d, 0x93, 0xc2, 0x59, 0x09,
+ 0x98, 0x48, 0x0f, 0x54, 0x23, 0x05, 0x82, 0x29, 0x3e, 0x1c, 0xf6, 0xd1, 0x4e, 0xf8, 0xed, 0x46,
+ 0x9e, 0xeb, 0xba, 0x32, 0x48, 0xd7, 0x9e, 0xe1, 0xf7, 0x39, 0x5d, 0xf8, 0x21, 0xc7, 0x2e, 0x14,
+ 0x3d, 0x42, 0x3b, 0x9e, 0x1d, 0x26, 0xac, 0xa6, 0x87, 0x4e, 0x58, 0x15, 0x04, 0xa5, 0x04, 0xa9,
+ 0xff, 0x36, 0x0e, 0xd0, 0xbb, 0xc5, 0xae, 0xbe, 0x6c, 0xc7, 0xdc, 0x12, 0xbf, 0x43, 0x73, 0xa9,
+ 0x6e, 0xa9, 0x2f, 0xbd, 0xcf, 0x74, 0x89, 0x7c, 0xf4, 0xc2, 0x48, 0x63, 0x46, 0x1d, 0x4f, 0x18,
+ 0xf5, 0xca, 0xf6, 0xc0, 0x01, 0xcc, 0x88, 0x2f, 0x5b, 0xc4, 0x9b, 0x59, 0x78, 0xd1, 0xc7, 0x83,
+ 0xd4, 0xad, 0x63, 0x6a, 0x9c, 0x30, 0x9d, 0x45, 0xc1, 0x99, 0xbf, 0x9b, 0xc1, 0x09, 0xdb, 0xd1,
+ 0x9d, 0x25, 0x02, 0x0c, 0xb9, 0x69, 0x82, 0x9d, 0x25, 0x80, 0x91, 0xad, 0x31, 0xf5, 0x6e, 0x5b,
+ 0x43, 0xfd, 0x17, 0x05, 0x16, 0x5f, 0x9e, 0xda, 0xc4, 0xec, 0xd5, 0x6e, 0xc2, 0x08, 0xe4, 0x20,
+ 0xf2, 0xe5, 0x04, 0x7b, 0x70, 0x92, 0x8c, 0xac, 0x43, 0x66, 0x1d, 0x88, 0xaf, 0x75, 0xef, 0x73,
+ 0x09, 0xde, 0xed, 0xab, 0xe3, 0xe4, 0xde, 0xad, 0x8e, 0xa3, 0x1e, 0x43, 0xa5, 0x7f, 0x02, 0xd2,
+ 0xf1, 0x5e, 0x65, 0x19, 0x4b, 0x3d, 0x84, 0x0a, 0x7f, 0xc4, 0x05, 0x4f, 0xaf, 0xfa, 0x79, 0x58,
+ 0x15, 0x89, 0xa5, 0xf9, 0x72, 0xa3, 0xa5, 0xf9, 0x54, 0x13, 0x6e, 0xa6, 0xf0, 0xcd, 0x7c, 0x27,
+ 0x2a, 0x97, 0x7b, 0x27, 0xfe, 0x55, 0x0e, 0xee, 0xf4, 0x1e, 0xdc, 0x7e, 0x58, 0x19, 0xf9, 0xbf,
+ 0xa9, 0x46, 0xa1, 0x2f, 0x60, 0x32, 0x92, 0xf9, 0x2f, 0xa6, 0x7d, 0x0b, 0x33, 0x48, 0x9b, 0x9a,
+ 0x28, 0x02, 0x68, 0x92, 0x91, 0xfa, 0x35, 0x4c, 0xca, 0xfa, 0xc2, 0x02, 0xa0, 0xed, 0xdd, 0x17,
+ 0x07, 0x5b, 0x9a, 0xfe, 0x6a, 0x6f, 0xbf, 0xb1, 0xb5, 0xb1, 0xbb, 0xbd, 0xbb, 0xb5, 0x59, 0x1e,
+ 0x43, 0x8f, 0xe0, 0x9e, 0x84, 0xaf, 0xbf, 0x78, 0xa1, 0xaf, 0x6f, 0x1c, 0xec, 0x1e, 0x6e, 0xe9,
+ 0xaf, 0x77, 0x0f, 0x76, 0xf4, 0xbd, 0x97, 0x7b, 0x5f, 0x6d, 0x69, 0x2f, 0xf5, 0xfa, 0xfa, 0x8b,
+ 0xf5, 0xbd, 0x8d, 0xad, 0xfd, 0xb2, 0x82, 0x8a, 0x00, 0x3d, 0xe4, 0x72, 0x4e, 0x25, 0x70, 0xf7,
+ 0x02, 0x8d, 0xe4, 0x72, 0xfc, 0x36, 0x00, 0xaf, 0xc6, 0x8b, 0x64, 0xbd, 0x32, 0x6c, 0xb2, 0x7e,
+ 0xba, 0x1b, 0x34, 0xd7, 0xfe, 0x69, 0x1e, 0x66, 0x58, 0x63, 0x9f, 0x78, 0x5d, 0x8b, 0x57, 0x13,
+ 0x26, 0x45, 0xac, 0x8d, 0x6e, 0xa7, 0x04, 0x04, 0xd1, 0x17, 0x41, 0xf5, 0x4e, 0x36, 0x82, 0x54,
+ 0x4f, 0x87, 0xd9, 0x68, 0x42, 0x1d, 0x7d, 0x90, 0x45, 0x11, 0x4b, 0xc4, 0x57, 0x3f, 0x1c, 0x84,
+ 0x26, 0xd8, 0xaf, 0x28, 0xe8, 0x53, 0xb8, 0xc6, 0x63, 0x1c, 0xb4, 0xd4, 0x4f, 0x12, 0x4d, 0x8e,
+ 0x57, 0x6f, 0x67, 0x8e, 0x87, 0xbc, 0x08, 0x14, 0xe3, 0xf1, 0x12, 0xba, 0x97, 0x41, 0x94, 0xcc,
+ 0x37, 0x57, 0xef, 0x0f, 0x46, 0x0c, 0xc5, 0x7c, 0x0e, 0x93, 0x22, 0xf7, 0x92, 0x66, 0xe0, 0x58,
+ 0xf2, 0x2c, 0xcd, 0xc0, 0xf1, 0xb4, 0xcd, 0x8a, 0x82, 0x5a, 0x30, 0xd7, 0x77, 0x5a, 0xd1, 0xc3,
+ 0x0c, 0xc2, 0x14, 0x57, 0x51, 0x7d, 0x34, 0x14, 0x6e, 0x98, 0x24, 0x2d, 0xc4, 0x92, 0x30, 0x28,
+ 0x65, 0xa9, 0xd2, 0xd2, 0x3f, 0xd5, 0x7b, 0x03, 0xf1, 0xa4, 0x84, 0x03, 0x98, 0x0e, 0xd3, 0x2d,
+ 0x48, 0xed, 0xa7, 0x4a, 0xa6, 0x79, 0xaa, 0xef, 0x5f, 0x88, 0xd3, 0xd3, 0x3b, 0x96, 0x94, 0x49,
+ 0xd3, 0x3b, 0x2d, 0x9b, 0x93, 0xa6, 0x77, 0x7a, 0x76, 0xc7, 0x80, 0x62, 0xbc, 0xdc, 0x9d, 0xb6,
+ 0x7b, 0x52, 0x6b, 0xee, 0x69, 0xbb, 0x27, 0xa3, 0x72, 0xfe, 0x05, 0xe4, 0x83, 0x82, 0x35, 0x4a,
+ 0x79, 0x63, 0x24, 0x6a, 0xe3, 0x55, 0xf5, 0x22, 0x94, 0x9e, 0xde, 0xf1, 0xd2, 0x74, 0x9a, 0xde,
+ 0xa9, 0xf5, 0xf0, 0x34, 0xbd, 0x33, 0xaa, 0xdc, 0x16, 0x94, 0x93, 0x65, 0x63, 0xf4, 0xa0, 0x9f,
+ 0x3a, 0xa3, 0x7e, 0x5d, 0x7d, 0x38, 0x0c, 0xaa, 0x14, 0xb5, 0x0f, 0xf9, 0xa0, 0x42, 0x9b, 0x66,
+ 0xa2, 0x44, 0x99, 0x39, 0xcd, 0x44, 0xc9, 0x02, 0xef, 0x8a, 0xc2, 0xf4, 0x4f, 0xa6, 0xb2, 0xd2,
+ 0xf4, 0xcf, 0x48, 0xc2, 0xa5, 0xe9, 0x9f, 0x99, 0x19, 0xb3, 0xa0, 0x9c, 0x4c, 0x1a, 0xa5, 0x89,
+ 0xca, 0x48, 0x77, 0xa5, 0x89, 0xca, 0xcc, 0x41, 0x11, 0x28, 0xc6, 0x13, 0x47, 0x69, 0x4b, 0x9f,
+ 0x9a, 0x73, 0x4a, 0x5b, 0xfa, 0xf4, 0x1c, 0xd4, 0x8a, 0x82, 0x8e, 0xa0, 0x94, 0x48, 0xe3, 0xa0,
+ 0x34, 0x7f, 0x99, 0x9a, 0x75, 0xaa, 0x3e, 0x18, 0x02, 0x53, 0x4e, 0xe7, 0x0c, 0xe6, 0x53, 0x9f,
+ 0xe9, 0xa8, 0x36, 0xf0, 0x35, 0x1e, 0x4b, 0x13, 0x55, 0x97, 0x87, 0xc6, 0x97, 0x92, 0x4f, 0xfa,
+ 0x53, 0x38, 0xf7, 0x07, 0x67, 0x00, 0xb2, 0x67, 0x98, 0x91, 0xc4, 0x58, 0x51, 0xd0, 0x5b, 0x28,
+ 0x27, 0x83, 0xcb, 0xb4, 0xdd, 0x91, 0x11, 0x41, 0xa7, 0xed, 0x8e, 0xac, 0x58, 0x75, 0x45, 0x41,
+ 0x0e, 0xa0, 0xfe, 0xaf, 0x90, 0xd0, 0xa3, 0x11, 0x3e, 0xef, 0xad, 0xfe, 0x60, 0x38, 0x64, 0x69,
+ 0xc7, 0x3d, 0x98, 0x92, 0xe5, 0x2f, 0x74, 0x27, 0xb3, 0x32, 0x16, 0xb0, 0xbe, 0x7b, 0x01, 0x46,
+ 0x6f, 0x5d, 0x12, 0xe5, 0xb4, 0xb4, 0x75, 0x49, 0xaf, 0x72, 0xa6, 0xad, 0x4b, 0x46, 0x6d, 0x6e,
+ 0x45, 0x41, 0x36, 0xcc, 0xf5, 0xfd, 0xc9, 0x28, 0xf5, 0x16, 0xce, 0xf8, 0x8f, 0x56, 0xea, 0x2d,
+ 0x9c, 0xf5, 0xaf, 0xa5, 0x15, 0x05, 0x9d, 0xc2, 0x8d, 0xb4, 0x3f, 0xb2, 0xa0, 0x1f, 0x0e, 0xfb,
+ 0x87, 0x17, 0x21, 0xb5, 0x36, 0xda, 0xff, 0x63, 0x56, 0x14, 0xf4, 0xc7, 0x0a, 0xdc, 0xcc, 0x0c,
+ 0x4b, 0xd1, 0xda, 0xe8, 0x51, 0x75, 0xf5, 0xf1, 0x48, 0x34, 0x81, 0x22, 0xf5, 0x6f, 0x94, 0x5f,
+ 0x7c, 0xbb, 0xa4, 0xfc, 0xea, 0xdb, 0x25, 0xe5, 0x9b, 0x6f, 0x97, 0x94, 0x3f, 0xff, 0x6e, 0x69,
+ 0xec, 0x57, 0xdf, 0x2d, 0x8d, 0xfd, 0xfa, 0xbb, 0xa5, 0x31, 0xb8, 0x61, 0x38, 0xed, 0x3e, 0xa6,
+ 0xf5, 0x69, 0x16, 0xe5, 0x36, 0x3c, 0x87, 0x3a, 0x0d, 0xe5, 0xab, 0x8d, 0x63, 0x8b, 0x9e, 0x74,
+ 0x9a, 0xec, 0xad, 0xb5, 0x6c, 0x38, 0x7e, 0xdb, 0xf1, 0x97, 0xf9, 0x9f, 0x08, 0x88, 0xb7, 0xdc,
+ 0x5d, 0x0b, 0x9b, 0xc6, 0x09, 0xb6, 0x6c, 0x7f, 0x39, 0xf9, 0xdf, 0xcc, 0x4f, 0xd8, 0x6f, 0x77,
+ 0xf5, 0xaf, 0x73, 0xe3, 0x8d, 0xc3, 0x2f, 0xff, 0x3e, 0x57, 0x6e, 0x04, 0xa2, 0x98, 0x84, 0xda,
+ 0xe1, 0xea, 0xbf, 0xf6, 0x40, 0x6f, 0x18, 0xe8, 0xcd, 0xe1, 0xea, 0xb7, 0xb9, 0x5b, 0x49, 0xd0,
+ 0x9b, 0xe7, 0x8d, 0x7a, 0x10, 0x63, 0xfd, 0x67, 0x0e, 0x05, 0xc3, 0x4f, 0x9f, 0xb2, 0xf1, 0xa7,
+ 0x4f, 0x0f, 0x57, 0x9b, 0x93, 0xfc, 0xaf, 0x7d, 0x8f, 0xff, 0x37, 0x00, 0x00, 0xff, 0xff, 0x04,
+ 0x1d, 0xb5, 0xb5, 0x1d, 0x3a, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@@ -3737,88 +4433,124 @@ var _ grpc.ClientConn
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
-// ViewProtocolServiceClient is the client API for ViewProtocolService service.
+// ViewServiceClient is the client API for ViewService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type ViewProtocolServiceClient interface {
+type ViewServiceClient 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.
+ StatusStream(ctx context.Context, in *StatusStreamRequest, opts ...grpc.CallOption) (ViewService_StatusStreamClient, error)
+ // 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)
+ Notes(ctx context.Context, in *NotesRequest, opts ...grpc.CallOption) (ViewService_NotesClient, error)
// Returns a stream of `NotesForVotingResponse`s.
- NotesForVoting(ctx context.Context, in *NotesForVotingRequest, opts ...grpc.CallOption) (ViewProtocolService_NotesForVotingClient, error)
- // Returns authentication paths for the given note commitments.
- //
- // This method takes a batch of input commitments, rather than just one, so
- // that the client can get a consistent set of authentication paths to a
- // common root. (Otherwise, if a client made multiple requests, the wallet
- // service could have advanced the state commitment tree state between queries).
- Witness(ctx context.Context, in *WitnessRequest, opts ...grpc.CallOption) (*WitnessResponse, error)
- WitnessAndBuild(ctx context.Context, in *WitnessAndBuildRequest, opts ...grpc.CallOption) (*WitnessAndBuildResponse, error)
- // Queries for assets.
+ NotesForVoting(ctx context.Context, in *NotesForVotingRequest, opts ...grpc.CallOption) (ViewService_NotesForVotingClient, error)
+ // Queries for metadata about known 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)
+ Assets(ctx context.Context, in *AssetsRequest, opts ...grpc.CallOption) (ViewService_AssetsClient, error)
+ // Query for metadata about a specific asset, by asset ID.
+ //
+ // This is the same as the method on the shielded pool's `QueryService`, but exposing it
+ // here allows a view server to provide more specific or opinionated asset metadata -- like
+ // using an asset registry to provide tickers, symbols, etc.
+ AssetMetadataById(ctx context.Context, in *AssetMetadataByIdRequest, opts ...grpc.CallOption) (*AssetMetadataByIdResponse, 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
EphemeralAddress(ctx context.Context, in *EphemeralAddressRequest, opts ...grpc.CallOption) (*EphemeralAddressResponse, error)
// Query for balance of a given address.
// Returns a stream of `BalancesResponses`.
- Balances(ctx context.Context, in *BalancesRequest, opts ...grpc.CallOption) (ViewProtocolService_BalancesClient, error)
+ Balances(ctx context.Context, in *BalancesRequest, opts ...grpc.CallOption) (ViewService_BalancesClient, error)
// Query for a note by its note commitment, optionally waiting until the note is detected.
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) (ViewService_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.
TransactionInfoByHash(ctx context.Context, in *TransactionInfoByHashRequest, opts ...grpc.CallOption) (*TransactionInfoByHashResponse, error)
// Query for the full transactions in the given range of blocks.
// Returns a stream of `TransactionInfoResponse`s.
- TransactionInfo(ctx context.Context, in *TransactionInfoRequest, opts ...grpc.CallOption) (ViewProtocolService_TransactionInfoClient, error)
- // Query for a transaction plan
- TransactionPlanner(ctx context.Context, in *TransactionPlannerRequest, opts ...grpc.CallOption) (*TransactionPlannerResponse, error)
- // Broadcast a transaction to the network, optionally waiting for full confirmation.
- BroadcastTransaction(ctx context.Context, in *BroadcastTransactionRequest, opts ...grpc.CallOption) (*BroadcastTransactionResponse, error)
+ TransactionInfo(ctx context.Context, in *TransactionInfoRequest, opts ...grpc.CallOption) (ViewService_TransactionInfoClient, error)
// Query for owned position IDs for the given trading pair and in the given position state.
- OwnedPositionIds(ctx context.Context, in *OwnedPositionIdsRequest, opts ...grpc.CallOption) (ViewProtocolService_OwnedPositionIdsClient, error)
+ OwnedPositionIds(ctx context.Context, in *OwnedPositionIdsRequest, opts ...grpc.CallOption) (ViewService_OwnedPositionIdsClient, error)
+ // Translates a high-level intent ("send X funds to Y address") into a complete transaction plan.
+ TransactionPlanner(ctx context.Context, in *TransactionPlannerRequest, opts ...grpc.CallOption) (*TransactionPlannerResponse, error)
+ // Returns authentication data for the given transaction plan.
+ //
+ // This method takes a complete transaction plan, so that the client can get a
+ // consistent set of authentication paths to a common root for the entire
+ // transaction. (Otherwise, if a client made multiple requests, the wallet
+ // service could have advanced the state commitment tree between queries).
+ Witness(ctx context.Context, in *WitnessRequest, opts ...grpc.CallOption) (*WitnessResponse, error)
+ // Like `Witness`, but immediately uses the witness data to build (prove) the transaction.
+ //
+ // This method is useful for clients that can't easily do proving themselves, either because
+ // they're not written in Rust and can't easily import the proving code, or because they don't
+ // have access to proving keys, or some other reason.
+ //
+ // This method streams status updates to the caller before finally returning the transaction.
+ WitnessAndBuild(ctx context.Context, in *WitnessAndBuildRequest, opts ...grpc.CallOption) (ViewService_WitnessAndBuildClient, error)
// Authorize a transaction plan and build the transaction.
- AuthorizeAndBuild(ctx context.Context, in *AuthorizeAndBuildRequest, opts ...grpc.CallOption) (*AuthorizeAndBuildResponse, error)
+ //
+ // This method is only supported on view servers that have access to a custody
+ // service. Otherwise, it will fail.
+ //
+ // Penumbra's transaction authorization mechanism is designed so transactions
+ // can be signed and built (proved) concurrently. This allows implementations
+ // to, e.g., start proving optimistically while presenting the user with an
+ // approval dialog.
+ //
+ // This method streams status updates to the caller before finally returning the transaction.
+ AuthorizeAndBuild(ctx context.Context, in *AuthorizeAndBuildRequest, opts ...grpc.CallOption) (ViewService_AuthorizeAndBuildClient, error)
+ // Broadcast a transaction to the network, optionally waiting for full confirmation.
+ //
+ // This method streams status updates to the caller before finally returning confirmation.
+ BroadcastTransaction(ctx context.Context, in *BroadcastTransactionRequest, opts ...grpc.CallOption) (ViewService_BroadcastTransactionClient, error)
+ // Get delegation tokens for a given address index. Each delegation token will
+ // be represented by a `ValueView` with the given address index's balance of
+ // that token. Each `ValueView`'s `extended_metadata` field will contain the
+ // `ValidatorInfo` of the delegated validator.
+ DelegationsByAddressIndex(ctx context.Context, in *DelegationsByAddressIndexRequest, opts ...grpc.CallOption) (ViewService_DelegationsByAddressIndexClient, error)
}
-type viewProtocolServiceClient struct {
+type viewServiceClient struct {
cc grpc1.ClientConn
}
-func NewViewProtocolServiceClient(cc grpc1.ClientConn) ViewProtocolServiceClient {
- return &viewProtocolServiceClient{cc}
+func NewViewServiceClient(cc grpc1.ClientConn) ViewServiceClient {
+ return &viewServiceClient{cc}
}
-func (c *viewProtocolServiceClient) Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error) {
+func (c *viewServiceClient) Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error) {
out := new(StatusResponse)
- err := c.cc.Invoke(ctx, "/penumbra.view.v1alpha1.ViewProtocolService/Status", in, out, opts...)
+ err := c.cc.Invoke(ctx, "/penumbra.view.v1.ViewService/Status", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
-func (c *viewProtocolServiceClient) StatusStream(ctx context.Context, in *StatusStreamRequest, opts ...grpc.CallOption) (ViewProtocolService_StatusStreamClient, error) {
- stream, err := c.cc.NewStream(ctx, &_ViewProtocolService_serviceDesc.Streams[0], "/penumbra.view.v1alpha1.ViewProtocolService/StatusStream", opts...)
+func (c *viewServiceClient) StatusStream(ctx context.Context, in *StatusStreamRequest, opts ...grpc.CallOption) (ViewService_StatusStreamClient, error) {
+ stream, err := c.cc.NewStream(ctx, &_ViewService_serviceDesc.Streams[0], "/penumbra.view.v1.ViewService/StatusStream", opts...)
if err != nil {
return nil, err
}
- x := &viewProtocolServiceStatusStreamClient{stream}
+ x := &viewServiceStatusStreamClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
@@ -3828,16 +4560,16 @@ func (c *viewProtocolServiceClient) StatusStream(ctx context.Context, in *Status
return x, nil
}
-type ViewProtocolService_StatusStreamClient interface {
+type ViewService_StatusStreamClient interface {
Recv() (*StatusStreamResponse, error)
grpc.ClientStream
}
-type viewProtocolServiceStatusStreamClient struct {
+type viewServiceStatusStreamClient struct {
grpc.ClientStream
}
-func (x *viewProtocolServiceStatusStreamClient) Recv() (*StatusStreamResponse, error) {
+func (x *viewServiceStatusStreamClient) Recv() (*StatusStreamResponse, error) {
m := new(StatusStreamResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
@@ -3845,12 +4577,12 @@ func (x *viewProtocolServiceStatusStreamClient) Recv() (*StatusStreamResponse, e
return m, nil
}
-func (c *viewProtocolServiceClient) Notes(ctx context.Context, in *NotesRequest, opts ...grpc.CallOption) (ViewProtocolService_NotesClient, error) {
- stream, err := c.cc.NewStream(ctx, &_ViewProtocolService_serviceDesc.Streams[1], "/penumbra.view.v1alpha1.ViewProtocolService/Notes", opts...)
+func (c *viewServiceClient) Notes(ctx context.Context, in *NotesRequest, opts ...grpc.CallOption) (ViewService_NotesClient, error) {
+ stream, err := c.cc.NewStream(ctx, &_ViewService_serviceDesc.Streams[1], "/penumbra.view.v1.ViewService/Notes", opts...)
if err != nil {
return nil, err
}
- x := &viewProtocolServiceNotesClient{stream}
+ x := &viewServiceNotesClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
@@ -3860,16 +4592,16 @@ func (c *viewProtocolServiceClient) Notes(ctx context.Context, in *NotesRequest,
return x, nil
}
-type ViewProtocolService_NotesClient interface {
+type ViewService_NotesClient interface {
Recv() (*NotesResponse, error)
grpc.ClientStream
}
-type viewProtocolServiceNotesClient struct {
+type viewServiceNotesClient struct {
grpc.ClientStream
}
-func (x *viewProtocolServiceNotesClient) Recv() (*NotesResponse, error) {
+func (x *viewServiceNotesClient) Recv() (*NotesResponse, error) {
m := new(NotesResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
@@ -3877,12 +4609,12 @@ func (x *viewProtocolServiceNotesClient) Recv() (*NotesResponse, error) {
return m, nil
}
-func (c *viewProtocolServiceClient) NotesForVoting(ctx context.Context, in *NotesForVotingRequest, opts ...grpc.CallOption) (ViewProtocolService_NotesForVotingClient, error) {
- stream, err := c.cc.NewStream(ctx, &_ViewProtocolService_serviceDesc.Streams[2], "/penumbra.view.v1alpha1.ViewProtocolService/NotesForVoting", opts...)
+func (c *viewServiceClient) NotesForVoting(ctx context.Context, in *NotesForVotingRequest, opts ...grpc.CallOption) (ViewService_NotesForVotingClient, error) {
+ stream, err := c.cc.NewStream(ctx, &_ViewService_serviceDesc.Streams[2], "/penumbra.view.v1.ViewService/NotesForVoting", opts...)
if err != nil {
return nil, err
}
- x := &viewProtocolServiceNotesForVotingClient{stream}
+ x := &viewServiceNotesForVotingClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
@@ -3892,16 +4624,16 @@ func (c *viewProtocolServiceClient) NotesForVoting(ctx context.Context, in *Note
return x, nil
}
-type ViewProtocolService_NotesForVotingClient interface {
+type ViewService_NotesForVotingClient interface {
Recv() (*NotesForVotingResponse, error)
grpc.ClientStream
}
-type viewProtocolServiceNotesForVotingClient struct {
+type viewServiceNotesForVotingClient struct {
grpc.ClientStream
}
-func (x *viewProtocolServiceNotesForVotingClient) Recv() (*NotesForVotingResponse, error) {
+func (x *viewServiceNotesForVotingClient) Recv() (*NotesForVotingResponse, error) {
m := new(NotesForVotingResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
@@ -3909,30 +4641,12 @@ func (x *viewProtocolServiceNotesForVotingClient) Recv() (*NotesForVotingRespons
return m, nil
}
-func (c *viewProtocolServiceClient) Witness(ctx context.Context, in *WitnessRequest, opts ...grpc.CallOption) (*WitnessResponse, error) {
- out := new(WitnessResponse)
- err := c.cc.Invoke(ctx, "/penumbra.view.v1alpha1.ViewProtocolService/Witness", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *viewProtocolServiceClient) WitnessAndBuild(ctx context.Context, in *WitnessAndBuildRequest, opts ...grpc.CallOption) (*WitnessAndBuildResponse, error) {
- out := new(WitnessAndBuildResponse)
- err := c.cc.Invoke(ctx, "/penumbra.view.v1alpha1.ViewProtocolService/WitnessAndBuild", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *viewProtocolServiceClient) Assets(ctx context.Context, in *AssetsRequest, opts ...grpc.CallOption) (ViewProtocolService_AssetsClient, error) {
- stream, err := c.cc.NewStream(ctx, &_ViewProtocolService_serviceDesc.Streams[3], "/penumbra.view.v1alpha1.ViewProtocolService/Assets", opts...)
+func (c *viewServiceClient) Assets(ctx context.Context, in *AssetsRequest, opts ...grpc.CallOption) (ViewService_AssetsClient, error) {
+ stream, err := c.cc.NewStream(ctx, &_ViewService_serviceDesc.Streams[3], "/penumbra.view.v1.ViewService/Assets", opts...)
if err != nil {
return nil, err
}
- x := &viewProtocolServiceAssetsClient{stream}
+ x := &viewServiceAssetsClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
@@ -3942,16 +4656,16 @@ func (c *viewProtocolServiceClient) Assets(ctx context.Context, in *AssetsReques
return x, nil
}
-type ViewProtocolService_AssetsClient interface {
+type ViewService_AssetsClient interface {
Recv() (*AssetsResponse, error)
grpc.ClientStream
}
-type viewProtocolServiceAssetsClient struct {
+type viewServiceAssetsClient struct {
grpc.ClientStream
}
-func (x *viewProtocolServiceAssetsClient) Recv() (*AssetsResponse, error) {
+func (x *viewServiceAssetsClient) Recv() (*AssetsResponse, error) {
m := new(AssetsResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
@@ -3959,57 +4673,84 @@ 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 *viewServiceClient) AssetMetadataById(ctx context.Context, in *AssetMetadataByIdRequest, opts ...grpc.CallOption) (*AssetMetadataByIdResponse, error) {
+ out := new(AssetMetadataByIdResponse)
+ err := c.cc.Invoke(ctx, "/penumbra.view.v1.ViewService/AssetMetadataById", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *viewServiceClient) AppParameters(ctx context.Context, in *AppParametersRequest, opts ...grpc.CallOption) (*AppParametersResponse, error) {
+ out := new(AppParametersResponse)
+ err := c.cc.Invoke(ctx, "/penumbra.view.v1.ViewService/AppParameters", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *viewServiceClient) GasPrices(ctx context.Context, in *GasPricesRequest, opts ...grpc.CallOption) (*GasPricesResponse, error) {
+ out := new(GasPricesResponse)
+ err := c.cc.Invoke(ctx, "/penumbra.view.v1.ViewService/GasPrices", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
-func (c *viewProtocolServiceClient) FMDParameters(ctx context.Context, in *FMDParametersRequest, opts ...grpc.CallOption) (*FMDParametersResponse, error) {
+func (c *viewServiceClient) FMDParameters(ctx context.Context, in *FMDParametersRequest, opts ...grpc.CallOption) (*FMDParametersResponse, error) {
out := new(FMDParametersResponse)
- err := c.cc.Invoke(ctx, "/penumbra.view.v1alpha1.ViewProtocolService/FMDParameters", in, out, opts...)
+ err := c.cc.Invoke(ctx, "/penumbra.view.v1.ViewService/FMDParameters", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
-func (c *viewProtocolServiceClient) AddressByIndex(ctx context.Context, in *AddressByIndexRequest, opts ...grpc.CallOption) (*AddressByIndexResponse, error) {
+func (c *viewServiceClient) AddressByIndex(ctx context.Context, in *AddressByIndexRequest, opts ...grpc.CallOption) (*AddressByIndexResponse, error) {
out := new(AddressByIndexResponse)
- err := c.cc.Invoke(ctx, "/penumbra.view.v1alpha1.ViewProtocolService/AddressByIndex", in, out, opts...)
+ err := c.cc.Invoke(ctx, "/penumbra.view.v1.ViewService/AddressByIndex", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *viewServiceClient) WalletId(ctx context.Context, in *WalletIdRequest, opts ...grpc.CallOption) (*WalletIdResponse, error) {
+ out := new(WalletIdResponse)
+ err := c.cc.Invoke(ctx, "/penumbra.view.v1.ViewService/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) {
+func (c *viewServiceClient) 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...)
+ err := c.cc.Invoke(ctx, "/penumbra.view.v1.ViewService/IndexByAddress", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
-func (c *viewProtocolServiceClient) EphemeralAddress(ctx context.Context, in *EphemeralAddressRequest, opts ...grpc.CallOption) (*EphemeralAddressResponse, error) {
+func (c *viewServiceClient) EphemeralAddress(ctx context.Context, in *EphemeralAddressRequest, opts ...grpc.CallOption) (*EphemeralAddressResponse, error) {
out := new(EphemeralAddressResponse)
- err := c.cc.Invoke(ctx, "/penumbra.view.v1alpha1.ViewProtocolService/EphemeralAddress", in, out, opts...)
+ err := c.cc.Invoke(ctx, "/penumbra.view.v1.ViewService/EphemeralAddress", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
-func (c *viewProtocolServiceClient) Balances(ctx context.Context, in *BalancesRequest, opts ...grpc.CallOption) (ViewProtocolService_BalancesClient, error) {
- stream, err := c.cc.NewStream(ctx, &_ViewProtocolService_serviceDesc.Streams[4], "/penumbra.view.v1alpha1.ViewProtocolService/Balances", opts...)
+func (c *viewServiceClient) Balances(ctx context.Context, in *BalancesRequest, opts ...grpc.CallOption) (ViewService_BalancesClient, error) {
+ stream, err := c.cc.NewStream(ctx, &_ViewService_serviceDesc.Streams[4], "/penumbra.view.v1.ViewService/Balances", opts...)
if err != nil {
return nil, err
}
- x := &viewProtocolServiceBalancesClient{stream}
+ x := &viewServiceBalancesClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
@@ -4019,16 +4760,16 @@ func (c *viewProtocolServiceClient) Balances(ctx context.Context, in *BalancesRe
return x, nil
}
-type ViewProtocolService_BalancesClient interface {
+type ViewService_BalancesClient interface {
Recv() (*BalancesResponse, error)
grpc.ClientStream
}
-type viewProtocolServiceBalancesClient struct {
+type viewServiceBalancesClient struct {
grpc.ClientStream
}
-func (x *viewProtocolServiceBalancesClient) Recv() (*BalancesResponse, error) {
+func (x *viewServiceBalancesClient) Recv() (*BalancesResponse, error) {
m := new(BalancesResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
@@ -4036,48 +4777,30 @@ func (x *viewProtocolServiceBalancesClient) Recv() (*BalancesResponse, error) {
return m, nil
}
-func (c *viewProtocolServiceClient) NoteByCommitment(ctx context.Context, in *NoteByCommitmentRequest, opts ...grpc.CallOption) (*NoteByCommitmentResponse, error) {
+func (c *viewServiceClient) NoteByCommitment(ctx context.Context, in *NoteByCommitmentRequest, opts ...grpc.CallOption) (*NoteByCommitmentResponse, error) {
out := new(NoteByCommitmentResponse)
- err := c.cc.Invoke(ctx, "/penumbra.view.v1alpha1.ViewProtocolService/NoteByCommitment", in, out, opts...)
+ err := c.cc.Invoke(ctx, "/penumbra.view.v1.ViewService/NoteByCommitment", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
-func (c *viewProtocolServiceClient) SwapByCommitment(ctx context.Context, in *SwapByCommitmentRequest, opts ...grpc.CallOption) (*SwapByCommitmentResponse, error) {
+func (c *viewServiceClient) SwapByCommitment(ctx context.Context, in *SwapByCommitmentRequest, opts ...grpc.CallOption) (*SwapByCommitmentResponse, error) {
out := new(SwapByCommitmentResponse)
- err := c.cc.Invoke(ctx, "/penumbra.view.v1alpha1.ViewProtocolService/SwapByCommitment", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, 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...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *viewProtocolServiceClient) TransactionInfoByHash(ctx context.Context, in *TransactionInfoByHashRequest, opts ...grpc.CallOption) (*TransactionInfoByHashResponse, error) {
- out := new(TransactionInfoByHashResponse)
- err := c.cc.Invoke(ctx, "/penumbra.view.v1alpha1.ViewProtocolService/TransactionInfoByHash", in, out, opts...)
+ err := c.cc.Invoke(ctx, "/penumbra.view.v1.ViewService/SwapByCommitment", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
-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...)
+func (c *viewServiceClient) UnclaimedSwaps(ctx context.Context, in *UnclaimedSwapsRequest, opts ...grpc.CallOption) (ViewService_UnclaimedSwapsClient, error) {
+ stream, err := c.cc.NewStream(ctx, &_ViewService_serviceDesc.Streams[5], "/penumbra.view.v1.ViewService/UnclaimedSwaps", opts...)
if err != nil {
return nil, err
}
- x := &viewProtocolServiceTransactionInfoClient{stream}
+ x := &viewServiceUnclaimedSwapsClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
@@ -4087,47 +4810,47 @@ func (c *viewProtocolServiceClient) TransactionInfo(ctx context.Context, in *Tra
return x, nil
}
-type ViewProtocolService_TransactionInfoClient interface {
- Recv() (*TransactionInfoResponse, error)
+type ViewService_UnclaimedSwapsClient interface {
+ Recv() (*UnclaimedSwapsResponse, error)
grpc.ClientStream
}
-type viewProtocolServiceTransactionInfoClient struct {
+type viewServiceUnclaimedSwapsClient struct {
grpc.ClientStream
}
-func (x *viewProtocolServiceTransactionInfoClient) Recv() (*TransactionInfoResponse, error) {
- m := new(TransactionInfoResponse)
+func (x *viewServiceUnclaimedSwapsClient) Recv() (*UnclaimedSwapsResponse, error) {
+ m := new(UnclaimedSwapsResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
-func (c *viewProtocolServiceClient) TransactionPlanner(ctx context.Context, in *TransactionPlannerRequest, opts ...grpc.CallOption) (*TransactionPlannerResponse, error) {
- out := new(TransactionPlannerResponse)
- err := c.cc.Invoke(ctx, "/penumbra.view.v1alpha1.ViewProtocolService/TransactionPlanner", in, out, opts...)
+func (c *viewServiceClient) NullifierStatus(ctx context.Context, in *NullifierStatusRequest, opts ...grpc.CallOption) (*NullifierStatusResponse, error) {
+ out := new(NullifierStatusResponse)
+ err := c.cc.Invoke(ctx, "/penumbra.view.v1.ViewService/NullifierStatus", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
-func (c *viewProtocolServiceClient) BroadcastTransaction(ctx context.Context, in *BroadcastTransactionRequest, opts ...grpc.CallOption) (*BroadcastTransactionResponse, error) {
- out := new(BroadcastTransactionResponse)
- err := c.cc.Invoke(ctx, "/penumbra.view.v1alpha1.ViewProtocolService/BroadcastTransaction", in, out, opts...)
+func (c *viewServiceClient) TransactionInfoByHash(ctx context.Context, in *TransactionInfoByHashRequest, opts ...grpc.CallOption) (*TransactionInfoByHashResponse, error) {
+ out := new(TransactionInfoByHashResponse)
+ err := c.cc.Invoke(ctx, "/penumbra.view.v1.ViewService/TransactionInfoByHash", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
-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...)
+func (c *viewServiceClient) TransactionInfo(ctx context.Context, in *TransactionInfoRequest, opts ...grpc.CallOption) (ViewService_TransactionInfoClient, error) {
+ stream, err := c.cc.NewStream(ctx, &_ViewService_serviceDesc.Streams[6], "/penumbra.view.v1.ViewService/TransactionInfo", opts...)
if err != nil {
return nil, err
}
- x := &viewProtocolServiceOwnedPositionIdsClient{stream}
+ x := &viewServiceTransactionInfoClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
@@ -4137,16 +4860,48 @@ func (c *viewProtocolServiceClient) OwnedPositionIds(ctx context.Context, in *Ow
return x, nil
}
-type ViewProtocolService_OwnedPositionIdsClient interface {
- Recv() (*OwnedPositionIdsResponse, error)
+type ViewService_TransactionInfoClient interface {
+ Recv() (*TransactionInfoResponse, error)
grpc.ClientStream
}
-type viewProtocolServiceOwnedPositionIdsClient struct {
+type viewServiceTransactionInfoClient struct {
grpc.ClientStream
}
-func (x *viewProtocolServiceOwnedPositionIdsClient) Recv() (*OwnedPositionIdsResponse, error) {
+func (x *viewServiceTransactionInfoClient) Recv() (*TransactionInfoResponse, error) {
+ m := new(TransactionInfoResponse)
+ if err := x.ClientStream.RecvMsg(m); err != nil {
+ return nil, err
+ }
+ return m, nil
+}
+
+func (c *viewServiceClient) OwnedPositionIds(ctx context.Context, in *OwnedPositionIdsRequest, opts ...grpc.CallOption) (ViewService_OwnedPositionIdsClient, error) {
+ stream, err := c.cc.NewStream(ctx, &_ViewService_serviceDesc.Streams[7], "/penumbra.view.v1.ViewService/OwnedPositionIds", opts...)
+ if err != nil {
+ return nil, err
+ }
+ x := &viewServiceOwnedPositionIdsClient{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 ViewService_OwnedPositionIdsClient interface {
+ Recv() (*OwnedPositionIdsResponse, error)
+ grpc.ClientStream
+}
+
+type viewServiceOwnedPositionIdsClient struct {
+ grpc.ClientStream
+}
+
+func (x *viewServiceOwnedPositionIdsClient) Recv() (*OwnedPositionIdsResponse, error) {
m := new(OwnedPositionIdsResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
@@ -4154,742 +4909,1023 @@ func (x *viewProtocolServiceOwnedPositionIdsClient) Recv() (*OwnedPositionIdsRes
return m, nil
}
-func (c *viewProtocolServiceClient) AuthorizeAndBuild(ctx context.Context, in *AuthorizeAndBuildRequest, opts ...grpc.CallOption) (*AuthorizeAndBuildResponse, error) {
- out := new(AuthorizeAndBuildResponse)
- err := c.cc.Invoke(ctx, "/penumbra.view.v1alpha1.ViewProtocolService/AuthorizeAndBuild", in, out, opts...)
+func (c *viewServiceClient) TransactionPlanner(ctx context.Context, in *TransactionPlannerRequest, opts ...grpc.CallOption) (*TransactionPlannerResponse, error) {
+ out := new(TransactionPlannerResponse)
+ err := c.cc.Invoke(ctx, "/penumbra.view.v1.ViewService/TransactionPlanner", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *viewServiceClient) Witness(ctx context.Context, in *WitnessRequest, opts ...grpc.CallOption) (*WitnessResponse, error) {
+ out := new(WitnessResponse)
+ err := c.cc.Invoke(ctx, "/penumbra.view.v1.ViewService/Witness", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
-// ViewProtocolServiceServer is the server API for ViewProtocolService service.
-type ViewProtocolServiceServer interface {
+func (c *viewServiceClient) WitnessAndBuild(ctx context.Context, in *WitnessAndBuildRequest, opts ...grpc.CallOption) (ViewService_WitnessAndBuildClient, error) {
+ stream, err := c.cc.NewStream(ctx, &_ViewService_serviceDesc.Streams[8], "/penumbra.view.v1.ViewService/WitnessAndBuild", opts...)
+ if err != nil {
+ return nil, err
+ }
+ x := &viewServiceWitnessAndBuildClient{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 ViewService_WitnessAndBuildClient interface {
+ Recv() (*WitnessAndBuildResponse, error)
+ grpc.ClientStream
+}
+
+type viewServiceWitnessAndBuildClient struct {
+ grpc.ClientStream
+}
+
+func (x *viewServiceWitnessAndBuildClient) Recv() (*WitnessAndBuildResponse, error) {
+ m := new(WitnessAndBuildResponse)
+ if err := x.ClientStream.RecvMsg(m); err != nil {
+ return nil, err
+ }
+ return m, nil
+}
+
+func (c *viewServiceClient) AuthorizeAndBuild(ctx context.Context, in *AuthorizeAndBuildRequest, opts ...grpc.CallOption) (ViewService_AuthorizeAndBuildClient, error) {
+ stream, err := c.cc.NewStream(ctx, &_ViewService_serviceDesc.Streams[9], "/penumbra.view.v1.ViewService/AuthorizeAndBuild", opts...)
+ if err != nil {
+ return nil, err
+ }
+ x := &viewServiceAuthorizeAndBuildClient{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 ViewService_AuthorizeAndBuildClient interface {
+ Recv() (*AuthorizeAndBuildResponse, error)
+ grpc.ClientStream
+}
+
+type viewServiceAuthorizeAndBuildClient struct {
+ grpc.ClientStream
+}
+
+func (x *viewServiceAuthorizeAndBuildClient) Recv() (*AuthorizeAndBuildResponse, error) {
+ m := new(AuthorizeAndBuildResponse)
+ if err := x.ClientStream.RecvMsg(m); err != nil {
+ return nil, err
+ }
+ return m, nil
+}
+
+func (c *viewServiceClient) BroadcastTransaction(ctx context.Context, in *BroadcastTransactionRequest, opts ...grpc.CallOption) (ViewService_BroadcastTransactionClient, error) {
+ stream, err := c.cc.NewStream(ctx, &_ViewService_serviceDesc.Streams[10], "/penumbra.view.v1.ViewService/BroadcastTransaction", opts...)
+ if err != nil {
+ return nil, err
+ }
+ x := &viewServiceBroadcastTransactionClient{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 ViewService_BroadcastTransactionClient interface {
+ Recv() (*BroadcastTransactionResponse, error)
+ grpc.ClientStream
+}
+
+type viewServiceBroadcastTransactionClient struct {
+ grpc.ClientStream
+}
+
+func (x *viewServiceBroadcastTransactionClient) Recv() (*BroadcastTransactionResponse, error) {
+ m := new(BroadcastTransactionResponse)
+ if err := x.ClientStream.RecvMsg(m); err != nil {
+ return nil, err
+ }
+ return m, nil
+}
+
+func (c *viewServiceClient) DelegationsByAddressIndex(ctx context.Context, in *DelegationsByAddressIndexRequest, opts ...grpc.CallOption) (ViewService_DelegationsByAddressIndexClient, error) {
+ stream, err := c.cc.NewStream(ctx, &_ViewService_serviceDesc.Streams[11], "/penumbra.view.v1.ViewService/DelegationsByAddressIndex", opts...)
+ if err != nil {
+ return nil, err
+ }
+ x := &viewServiceDelegationsByAddressIndexClient{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 ViewService_DelegationsByAddressIndexClient interface {
+ Recv() (*DelegationsByAddressIndexResponse, error)
+ grpc.ClientStream
+}
+
+type viewServiceDelegationsByAddressIndexClient struct {
+ grpc.ClientStream
+}
+
+func (x *viewServiceDelegationsByAddressIndexClient) Recv() (*DelegationsByAddressIndexResponse, error) {
+ m := new(DelegationsByAddressIndexResponse)
+ if err := x.ClientStream.RecvMsg(m); err != nil {
+ return nil, err
+ }
+ return m, nil
+}
+
+// ViewServiceServer is the server API for ViewService service.
+type ViewServiceServer 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.
+ StatusStream(*StatusStreamRequest, ViewService_StatusStreamServer) error
+ // Queries for notes that have been accepted by the chain.
// Returns a stream of `NotesResponse`s.
- Notes(*NotesRequest, ViewProtocolService_NotesServer) error
+ Notes(*NotesRequest, ViewService_NotesServer) error
// Returns a stream of `NotesForVotingResponse`s.
- NotesForVoting(*NotesForVotingRequest, ViewProtocolService_NotesForVotingServer) error
- // Returns authentication paths for the given note commitments.
- //
- // This method takes a batch of input commitments, rather than just one, so
- // that the client can get a consistent set of authentication paths to a
- // common root. (Otherwise, if a client made multiple requests, the wallet
- // service could have advanced the state commitment tree state between queries).
- Witness(context.Context, *WitnessRequest) (*WitnessResponse, error)
- WitnessAndBuild(context.Context, *WitnessAndBuildRequest) (*WitnessAndBuildResponse, error)
- // Queries for assets.
+ NotesForVoting(*NotesForVotingRequest, ViewService_NotesForVotingServer) error
+ // Queries for metadata about known assets.
// Returns a stream of `AssetsResponse`s.
- Assets(*AssetsRequest, ViewProtocolService_AssetsServer) error
- // Query for the current chain parameters.
- ChainParameters(context.Context, *ChainParametersRequest) (*ChainParametersResponse, error)
+ Assets(*AssetsRequest, ViewService_AssetsServer) error
+ // Query for metadata about a specific asset, by asset ID.
+ //
+ // This is the same as the method on the shielded pool's `QueryService`, but exposing it
+ // here allows a view server to provide more specific or opinionated asset metadata -- like
+ // using an asset registry to provide tickers, symbols, etc.
+ AssetMetadataById(context.Context, *AssetMetadataByIdRequest) (*AssetMetadataByIdResponse, 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
EphemeralAddress(context.Context, *EphemeralAddressRequest) (*EphemeralAddressResponse, error)
// Query for balance of a given address.
// Returns a stream of `BalancesResponses`.
- Balances(*BalancesRequest, ViewProtocolService_BalancesServer) error
+ Balances(*BalancesRequest, ViewService_BalancesServer) error
// Query for a note by its note commitment, optionally waiting until the note is detected.
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, ViewService_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.
TransactionInfoByHash(context.Context, *TransactionInfoByHashRequest) (*TransactionInfoByHashResponse, error)
// Query for the full transactions in the given range of blocks.
// Returns a stream of `TransactionInfoResponse`s.
- TransactionInfo(*TransactionInfoRequest, ViewProtocolService_TransactionInfoServer) error
- // Query for a transaction plan
- TransactionPlanner(context.Context, *TransactionPlannerRequest) (*TransactionPlannerResponse, error)
- // Broadcast a transaction to the network, optionally waiting for full confirmation.
- BroadcastTransaction(context.Context, *BroadcastTransactionRequest) (*BroadcastTransactionResponse, error)
+ TransactionInfo(*TransactionInfoRequest, ViewService_TransactionInfoServer) error
// Query for owned position IDs for the given trading pair and in the given position state.
- OwnedPositionIds(*OwnedPositionIdsRequest, ViewProtocolService_OwnedPositionIdsServer) error
+ OwnedPositionIds(*OwnedPositionIdsRequest, ViewService_OwnedPositionIdsServer) error
+ // Translates a high-level intent ("send X funds to Y address") into a complete transaction plan.
+ TransactionPlanner(context.Context, *TransactionPlannerRequest) (*TransactionPlannerResponse, error)
+ // Returns authentication data for the given transaction plan.
+ //
+ // This method takes a complete transaction plan, so that the client can get a
+ // consistent set of authentication paths to a common root for the entire
+ // transaction. (Otherwise, if a client made multiple requests, the wallet
+ // service could have advanced the state commitment tree between queries).
+ Witness(context.Context, *WitnessRequest) (*WitnessResponse, error)
+ // Like `Witness`, but immediately uses the witness data to build (prove) the transaction.
+ //
+ // This method is useful for clients that can't easily do proving themselves, either because
+ // they're not written in Rust and can't easily import the proving code, or because they don't
+ // have access to proving keys, or some other reason.
+ //
+ // This method streams status updates to the caller before finally returning the transaction.
+ WitnessAndBuild(*WitnessAndBuildRequest, ViewService_WitnessAndBuildServer) error
// Authorize a transaction plan and build the transaction.
- AuthorizeAndBuild(context.Context, *AuthorizeAndBuildRequest) (*AuthorizeAndBuildResponse, error)
+ //
+ // This method is only supported on view servers that have access to a custody
+ // service. Otherwise, it will fail.
+ //
+ // Penumbra's transaction authorization mechanism is designed so transactions
+ // can be signed and built (proved) concurrently. This allows implementations
+ // to, e.g., start proving optimistically while presenting the user with an
+ // approval dialog.
+ //
+ // This method streams status updates to the caller before finally returning the transaction.
+ AuthorizeAndBuild(*AuthorizeAndBuildRequest, ViewService_AuthorizeAndBuildServer) error
+ // Broadcast a transaction to the network, optionally waiting for full confirmation.
+ //
+ // This method streams status updates to the caller before finally returning confirmation.
+ BroadcastTransaction(*BroadcastTransactionRequest, ViewService_BroadcastTransactionServer) error
+ // Get delegation tokens for a given address index. Each delegation token will
+ // be represented by a `ValueView` with the given address index's balance of
+ // that token. Each `ValueView`'s `extended_metadata` field will contain the
+ // `ValidatorInfo` of the delegated validator.
+ DelegationsByAddressIndex(*DelegationsByAddressIndexRequest, ViewService_DelegationsByAddressIndexServer) error
}
-// UnimplementedViewProtocolServiceServer can be embedded to have forward compatible implementations.
-type UnimplementedViewProtocolServiceServer struct {
+// UnimplementedViewServiceServer can be embedded to have forward compatible implementations.
+type UnimplementedViewServiceServer struct {
}
-func (*UnimplementedViewProtocolServiceServer) Status(ctx context.Context, req *StatusRequest) (*StatusResponse, error) {
+func (*UnimplementedViewServiceServer) Status(ctx context.Context, req *StatusRequest) (*StatusResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Status not implemented")
}
-func (*UnimplementedViewProtocolServiceServer) StatusStream(req *StatusStreamRequest, srv ViewProtocolService_StatusStreamServer) error {
+func (*UnimplementedViewServiceServer) StatusStream(req *StatusStreamRequest, srv ViewService_StatusStreamServer) error {
return status.Errorf(codes.Unimplemented, "method StatusStream not implemented")
}
-func (*UnimplementedViewProtocolServiceServer) Notes(req *NotesRequest, srv ViewProtocolService_NotesServer) error {
+func (*UnimplementedViewServiceServer) Notes(req *NotesRequest, srv ViewService_NotesServer) error {
return status.Errorf(codes.Unimplemented, "method Notes not implemented")
}
-func (*UnimplementedViewProtocolServiceServer) NotesForVoting(req *NotesForVotingRequest, srv ViewProtocolService_NotesForVotingServer) error {
+func (*UnimplementedViewServiceServer) NotesForVoting(req *NotesForVotingRequest, srv ViewService_NotesForVotingServer) error {
return status.Errorf(codes.Unimplemented, "method NotesForVoting not implemented")
}
-func (*UnimplementedViewProtocolServiceServer) Witness(ctx context.Context, req *WitnessRequest) (*WitnessResponse, error) {
- return nil, status.Errorf(codes.Unimplemented, "method Witness not implemented")
+func (*UnimplementedViewServiceServer) Assets(req *AssetsRequest, srv ViewService_AssetsServer) error {
+ return status.Errorf(codes.Unimplemented, "method Assets not implemented")
}
-func (*UnimplementedViewProtocolServiceServer) WitnessAndBuild(ctx context.Context, req *WitnessAndBuildRequest) (*WitnessAndBuildResponse, error) {
- return nil, status.Errorf(codes.Unimplemented, "method WitnessAndBuild not implemented")
+func (*UnimplementedViewServiceServer) AssetMetadataById(ctx context.Context, req *AssetMetadataByIdRequest) (*AssetMetadataByIdResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method AssetMetadataById not implemented")
}
-func (*UnimplementedViewProtocolServiceServer) Assets(req *AssetsRequest, srv ViewProtocolService_AssetsServer) error {
- return status.Errorf(codes.Unimplemented, "method Assets not implemented")
+func (*UnimplementedViewServiceServer) AppParameters(ctx context.Context, req *AppParametersRequest) (*AppParametersResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method AppParameters not implemented")
}
-func (*UnimplementedViewProtocolServiceServer) ChainParameters(ctx context.Context, req *ChainParametersRequest) (*ChainParametersResponse, error) {
- return nil, status.Errorf(codes.Unimplemented, "method ChainParameters not implemented")
+func (*UnimplementedViewServiceServer) 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) {
+func (*UnimplementedViewServiceServer) FMDParameters(ctx context.Context, req *FMDParametersRequest) (*FMDParametersResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method FMDParameters not implemented")
}
-func (*UnimplementedViewProtocolServiceServer) AddressByIndex(ctx context.Context, req *AddressByIndexRequest) (*AddressByIndexResponse, error) {
+func (*UnimplementedViewServiceServer) AddressByIndex(ctx context.Context, req *AddressByIndexRequest) (*AddressByIndexResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method AddressByIndex not implemented")
}
-func (*UnimplementedViewProtocolServiceServer) IndexByAddress(ctx context.Context, req *IndexByAddressRequest) (*IndexByAddressResponse, error) {
+func (*UnimplementedViewServiceServer) WalletId(ctx context.Context, req *WalletIdRequest) (*WalletIdResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method WalletId not implemented")
+}
+func (*UnimplementedViewServiceServer) IndexByAddress(ctx context.Context, req *IndexByAddressRequest) (*IndexByAddressResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method IndexByAddress not implemented")
}
-func (*UnimplementedViewProtocolServiceServer) EphemeralAddress(ctx context.Context, req *EphemeralAddressRequest) (*EphemeralAddressResponse, error) {
+func (*UnimplementedViewServiceServer) EphemeralAddress(ctx context.Context, req *EphemeralAddressRequest) (*EphemeralAddressResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method EphemeralAddress not implemented")
}
-func (*UnimplementedViewProtocolServiceServer) Balances(req *BalancesRequest, srv ViewProtocolService_BalancesServer) error {
+func (*UnimplementedViewServiceServer) Balances(req *BalancesRequest, srv ViewService_BalancesServer) error {
return status.Errorf(codes.Unimplemented, "method Balances not implemented")
}
-func (*UnimplementedViewProtocolServiceServer) NoteByCommitment(ctx context.Context, req *NoteByCommitmentRequest) (*NoteByCommitmentResponse, error) {
+func (*UnimplementedViewServiceServer) NoteByCommitment(ctx context.Context, req *NoteByCommitmentRequest) (*NoteByCommitmentResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method NoteByCommitment not implemented")
}
-func (*UnimplementedViewProtocolServiceServer) SwapByCommitment(ctx context.Context, req *SwapByCommitmentRequest) (*SwapByCommitmentResponse, error) {
+func (*UnimplementedViewServiceServer) SwapByCommitment(ctx context.Context, req *SwapByCommitmentRequest) (*SwapByCommitmentResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method SwapByCommitment not implemented")
}
-func (*UnimplementedViewProtocolServiceServer) NullifierStatus(ctx context.Context, req *NullifierStatusRequest) (*NullifierStatusResponse, error) {
+func (*UnimplementedViewServiceServer) UnclaimedSwaps(req *UnclaimedSwapsRequest, srv ViewService_UnclaimedSwapsServer) error {
+ return status.Errorf(codes.Unimplemented, "method UnclaimedSwaps not implemented")
+}
+func (*UnimplementedViewServiceServer) NullifierStatus(ctx context.Context, req *NullifierStatusRequest) (*NullifierStatusResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method NullifierStatus not implemented")
}
-func (*UnimplementedViewProtocolServiceServer) TransactionInfoByHash(ctx context.Context, req *TransactionInfoByHashRequest) (*TransactionInfoByHashResponse, error) {
+func (*UnimplementedViewServiceServer) TransactionInfoByHash(ctx context.Context, req *TransactionInfoByHashRequest) (*TransactionInfoByHashResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method TransactionInfoByHash not implemented")
}
-func (*UnimplementedViewProtocolServiceServer) TransactionInfo(req *TransactionInfoRequest, srv ViewProtocolService_TransactionInfoServer) error {
+func (*UnimplementedViewServiceServer) TransactionInfo(req *TransactionInfoRequest, srv ViewService_TransactionInfoServer) error {
return status.Errorf(codes.Unimplemented, "method TransactionInfo not implemented")
}
-func (*UnimplementedViewProtocolServiceServer) TransactionPlanner(ctx context.Context, req *TransactionPlannerRequest) (*TransactionPlannerResponse, error) {
+func (*UnimplementedViewServiceServer) OwnedPositionIds(req *OwnedPositionIdsRequest, srv ViewService_OwnedPositionIdsServer) error {
+ return status.Errorf(codes.Unimplemented, "method OwnedPositionIds not implemented")
+}
+func (*UnimplementedViewServiceServer) TransactionPlanner(ctx context.Context, req *TransactionPlannerRequest) (*TransactionPlannerResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method TransactionPlanner not implemented")
}
-func (*UnimplementedViewProtocolServiceServer) BroadcastTransaction(ctx context.Context, req *BroadcastTransactionRequest) (*BroadcastTransactionResponse, error) {
- return nil, status.Errorf(codes.Unimplemented, "method BroadcastTransaction not implemented")
+func (*UnimplementedViewServiceServer) Witness(ctx context.Context, req *WitnessRequest) (*WitnessResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method Witness not implemented")
}
-func (*UnimplementedViewProtocolServiceServer) OwnedPositionIds(req *OwnedPositionIdsRequest, srv ViewProtocolService_OwnedPositionIdsServer) error {
- return status.Errorf(codes.Unimplemented, "method OwnedPositionIds not implemented")
+func (*UnimplementedViewServiceServer) WitnessAndBuild(req *WitnessAndBuildRequest, srv ViewService_WitnessAndBuildServer) error {
+ return status.Errorf(codes.Unimplemented, "method WitnessAndBuild not implemented")
+}
+func (*UnimplementedViewServiceServer) AuthorizeAndBuild(req *AuthorizeAndBuildRequest, srv ViewService_AuthorizeAndBuildServer) error {
+ return status.Errorf(codes.Unimplemented, "method AuthorizeAndBuild not implemented")
+}
+func (*UnimplementedViewServiceServer) BroadcastTransaction(req *BroadcastTransactionRequest, srv ViewService_BroadcastTransactionServer) error {
+ return status.Errorf(codes.Unimplemented, "method BroadcastTransaction not implemented")
}
-func (*UnimplementedViewProtocolServiceServer) AuthorizeAndBuild(ctx context.Context, req *AuthorizeAndBuildRequest) (*AuthorizeAndBuildResponse, error) {
- return nil, status.Errorf(codes.Unimplemented, "method AuthorizeAndBuild not implemented")
+func (*UnimplementedViewServiceServer) DelegationsByAddressIndex(req *DelegationsByAddressIndexRequest, srv ViewService_DelegationsByAddressIndexServer) error {
+ return status.Errorf(codes.Unimplemented, "method DelegationsByAddressIndex not implemented")
}
-func RegisterViewProtocolServiceServer(s grpc1.Server, srv ViewProtocolServiceServer) {
- s.RegisterService(&_ViewProtocolService_serviceDesc, srv)
+func RegisterViewServiceServer(s grpc1.Server, srv ViewServiceServer) {
+ s.RegisterService(&_ViewService_serviceDesc, srv)
}
-func _ViewProtocolService_Status_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _ViewService_Status_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(StatusRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
- return srv.(ViewProtocolServiceServer).Status(ctx, in)
+ return srv.(ViewServiceServer).Status(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
- FullMethod: "/penumbra.view.v1alpha1.ViewProtocolService/Status",
+ FullMethod: "/penumbra.view.v1.ViewService/Status",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(ViewProtocolServiceServer).Status(ctx, req.(*StatusRequest))
+ return srv.(ViewServiceServer).Status(ctx, req.(*StatusRequest))
}
return interceptor(ctx, in, info, handler)
}
-func _ViewProtocolService_StatusStream_Handler(srv interface{}, stream grpc.ServerStream) error {
+func _ViewService_StatusStream_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(StatusStreamRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
- return srv.(ViewProtocolServiceServer).StatusStream(m, &viewProtocolServiceStatusStreamServer{stream})
+ return srv.(ViewServiceServer).StatusStream(m, &viewServiceStatusStreamServer{stream})
}
-type ViewProtocolService_StatusStreamServer interface {
+type ViewService_StatusStreamServer interface {
Send(*StatusStreamResponse) error
grpc.ServerStream
}
-type viewProtocolServiceStatusStreamServer struct {
+type viewServiceStatusStreamServer struct {
grpc.ServerStream
}
-func (x *viewProtocolServiceStatusStreamServer) Send(m *StatusStreamResponse) error {
+func (x *viewServiceStatusStreamServer) Send(m *StatusStreamResponse) error {
return x.ServerStream.SendMsg(m)
}
-func _ViewProtocolService_Notes_Handler(srv interface{}, stream grpc.ServerStream) error {
+func _ViewService_Notes_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(NotesRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
- return srv.(ViewProtocolServiceServer).Notes(m, &viewProtocolServiceNotesServer{stream})
+ return srv.(ViewServiceServer).Notes(m, &viewServiceNotesServer{stream})
}
-type ViewProtocolService_NotesServer interface {
+type ViewService_NotesServer interface {
Send(*NotesResponse) error
grpc.ServerStream
}
-type viewProtocolServiceNotesServer struct {
+type viewServiceNotesServer struct {
grpc.ServerStream
}
-func (x *viewProtocolServiceNotesServer) Send(m *NotesResponse) error {
+func (x *viewServiceNotesServer) Send(m *NotesResponse) error {
return x.ServerStream.SendMsg(m)
}
-func _ViewProtocolService_NotesForVoting_Handler(srv interface{}, stream grpc.ServerStream) error {
+func _ViewService_NotesForVoting_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(NotesForVotingRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
- return srv.(ViewProtocolServiceServer).NotesForVoting(m, &viewProtocolServiceNotesForVotingServer{stream})
+ return srv.(ViewServiceServer).NotesForVoting(m, &viewServiceNotesForVotingServer{stream})
}
-type ViewProtocolService_NotesForVotingServer interface {
+type ViewService_NotesForVotingServer interface {
Send(*NotesForVotingResponse) error
grpc.ServerStream
}
-type viewProtocolServiceNotesForVotingServer struct {
+type viewServiceNotesForVotingServer struct {
grpc.ServerStream
}
-func (x *viewProtocolServiceNotesForVotingServer) Send(m *NotesForVotingResponse) error {
+func (x *viewServiceNotesForVotingServer) Send(m *NotesForVotingResponse) error {
return x.ServerStream.SendMsg(m)
}
-func _ViewProtocolService_Witness_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(WitnessRequest)
+func _ViewService_Assets_Handler(srv interface{}, stream grpc.ServerStream) error {
+ m := new(AssetsRequest)
+ if err := stream.RecvMsg(m); err != nil {
+ return err
+ }
+ return srv.(ViewServiceServer).Assets(m, &viewServiceAssetsServer{stream})
+}
+
+type ViewService_AssetsServer interface {
+ Send(*AssetsResponse) error
+ grpc.ServerStream
+}
+
+type viewServiceAssetsServer struct {
+ grpc.ServerStream
+}
+
+func (x *viewServiceAssetsServer) Send(m *AssetsResponse) error {
+ return x.ServerStream.SendMsg(m)
+}
+
+func _ViewService_AssetMetadataById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(AssetMetadataByIdRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
- return srv.(ViewProtocolServiceServer).Witness(ctx, in)
+ return srv.(ViewServiceServer).AssetMetadataById(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
- FullMethod: "/penumbra.view.v1alpha1.ViewProtocolService/Witness",
+ FullMethod: "/penumbra.view.v1.ViewService/AssetMetadataById",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(ViewProtocolServiceServer).Witness(ctx, req.(*WitnessRequest))
+ return srv.(ViewServiceServer).AssetMetadataById(ctx, req.(*AssetMetadataByIdRequest))
}
return interceptor(ctx, in, info, handler)
}
-func _ViewProtocolService_WitnessAndBuild_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(WitnessAndBuildRequest)
+func _ViewService_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).WitnessAndBuild(ctx, in)
+ return srv.(ViewServiceServer).AppParameters(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
- FullMethod: "/penumbra.view.v1alpha1.ViewProtocolService/WitnessAndBuild",
+ FullMethod: "/penumbra.view.v1.ViewService/AppParameters",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(ViewProtocolServiceServer).WitnessAndBuild(ctx, req.(*WitnessAndBuildRequest))
+ return srv.(ViewServiceServer).AppParameters(ctx, req.(*AppParametersRequest))
}
return interceptor(ctx, in, info, handler)
}
-func _ViewProtocolService_Assets_Handler(srv interface{}, stream grpc.ServerStream) error {
- m := new(AssetsRequest)
- if err := stream.RecvMsg(m); err != nil {
- return err
+func _ViewService_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
}
- return srv.(ViewProtocolServiceServer).Assets(m, &viewProtocolServiceAssetsServer{stream})
-}
-
-type ViewProtocolService_AssetsServer interface {
- Send(*AssetsResponse) error
- grpc.ServerStream
-}
-
-type viewProtocolServiceAssetsServer struct {
- grpc.ServerStream
-}
-
-func (x *viewProtocolServiceAssetsServer) Send(m *AssetsResponse) error {
- return x.ServerStream.SendMsg(m)
+ if interceptor == nil {
+ return srv.(ViewServiceServer).GasPrices(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/penumbra.view.v1.ViewService/GasPrices",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(ViewServiceServer).GasPrices(ctx, req.(*GasPricesRequest))
+ }
+ return interceptor(ctx, in, info, handler)
}
-func _ViewProtocolService_ChainParameters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(ChainParametersRequest)
+func _ViewService_FMDParameters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(FMDParametersRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
- return srv.(ViewProtocolServiceServer).ChainParameters(ctx, in)
+ return srv.(ViewServiceServer).FMDParameters(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
- FullMethod: "/penumbra.view.v1alpha1.ViewProtocolService/ChainParameters",
+ FullMethod: "/penumbra.view.v1.ViewService/FMDParameters",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(ViewProtocolServiceServer).ChainParameters(ctx, req.(*ChainParametersRequest))
+ return srv.(ViewServiceServer).FMDParameters(ctx, req.(*FMDParametersRequest))
}
return interceptor(ctx, in, info, handler)
}
-func _ViewProtocolService_FMDParameters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(FMDParametersRequest)
+func _ViewService_AddressByIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(AddressByIndexRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
- return srv.(ViewProtocolServiceServer).FMDParameters(ctx, in)
+ return srv.(ViewServiceServer).AddressByIndex(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
- FullMethod: "/penumbra.view.v1alpha1.ViewProtocolService/FMDParameters",
+ FullMethod: "/penumbra.view.v1.ViewService/AddressByIndex",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(ViewProtocolServiceServer).FMDParameters(ctx, req.(*FMDParametersRequest))
+ return srv.(ViewServiceServer).AddressByIndex(ctx, req.(*AddressByIndexRequest))
}
return interceptor(ctx, in, info, handler)
}
-func _ViewProtocolService_AddressByIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(AddressByIndexRequest)
+func _ViewService_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).AddressByIndex(ctx, in)
+ return srv.(ViewServiceServer).WalletId(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
- FullMethod: "/penumbra.view.v1alpha1.ViewProtocolService/AddressByIndex",
+ FullMethod: "/penumbra.view.v1.ViewService/WalletId",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(ViewProtocolServiceServer).AddressByIndex(ctx, req.(*AddressByIndexRequest))
+ return srv.(ViewServiceServer).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) {
+func _ViewService_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 {
return nil, err
}
if interceptor == nil {
- return srv.(ViewProtocolServiceServer).IndexByAddress(ctx, in)
+ return srv.(ViewServiceServer).IndexByAddress(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
- FullMethod: "/penumbra.view.v1alpha1.ViewProtocolService/IndexByAddress",
+ FullMethod: "/penumbra.view.v1.ViewService/IndexByAddress",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(ViewProtocolServiceServer).IndexByAddress(ctx, req.(*IndexByAddressRequest))
+ return srv.(ViewServiceServer).IndexByAddress(ctx, req.(*IndexByAddressRequest))
}
return interceptor(ctx, in, info, handler)
}
-func _ViewProtocolService_EphemeralAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _ViewService_EphemeralAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(EphemeralAddressRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
- return srv.(ViewProtocolServiceServer).EphemeralAddress(ctx, in)
+ return srv.(ViewServiceServer).EphemeralAddress(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
- FullMethod: "/penumbra.view.v1alpha1.ViewProtocolService/EphemeralAddress",
+ FullMethod: "/penumbra.view.v1.ViewService/EphemeralAddress",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(ViewProtocolServiceServer).EphemeralAddress(ctx, req.(*EphemeralAddressRequest))
+ return srv.(ViewServiceServer).EphemeralAddress(ctx, req.(*EphemeralAddressRequest))
}
return interceptor(ctx, in, info, handler)
}
-func _ViewProtocolService_Balances_Handler(srv interface{}, stream grpc.ServerStream) error {
+func _ViewService_Balances_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(BalancesRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
- return srv.(ViewProtocolServiceServer).Balances(m, &viewProtocolServiceBalancesServer{stream})
+ return srv.(ViewServiceServer).Balances(m, &viewServiceBalancesServer{stream})
}
-type ViewProtocolService_BalancesServer interface {
+type ViewService_BalancesServer interface {
Send(*BalancesResponse) error
grpc.ServerStream
}
-type viewProtocolServiceBalancesServer struct {
+type viewServiceBalancesServer struct {
grpc.ServerStream
}
-func (x *viewProtocolServiceBalancesServer) Send(m *BalancesResponse) error {
+func (x *viewServiceBalancesServer) Send(m *BalancesResponse) error {
return x.ServerStream.SendMsg(m)
}
-func _ViewProtocolService_NoteByCommitment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _ViewService_NoteByCommitment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(NoteByCommitmentRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
- return srv.(ViewProtocolServiceServer).NoteByCommitment(ctx, in)
+ return srv.(ViewServiceServer).NoteByCommitment(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
- FullMethod: "/penumbra.view.v1alpha1.ViewProtocolService/NoteByCommitment",
+ FullMethod: "/penumbra.view.v1.ViewService/NoteByCommitment",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(ViewProtocolServiceServer).NoteByCommitment(ctx, req.(*NoteByCommitmentRequest))
+ return srv.(ViewServiceServer).NoteByCommitment(ctx, req.(*NoteByCommitmentRequest))
}
return interceptor(ctx, in, info, handler)
}
-func _ViewProtocolService_SwapByCommitment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _ViewService_SwapByCommitment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SwapByCommitmentRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
- return srv.(ViewProtocolServiceServer).SwapByCommitment(ctx, in)
+ return srv.(ViewServiceServer).SwapByCommitment(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
- FullMethod: "/penumbra.view.v1alpha1.ViewProtocolService/SwapByCommitment",
+ FullMethod: "/penumbra.view.v1.ViewService/SwapByCommitment",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(ViewProtocolServiceServer).SwapByCommitment(ctx, req.(*SwapByCommitmentRequest))
+ return srv.(ViewServiceServer).SwapByCommitment(ctx, req.(*SwapByCommitmentRequest))
}
return interceptor(ctx, in, info, handler)
}
-func _ViewProtocolService_NullifierStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _ViewService_UnclaimedSwaps_Handler(srv interface{}, stream grpc.ServerStream) error {
+ m := new(UnclaimedSwapsRequest)
+ if err := stream.RecvMsg(m); err != nil {
+ return err
+ }
+ return srv.(ViewServiceServer).UnclaimedSwaps(m, &viewServiceUnclaimedSwapsServer{stream})
+}
+
+type ViewService_UnclaimedSwapsServer interface {
+ Send(*UnclaimedSwapsResponse) error
+ grpc.ServerStream
+}
+
+type viewServiceUnclaimedSwapsServer struct {
+ grpc.ServerStream
+}
+
+func (x *viewServiceUnclaimedSwapsServer) Send(m *UnclaimedSwapsResponse) error {
+ return x.ServerStream.SendMsg(m)
+}
+
+func _ViewService_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 {
return nil, err
}
if interceptor == nil {
- return srv.(ViewProtocolServiceServer).NullifierStatus(ctx, in)
+ return srv.(ViewServiceServer).NullifierStatus(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
- FullMethod: "/penumbra.view.v1alpha1.ViewProtocolService/NullifierStatus",
+ FullMethod: "/penumbra.view.v1.ViewService/NullifierStatus",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(ViewProtocolServiceServer).NullifierStatus(ctx, req.(*NullifierStatusRequest))
+ return srv.(ViewServiceServer).NullifierStatus(ctx, req.(*NullifierStatusRequest))
}
return interceptor(ctx, in, info, handler)
}
-func _ViewProtocolService_TransactionInfoByHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _ViewService_TransactionInfoByHash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(TransactionInfoByHashRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
- return srv.(ViewProtocolServiceServer).TransactionInfoByHash(ctx, in)
+ return srv.(ViewServiceServer).TransactionInfoByHash(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
- FullMethod: "/penumbra.view.v1alpha1.ViewProtocolService/TransactionInfoByHash",
+ FullMethod: "/penumbra.view.v1.ViewService/TransactionInfoByHash",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(ViewProtocolServiceServer).TransactionInfoByHash(ctx, req.(*TransactionInfoByHashRequest))
+ return srv.(ViewServiceServer).TransactionInfoByHash(ctx, req.(*TransactionInfoByHashRequest))
}
return interceptor(ctx, in, info, handler)
}
-func _ViewProtocolService_TransactionInfo_Handler(srv interface{}, stream grpc.ServerStream) error {
+func _ViewService_TransactionInfo_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(TransactionInfoRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
- return srv.(ViewProtocolServiceServer).TransactionInfo(m, &viewProtocolServiceTransactionInfoServer{stream})
+ return srv.(ViewServiceServer).TransactionInfo(m, &viewServiceTransactionInfoServer{stream})
}
-type ViewProtocolService_TransactionInfoServer interface {
+type ViewService_TransactionInfoServer interface {
Send(*TransactionInfoResponse) error
grpc.ServerStream
}
-type viewProtocolServiceTransactionInfoServer struct {
+type viewServiceTransactionInfoServer struct {
+ grpc.ServerStream
+}
+
+func (x *viewServiceTransactionInfoServer) Send(m *TransactionInfoResponse) error {
+ return x.ServerStream.SendMsg(m)
+}
+
+func _ViewService_OwnedPositionIds_Handler(srv interface{}, stream grpc.ServerStream) error {
+ m := new(OwnedPositionIdsRequest)
+ if err := stream.RecvMsg(m); err != nil {
+ return err
+ }
+ return srv.(ViewServiceServer).OwnedPositionIds(m, &viewServiceOwnedPositionIdsServer{stream})
+}
+
+type ViewService_OwnedPositionIdsServer interface {
+ Send(*OwnedPositionIdsResponse) error
+ grpc.ServerStream
+}
+
+type viewServiceOwnedPositionIdsServer struct {
grpc.ServerStream
}
-func (x *viewProtocolServiceTransactionInfoServer) Send(m *TransactionInfoResponse) error {
+func (x *viewServiceOwnedPositionIdsServer) Send(m *OwnedPositionIdsResponse) error {
return x.ServerStream.SendMsg(m)
}
-func _ViewProtocolService_TransactionPlanner_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _ViewService_TransactionPlanner_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(TransactionPlannerRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
- return srv.(ViewProtocolServiceServer).TransactionPlanner(ctx, in)
+ return srv.(ViewServiceServer).TransactionPlanner(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
- FullMethod: "/penumbra.view.v1alpha1.ViewProtocolService/TransactionPlanner",
+ FullMethod: "/penumbra.view.v1.ViewService/TransactionPlanner",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(ViewProtocolServiceServer).TransactionPlanner(ctx, req.(*TransactionPlannerRequest))
+ return srv.(ViewServiceServer).TransactionPlanner(ctx, req.(*TransactionPlannerRequest))
}
return interceptor(ctx, in, info, handler)
}
-func _ViewProtocolService_BroadcastTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(BroadcastTransactionRequest)
+func _ViewService_Witness_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(WitnessRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
- return srv.(ViewProtocolServiceServer).BroadcastTransaction(ctx, in)
+ return srv.(ViewServiceServer).Witness(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
- FullMethod: "/penumbra.view.v1alpha1.ViewProtocolService/BroadcastTransaction",
+ FullMethod: "/penumbra.view.v1.ViewService/Witness",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(ViewProtocolServiceServer).BroadcastTransaction(ctx, req.(*BroadcastTransactionRequest))
+ return srv.(ViewServiceServer).Witness(ctx, req.(*WitnessRequest))
}
return interceptor(ctx, in, info, handler)
}
-func _ViewProtocolService_OwnedPositionIds_Handler(srv interface{}, stream grpc.ServerStream) error {
- m := new(OwnedPositionIdsRequest)
+func _ViewService_WitnessAndBuild_Handler(srv interface{}, stream grpc.ServerStream) error {
+ m := new(WitnessAndBuildRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
- return srv.(ViewProtocolServiceServer).OwnedPositionIds(m, &viewProtocolServiceOwnedPositionIdsServer{stream})
+ return srv.(ViewServiceServer).WitnessAndBuild(m, &viewServiceWitnessAndBuildServer{stream})
}
-type ViewProtocolService_OwnedPositionIdsServer interface {
- Send(*OwnedPositionIdsResponse) error
+type ViewService_WitnessAndBuildServer interface {
+ Send(*WitnessAndBuildResponse) error
grpc.ServerStream
}
-type viewProtocolServiceOwnedPositionIdsServer struct {
+type viewServiceWitnessAndBuildServer struct {
grpc.ServerStream
}
-func (x *viewProtocolServiceOwnedPositionIdsServer) Send(m *OwnedPositionIdsResponse) error {
+func (x *viewServiceWitnessAndBuildServer) Send(m *WitnessAndBuildResponse) error {
return x.ServerStream.SendMsg(m)
}
-func _ViewProtocolService_AuthorizeAndBuild_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(AuthorizeAndBuildRequest)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(ViewProtocolServiceServer).AuthorizeAndBuild(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/penumbra.view.v1alpha1.ViewProtocolService/AuthorizeAndBuild",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(ViewProtocolServiceServer).AuthorizeAndBuild(ctx, req.(*AuthorizeAndBuildRequest))
+func _ViewService_AuthorizeAndBuild_Handler(srv interface{}, stream grpc.ServerStream) error {
+ m := new(AuthorizeAndBuildRequest)
+ if err := stream.RecvMsg(m); err != nil {
+ return err
}
- return interceptor(ctx, in, info, handler)
+ return srv.(ViewServiceServer).AuthorizeAndBuild(m, &viewServiceAuthorizeAndBuildServer{stream})
}
-var _ViewProtocolService_serviceDesc = grpc.ServiceDesc{
- ServiceName: "penumbra.view.v1alpha1.ViewProtocolService",
- HandlerType: (*ViewProtocolServiceServer)(nil),
- Methods: []grpc.MethodDesc{
- {
- MethodName: "Status",
- Handler: _ViewProtocolService_Status_Handler,
- },
- {
- MethodName: "Witness",
- Handler: _ViewProtocolService_Witness_Handler,
- },
- {
- MethodName: "WitnessAndBuild",
- Handler: _ViewProtocolService_WitnessAndBuild_Handler,
- },
- {
- MethodName: "ChainParameters",
- Handler: _ViewProtocolService_ChainParameters_Handler,
- },
+type ViewService_AuthorizeAndBuildServer interface {
+ Send(*AuthorizeAndBuildResponse) error
+ grpc.ServerStream
+}
+
+type viewServiceAuthorizeAndBuildServer struct {
+ grpc.ServerStream
+}
+
+func (x *viewServiceAuthorizeAndBuildServer) Send(m *AuthorizeAndBuildResponse) error {
+ return x.ServerStream.SendMsg(m)
+}
+
+func _ViewService_BroadcastTransaction_Handler(srv interface{}, stream grpc.ServerStream) error {
+ m := new(BroadcastTransactionRequest)
+ if err := stream.RecvMsg(m); err != nil {
+ return err
+ }
+ return srv.(ViewServiceServer).BroadcastTransaction(m, &viewServiceBroadcastTransactionServer{stream})
+}
+
+type ViewService_BroadcastTransactionServer interface {
+ Send(*BroadcastTransactionResponse) error
+ grpc.ServerStream
+}
+
+type viewServiceBroadcastTransactionServer struct {
+ grpc.ServerStream
+}
+
+func (x *viewServiceBroadcastTransactionServer) Send(m *BroadcastTransactionResponse) error {
+ return x.ServerStream.SendMsg(m)
+}
+
+func _ViewService_DelegationsByAddressIndex_Handler(srv interface{}, stream grpc.ServerStream) error {
+ m := new(DelegationsByAddressIndexRequest)
+ if err := stream.RecvMsg(m); err != nil {
+ return err
+ }
+ return srv.(ViewServiceServer).DelegationsByAddressIndex(m, &viewServiceDelegationsByAddressIndexServer{stream})
+}
+
+type ViewService_DelegationsByAddressIndexServer interface {
+ Send(*DelegationsByAddressIndexResponse) error
+ grpc.ServerStream
+}
+
+type viewServiceDelegationsByAddressIndexServer struct {
+ grpc.ServerStream
+}
+
+func (x *viewServiceDelegationsByAddressIndexServer) Send(m *DelegationsByAddressIndexResponse) error {
+ return x.ServerStream.SendMsg(m)
+}
+
+var _ViewService_serviceDesc = grpc.ServiceDesc{
+ ServiceName: "penumbra.view.v1.ViewService",
+ HandlerType: (*ViewServiceServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "Status",
+ Handler: _ViewService_Status_Handler,
+ },
+ {
+ MethodName: "AssetMetadataById",
+ Handler: _ViewService_AssetMetadataById_Handler,
+ },
+ {
+ MethodName: "AppParameters",
+ Handler: _ViewService_AppParameters_Handler,
+ },
+ {
+ MethodName: "GasPrices",
+ Handler: _ViewService_GasPrices_Handler,
+ },
{
MethodName: "FMDParameters",
- Handler: _ViewProtocolService_FMDParameters_Handler,
+ Handler: _ViewService_FMDParameters_Handler,
},
{
MethodName: "AddressByIndex",
- Handler: _ViewProtocolService_AddressByIndex_Handler,
+ Handler: _ViewService_AddressByIndex_Handler,
+ },
+ {
+ MethodName: "WalletId",
+ Handler: _ViewService_WalletId_Handler,
},
{
MethodName: "IndexByAddress",
- Handler: _ViewProtocolService_IndexByAddress_Handler,
+ Handler: _ViewService_IndexByAddress_Handler,
},
{
MethodName: "EphemeralAddress",
- Handler: _ViewProtocolService_EphemeralAddress_Handler,
+ Handler: _ViewService_EphemeralAddress_Handler,
},
{
MethodName: "NoteByCommitment",
- Handler: _ViewProtocolService_NoteByCommitment_Handler,
+ Handler: _ViewService_NoteByCommitment_Handler,
},
{
MethodName: "SwapByCommitment",
- Handler: _ViewProtocolService_SwapByCommitment_Handler,
+ Handler: _ViewService_SwapByCommitment_Handler,
},
{
MethodName: "NullifierStatus",
- Handler: _ViewProtocolService_NullifierStatus_Handler,
+ Handler: _ViewService_NullifierStatus_Handler,
},
{
MethodName: "TransactionInfoByHash",
- Handler: _ViewProtocolService_TransactionInfoByHash_Handler,
+ Handler: _ViewService_TransactionInfoByHash_Handler,
},
{
MethodName: "TransactionPlanner",
- Handler: _ViewProtocolService_TransactionPlanner_Handler,
- },
- {
- MethodName: "BroadcastTransaction",
- Handler: _ViewProtocolService_BroadcastTransaction_Handler,
+ Handler: _ViewService_TransactionPlanner_Handler,
},
{
- MethodName: "AuthorizeAndBuild",
- Handler: _ViewProtocolService_AuthorizeAndBuild_Handler,
+ MethodName: "Witness",
+ Handler: _ViewService_Witness_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "StatusStream",
- Handler: _ViewProtocolService_StatusStream_Handler,
+ Handler: _ViewService_StatusStream_Handler,
ServerStreams: true,
},
{
StreamName: "Notes",
- Handler: _ViewProtocolService_Notes_Handler,
+ Handler: _ViewService_Notes_Handler,
ServerStreams: true,
},
{
StreamName: "NotesForVoting",
- Handler: _ViewProtocolService_NotesForVoting_Handler,
+ Handler: _ViewService_NotesForVoting_Handler,
ServerStreams: true,
},
{
StreamName: "Assets",
- Handler: _ViewProtocolService_Assets_Handler,
+ Handler: _ViewService_Assets_Handler,
ServerStreams: true,
},
{
StreamName: "Balances",
- Handler: _ViewProtocolService_Balances_Handler,
+ Handler: _ViewService_Balances_Handler,
+ ServerStreams: true,
+ },
+ {
+ StreamName: "UnclaimedSwaps",
+ Handler: _ViewService_UnclaimedSwaps_Handler,
ServerStreams: true,
},
{
StreamName: "TransactionInfo",
- Handler: _ViewProtocolService_TransactionInfo_Handler,
+ Handler: _ViewService_TransactionInfo_Handler,
ServerStreams: true,
},
{
StreamName: "OwnedPositionIds",
- Handler: _ViewProtocolService_OwnedPositionIds_Handler,
+ Handler: _ViewService_OwnedPositionIds_Handler,
+ ServerStreams: true,
+ },
+ {
+ StreamName: "WitnessAndBuild",
+ Handler: _ViewService_WitnessAndBuild_Handler,
+ ServerStreams: true,
+ },
+ {
+ StreamName: "AuthorizeAndBuild",
+ Handler: _ViewService_AuthorizeAndBuild_Handler,
+ ServerStreams: true,
+ },
+ {
+ StreamName: "BroadcastTransaction",
+ Handler: _ViewService_BroadcastTransaction_Handler,
+ ServerStreams: true,
+ },
+ {
+ StreamName: "DelegationsByAddressIndex",
+ Handler: _ViewService_DelegationsByAddressIndex_Handler,
ServerStreams: true,
},
},
- 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}
+ Metadata: "penumbra/view/v1/view.proto",
}
-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...)
+func (m *AuthorizeAndBuildRequest) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
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)
+ return dAtA[:n], nil
}
-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)
+func (m *AuthorizeAndBuildRequest) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
}
-var _ViewAuthService_serviceDesc = grpc.ServiceDesc{
- ServiceName: "penumbra.view.v1alpha1.ViewAuthService",
- HandlerType: (*ViewAuthServiceServer)(nil),
- Methods: []grpc.MethodDesc{
+func (m *AuthorizeAndBuildRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.TransactionPlan != nil {
{
- MethodName: "ViewAuth",
- Handler: _ViewAuthService_ViewAuth_Handler,
- },
- },
- Streams: []grpc.StreamDesc{},
- Metadata: "penumbra/view/v1alpha1/view.proto",
+ size, err := m.TransactionPlan.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 *AuthorizeAndBuildRequest) Marshal() (dAtA []byte, err error) {
+func (m *AuthorizeAndBuildResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -4899,19 +5935,38 @@ func (m *AuthorizeAndBuildRequest) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *AuthorizeAndBuildRequest) MarshalTo(dAtA []byte) (int, error) {
+func (m *AuthorizeAndBuildResponse) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *AuthorizeAndBuildRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *AuthorizeAndBuildResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
- if m.AuthorizationData != nil {
+ if m.Status != nil {
{
- size, err := m.AuthorizationData.MarshalToSizedBuffer(dAtA[:i])
+ size := m.Status.Size()
+ i -= size
+ if _, err := m.Status.MarshalTo(dAtA[i:]); err != nil {
+ return 0, err
+ }
+ }
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *AuthorizeAndBuildResponse_BuildProgress_) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AuthorizeAndBuildResponse_BuildProgress_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ if m.BuildProgress != nil {
+ {
+ size, err := m.BuildProgress.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -4919,11 +5974,20 @@ func (m *AuthorizeAndBuildRequest) MarshalToSizedBuffer(dAtA []byte) (int, error
i = encodeVarintView(dAtA, i, uint64(size))
}
i--
- dAtA[i] = 0x12
+ dAtA[i] = 0xa
}
- if m.TransactionPlan != nil {
+ return len(dAtA) - i, nil
+}
+func (m *AuthorizeAndBuildResponse_Complete_) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AuthorizeAndBuildResponse_Complete_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ if m.Complete != nil {
{
- size, err := m.TransactionPlan.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.Complete.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -4931,12 +5995,40 @@ func (m *AuthorizeAndBuildRequest) MarshalToSizedBuffer(dAtA []byte) (int, error
i = encodeVarintView(dAtA, i, uint64(size))
}
i--
- dAtA[i] = 0xa
+ dAtA[i] = 0x12
+ }
+ return len(dAtA) - i, nil
+}
+func (m *AuthorizeAndBuildResponse_BuildProgress) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *AuthorizeAndBuildResponse_BuildProgress) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AuthorizeAndBuildResponse_BuildProgress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.Progress != 0 {
+ i -= 4
+ encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Progress))))
+ i--
+ dAtA[i] = 0xd
}
return len(dAtA) - i, nil
}
-func (m *AuthorizeAndBuildResponse) Marshal() (dAtA []byte, err error) {
+func (m *AuthorizeAndBuildResponse_Complete) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -4946,12 +6038,12 @@ func (m *AuthorizeAndBuildResponse) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *AuthorizeAndBuildResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *AuthorizeAndBuildResponse_Complete) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *AuthorizeAndBuildResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *AuthorizeAndBuildResponse_Complete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
@@ -5036,14 +6128,28 @@ func (m *BroadcastTransactionResponse) MarshalToSizedBuffer(dAtA []byte) (int, e
_ = i
var l int
_ = l
- if m.DetectionHeight != 0 {
- i = encodeVarintView(dAtA, i, uint64(m.DetectionHeight))
- i--
- dAtA[i] = 0x10
+ if m.Status != nil {
+ {
+ size := m.Status.Size()
+ i -= size
+ if _, err := m.Status.MarshalTo(dAtA[i:]); err != nil {
+ return 0, err
+ }
+ }
}
- if m.Id != nil {
+ return len(dAtA) - i, nil
+}
+
+func (m *BroadcastTransactionResponse_BroadcastSuccess_) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *BroadcastTransactionResponse_BroadcastSuccess_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ if m.BroadcastSuccess != nil {
{
- size, err := m.Id.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.BroadcastSuccess.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -5055,8 +6161,28 @@ func (m *BroadcastTransactionResponse) MarshalToSizedBuffer(dAtA []byte) (int, e
}
return len(dAtA) - i, nil
}
+func (m *BroadcastTransactionResponse_Confirmed_) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
-func (m *TransactionPlannerRequest) Marshal() (dAtA []byte, err error) {
+func (m *BroadcastTransactionResponse_Confirmed_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ if m.Confirmed != nil {
+ {
+ size, err := m.Confirmed.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 *BroadcastTransactionResponse_BroadcastSuccess) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -5066,46 +6192,231 @@ func (m *TransactionPlannerRequest) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *TransactionPlannerRequest) MarshalTo(dAtA []byte) (int, error) {
+func (m *BroadcastTransactionResponse_BroadcastSuccess) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *TransactionPlannerRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *BroadcastTransactionResponse_BroadcastSuccess) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
- if len(m.IbcActions) > 0 {
- for iNdEx := len(m.IbcActions) - 1; iNdEx >= 0; iNdEx-- {
- {
- size, err := m.IbcActions[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] = 0xe2
- }
- }
- 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 = encodeVarintView(dAtA, i, uint64(size))
+ if m.Id != nil {
+ {
+ size, err := m.Id.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
}
- i--
- dAtA[i] = 0x3
- i--
- dAtA[i] = 0x92
+ i -= size
+ i = encodeVarintView(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *BroadcastTransactionResponse_Confirmed) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *BroadcastTransactionResponse_Confirmed) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *BroadcastTransactionResponse_Confirmed) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.DetectionHeight != 0 {
+ i = encodeVarintView(dAtA, i, uint64(m.DetectionHeight))
+ i--
+ dAtA[i] = 0x10
+ }
+ if m.Id != nil {
+ {
+ size, err := m.Id.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 *TransactionPlannerRequest) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *TransactionPlannerRequest) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TransactionPlannerRequest) 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 = encodeVarintView(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0xc
+ i--
+ dAtA[i] = 0xca
+ }
+ if m.EpochIndex != 0 {
+ i = encodeVarintView(dAtA, i, uint64(m.EpochIndex))
+ i--
+ dAtA[i] = 0xc
+ i--
+ dAtA[i] = 0xc0
+ }
+ if m.FeeMode != nil {
+ {
+ size := m.FeeMode.Size()
+ i -= size
+ if _, err := m.FeeMode.MarshalTo(dAtA[i:]); err != nil {
+ return 0, err
+ }
+ }
+ }
+ 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.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
+ }
+ i -= size
+ i = encodeVarintView(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x3
+ i--
+ dAtA[i] = 0xe2
+ }
+ }
+ if len(m.UndelegationClaims) > 0 {
+ for iNdEx := len(m.UndelegationClaims) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.UndelegationClaims[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] = 0x9a
+ }
+ }
+ 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 = encodeVarintView(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x3
+ i--
+ dAtA[i] = 0x92
}
}
if len(m.Delegations) > 0 {
@@ -5172,14 +6483,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 {
{
@@ -5193,9 +6507,24 @@ func (m *TransactionPlannerRequest) MarshalToSizedBuffer(dAtA []byte) (int, erro
i--
dAtA[i] = 0x1a
}
- if m.Fee != nil {
+ if m.ExpiryHeight != 0 {
+ i = encodeVarintView(dAtA, i, uint64(m.ExpiryHeight))
+ i--
+ dAtA[i] = 0x8
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *TransactionPlannerRequest_AutoFee) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TransactionPlannerRequest_AutoFee) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ if m.AutoFee != nil {
{
- size, err := m.Fee.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.AutoFee.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -5203,26 +6532,22 @@ func (m *TransactionPlannerRequest) MarshalToSizedBuffer(dAtA []byte) (int, erro
i = encodeVarintView(dAtA, i, uint64(size))
}
i--
- dAtA[i] = 0x12
- }
- if m.ExpiryHeight != 0 {
- i = encodeVarintView(dAtA, i, uint64(m.ExpiryHeight))
+ dAtA[i] = 0x6
i--
- dAtA[i] = 0x8
+ dAtA[i] = 0xa2
}
return len(dAtA) - i, nil
}
-
-func (m *TransactionPlannerRequest_AccountGroupId) MarshalTo(dAtA []byte) (int, error) {
+func (m *TransactionPlannerRequest_ManualFee) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *TransactionPlannerRequest_AccountGroupId) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *TransactionPlannerRequest_ManualFee) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
- if m.AccountGroupId != nil {
+ if m.ManualFee != nil {
{
- size, err := m.AccountGroupId.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.ManualFee.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -5230,7 +6555,9 @@ func (m *TransactionPlannerRequest_AccountGroupId) MarshalToSizedBuffer(dAtA []b
i = encodeVarintView(dAtA, i, uint64(size))
}
i--
- dAtA[i] = 0x72
+ dAtA[i] = 0x6
+ i--
+ dAtA[i] = 0xaa
}
return len(dAtA) - i, nil
}
@@ -5301,6 +6628,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 +6808,7 @@ func (m *TransactionPlannerRequest_Undelegate) MarshalToSizedBuffer(dAtA []byte)
return len(dAtA) - i, nil
}
-func (m *TransactionPlannerResponse) Marshal() (dAtA []byte, err error) {
+func (m *TransactionPlannerRequest_UndelegateClaim) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -5479,19 +6818,53 @@ func (m *TransactionPlannerResponse) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *TransactionPlannerResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *TransactionPlannerRequest_UndelegateClaim) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *TransactionPlannerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *TransactionPlannerRequest_UndelegateClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
- if m.Plan != nil {
+ if m.UnbondingStartHeight != 0 {
+ i = encodeVarintView(dAtA, i, uint64(m.UnbondingStartHeight))
+ i--
+ dAtA[i] = 0x28
+ }
+ if m.UnbondingAmount != nil {
{
- size, err := m.Plan.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.UnbondingAmount.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintView(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x22
+ }
+ if m.Penalty != nil {
+ {
+ size, err := m.Penalty.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintView(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x1a
+ }
+ if m.StartEpochIndex != 0 {
+ i = encodeVarintView(dAtA, i, uint64(m.StartEpochIndex))
+ i--
+ dAtA[i] = 0x10
+ }
+ if m.ValidatorIdentity != nil {
+ {
+ size, err := m.ValidatorIdentity.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -5504,7 +6877,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_PositionOpen) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -5514,29 +6887,19 @@ func (m *AddressByIndexRequest) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *AddressByIndexRequest) MarshalTo(dAtA []byte) (int, error) {
+func (m *TransactionPlannerRequest_PositionOpen) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *AddressByIndexRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *TransactionPlannerRequest_PositionOpen) 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.Position != nil {
{
- size, err := m.AddressIndex.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.Position.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -5549,7 +6912,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_PositionClose) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -5559,19 +6922,19 @@ func (m *AddressByIndexResponse) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *AddressByIndexResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *TransactionPlannerRequest_PositionClose) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *AddressByIndexResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *TransactionPlannerRequest_PositionClose) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
- if m.Address != nil {
+ if m.PositionId != nil {
{
- size, err := m.Address.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.PositionId.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -5584,7 +6947,7 @@ func (m *AddressByIndexResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)
return len(dAtA) - i, nil
}
-func (m *IndexByAddressRequest) 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])
@@ -5594,19 +6957,43 @@ func (m *IndexByAddressRequest) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *IndexByAddressRequest) MarshalTo(dAtA []byte) (int, error) {
+func (m *TransactionPlannerRequest_PositionWithdraw) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *IndexByAddressRequest) 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
}
@@ -5619,7 +7006,7 @@ func (m *IndexByAddressRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
-func (m *IndexByAddressResponse) 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])
@@ -5629,35 +7016,51 @@ func (m *IndexByAddressResponse) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *IndexByAddressResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *TransactionPlannerResponse) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *IndexByAddressResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *TransactionPlannerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
- if m.XAddressIndex != nil {
+ if m.Plan != nil {
{
- size := m.XAddressIndex.Size()
- i -= size
- if _, err := m.XAddressIndex.MarshalTo(dAtA[i:]); err != nil {
+ size, err := m.Plan.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 *AddressByIndexRequest) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *AddressByIndexRequest) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *IndexByAddressResponse_AddressIndex) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *AddressByIndexRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
if m.AddressIndex != nil {
{
size, err := m.AddressIndex.MarshalToSizedBuffer(dAtA[:i])
@@ -5672,7 +7075,8 @@ func (m *IndexByAddressResponse_AddressIndex) MarshalToSizedBuffer(dAtA []byte)
}
return len(dAtA) - i, nil
}
-func (m *EphemeralAddressRequest) Marshal() (dAtA []byte, err error) {
+
+func (m *AddressByIndexResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -5682,29 +7086,19 @@ func (m *EphemeralAddressRequest) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *EphemeralAddressRequest) MarshalTo(dAtA []byte) (int, error) {
+func (m *AddressByIndexResponse) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *EphemeralAddressRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *AddressByIndexResponse) 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.Address != nil {
{
- size, err := m.AddressIndex.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.Address.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -5717,7 +7111,7 @@ func (m *EphemeralAddressRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)
return len(dAtA) - i, nil
}
-func (m *EphemeralAddressResponse) 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])
@@ -5727,19 +7121,42 @@ func (m *EphemeralAddressResponse) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *EphemeralAddressResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *WalletIdRequest) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *EphemeralAddressResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *WalletIdRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
- if m.Address != nil {
+ 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
+ }
+ 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.Address.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.WalletId.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -5752,7 +7169,7 @@ func (m *EphemeralAddressResponse) MarshalToSizedBuffer(dAtA []byte) (int, error
return len(dAtA) - i, nil
}
-func (m *BalancesRequest) 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])
@@ -5762,31 +7179,19 @@ func (m *BalancesRequest) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *BalancesRequest) MarshalTo(dAtA []byte) (int, error) {
+func (m *IndexByAddressRequest) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *BalancesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *IndexByAddressRequest) 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.Address != nil {
{
- size, err := m.AccountFilter.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.Address.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -5799,7 +7204,7 @@ func (m *BalancesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
-func (m *BalancesResponse) 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])
@@ -5809,31 +7214,19 @@ func (m *BalancesResponse) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *BalancesResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *IndexByAddressResponse) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *BalancesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *IndexByAddressResponse) 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))
- }
- i--
- dAtA[i] = 0x12
- }
- 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 +7239,7 @@ func (m *BalancesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
-func (m *ViewAuthToken) 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])
@@ -5856,27 +7249,32 @@ func (m *ViewAuthToken) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *ViewAuthToken) MarshalTo(dAtA []byte) (int, error) {
+func (m *EphemeralAddressRequest) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *ViewAuthToken) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *EphemeralAddressRequest) 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.AddressIndex != 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 *ViewAuthRequest) 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])
@@ -5886,19 +7284,19 @@ func (m *ViewAuthRequest) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *ViewAuthRequest) MarshalTo(dAtA []byte) (int, error) {
+func (m *EphemeralAddressResponse) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *ViewAuthRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *EphemeralAddressResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
- if m.Fvk != nil {
+ if m.Address != nil {
{
- size, err := m.Fvk.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.Address.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -5911,7 +7309,7 @@ func (m *ViewAuthRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
-func (m *ViewAuthResponse) 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])
@@ -5921,19 +7319,31 @@ func (m *ViewAuthResponse) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *ViewAuthResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *BalancesRequest) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *ViewAuthResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *BalancesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
- if m.Token != 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.Token.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.AccountFilter.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -5946,7 +7356,7 @@ func (m *ViewAuthResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
-func (m *StatusRequest) 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])
@@ -5956,38 +7366,55 @@ func (m *StatusRequest) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *StatusRequest) MarshalTo(dAtA []byte) (int, error) {
+func (m *BalancesResponse) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *StatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *BalancesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
- if m.XAccountGroupId != nil {
+ if m.BalanceView != nil {
+ {
+ size, err := m.BalanceView.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintView(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x22
+ }
+ if m.AccountAddress != nil {
{
- size := m.XAccountGroupId.Size()
+ size, err := m.AccountAddress.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
i -= size
- if _, err := m.XAccountGroupId.MarshalTo(dAtA[i:]); err != nil {
+ i = encodeVarintView(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x1a
+ }
+ 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
}
- 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 {
+ if m.Account != nil {
{
- size, err := m.AccountGroupId.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.Account.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -5995,10 +7422,34 @@ func (m *StatusRequest_AccountGroupId) MarshalToSizedBuffer(dAtA []byte) (int, e
i = encodeVarintView(dAtA, i, uint64(size))
}
i--
- dAtA[i] = 0x72
+ dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
+
+func (m *StatusRequest) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *StatusRequest) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *StatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ return len(dAtA) - i, nil
+}
+
func (m *StatusResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@@ -6027,10 +7478,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 +7513,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 +7536,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 +7574,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 +7623,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 +7643,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 +7663,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 +7683,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])
@@ -6333,44 +7695,9 @@ func (m *WitnessRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x1a
}
- if len(m.NoteCommitments) > 0 {
- for iNdEx := len(m.NoteCommitments) - 1; iNdEx >= 0; iNdEx-- {
- {
- size, err := m.NoteCommitments[iNdEx].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 *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)
@@ -6469,6 +7796,109 @@ func (m *WitnessAndBuildResponse) MarshalTo(dAtA []byte) (int, error) {
}
func (m *WitnessAndBuildResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.Status != nil {
+ {
+ size := m.Status.Size()
+ i -= size
+ if _, err := m.Status.MarshalTo(dAtA[i:]); err != nil {
+ return 0, err
+ }
+ }
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *WitnessAndBuildResponse_BuildProgress_) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *WitnessAndBuildResponse_BuildProgress_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ if m.BuildProgress != nil {
+ {
+ size, err := m.BuildProgress.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 *WitnessAndBuildResponse_Complete_) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *WitnessAndBuildResponse_Complete_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ if m.Complete != nil {
+ {
+ size, err := m.Complete.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 *WitnessAndBuildResponse_BuildProgress) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *WitnessAndBuildResponse_BuildProgress) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *WitnessAndBuildResponse_BuildProgress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.Progress != 0 {
+ i -= 4
+ encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Progress))))
+ i--
+ dAtA[i] = 0xd
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *WitnessAndBuildResponse_Complete) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *WitnessAndBuildResponse_Complete) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *WitnessAndBuildResponse_Complete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
@@ -6620,7 +8050,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 +8060,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 +8073,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 +8083,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 +8108,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 +8244,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 +8269,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 +8324,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 +8349,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 +8379,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 +8394,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 +8462,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 +8487,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 +8575,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 +8656,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)
@@ -7428,6 +8836,18 @@ func (m *SpendableNoteRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
+ if m.ReturnAddress != nil {
+ {
+ size, err := m.ReturnAddress.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintView(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x4a
+ }
if m.Source != nil {
{
size, err := m.Source.MarshalToSizedBuffer(dAtA[:i])
@@ -7445,14 +8865,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 +8926,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 +8958,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 +9019,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,37 +9039,56 @@ 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
}
+ i -= size
+ i = encodeVarintView(dAtA, i, uint64(size))
}
+ i--
+ dAtA[i] = 0x12
}
- if m.XPositionState != nil {
+ if m.PositionState != nil {
{
- size := m.XPositionState.Size()
- i -= size
- if _, err := m.XPositionState.MarshalTo(dAtA[i:]); err != nil {
+ size, err := m.PositionState.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 *OwnedPositionIdsRequest_PositionState) MarshalTo(dAtA []byte) (int, error) {
+func (m *OwnedPositionIdsResponse) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *OwnedPositionIdsResponse) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *OwnedPositionIdsRequest_PositionState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *OwnedPositionIdsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
- if m.PositionState != nil {
+ _ = i
+ var l int
+ _ = l
+ if m.PositionId != nil {
{
- size, err := m.PositionState.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.PositionId.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -7693,16 +9100,30 @@ func (m *OwnedPositionIdsRequest_PositionState) MarshalToSizedBuffer(dAtA []byte
}
return len(dAtA) - i, nil
}
-func (m *OwnedPositionIdsRequest_TradingPair) MarshalTo(dAtA []byte) (int, error) {
+
+func (m *AssetMetadataByIdRequest) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *AssetMetadataByIdRequest) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *OwnedPositionIdsRequest_TradingPair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *AssetMetadataByIdRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
- if m.TradingPair != nil {
+ _ = i
+ var l int
+ _ = l
+ if m.AssetId != nil {
{
- size, err := m.TradingPair.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.AssetId.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -7714,7 +9135,8 @@ func (m *OwnedPositionIdsRequest_TradingPair) MarshalToSizedBuffer(dAtA []byte)
}
return len(dAtA) - i, nil
}
-func (m *OwnedPositionIdsResponse) Marshal() (dAtA []byte, err error) {
+
+func (m *AssetMetadataByIdResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -7724,19 +9146,19 @@ func (m *OwnedPositionIdsResponse) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
-func (m *OwnedPositionIdsResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *AssetMetadataByIdResponse) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
-func (m *OwnedPositionIdsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *AssetMetadataByIdResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
- if m.PositionId != nil {
+ if m.DenomMetadata != nil {
{
- size, err := m.PositionId.MarshalToSizedBuffer(dAtA[:i])
+ size, err := m.DenomMetadata.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@@ -7749,39 +9171,158 @@ func (m *OwnedPositionIdsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error
return len(dAtA) - i, nil
}
-func encodeVarintView(dAtA []byte, offset int, v uint64) int {
- offset -= sovView(v)
- base := offset
- for v >= 1<<7 {
- dAtA[offset] = uint8(v&0x7f | 0x80)
- v >>= 7
- offset++
+func (m *DelegationsByAddressIndexRequest) 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 *AuthorizeAndBuildRequest) Size() (n int) {
- if m == nil {
- return 0
- }
+
+func (m *DelegationsByAddressIndexRequest) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DelegationsByAddressIndexRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
var l int
_ = l
- if m.TransactionPlan != nil {
- l = m.TransactionPlan.Size()
- n += 1 + l + sovView(uint64(l))
+ if m.Filter != 0 {
+ i = encodeVarintView(dAtA, i, uint64(m.Filter))
+ i--
+ dAtA[i] = 0x10
}
- if m.AuthorizationData != nil {
- l = m.AuthorizationData.Size()
- n += 1 + l + sovView(uint64(l))
+ if m.AddressIndex != 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 n
+ return len(dAtA) - i, nil
}
-func (m *AuthorizeAndBuildResponse) Size() (n int) {
- if m == nil {
- return 0
- }
- var l int
+func (m *DelegationsByAddressIndexResponse) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *DelegationsByAddressIndexResponse) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DelegationsByAddressIndexResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.ValueView != nil {
+ {
+ size, err := m.ValueView.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 encodeVarintView(dAtA []byte, offset int, v uint64) int {
+ offset -= sovView(v)
+ base := offset
+ for v >= 1<<7 {
+ dAtA[offset] = uint8(v&0x7f | 0x80)
+ v >>= 7
+ offset++
+ }
+ dAtA[offset] = uint8(v)
+ return base
+}
+func (m *AuthorizeAndBuildRequest) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.TransactionPlan != nil {
+ l = m.TransactionPlan.Size()
+ n += 1 + l + sovView(uint64(l))
+ }
+ return n
+}
+
+func (m *AuthorizeAndBuildResponse) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.Status != nil {
+ n += m.Status.Size()
+ }
+ return n
+}
+
+func (m *AuthorizeAndBuildResponse_BuildProgress_) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.BuildProgress != nil {
+ l = m.BuildProgress.Size()
+ n += 1 + l + sovView(uint64(l))
+ }
+ return n
+}
+func (m *AuthorizeAndBuildResponse_Complete_) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.Complete != nil {
+ l = m.Complete.Size()
+ n += 1 + l + sovView(uint64(l))
+ }
+ return n
+}
+func (m *AuthorizeAndBuildResponse_BuildProgress) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.Progress != 0 {
+ n += 5
+ }
+ return n
+}
+
+func (m *AuthorizeAndBuildResponse_Complete) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
_ = l
if m.Transaction != nil {
l = m.Transaction.Size()
@@ -7807,6 +9348,55 @@ func (m *BroadcastTransactionRequest) Size() (n int) {
}
func (m *BroadcastTransactionResponse) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.Status != nil {
+ n += m.Status.Size()
+ }
+ return n
+}
+
+func (m *BroadcastTransactionResponse_BroadcastSuccess_) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.BroadcastSuccess != nil {
+ l = m.BroadcastSuccess.Size()
+ n += 1 + l + sovView(uint64(l))
+ }
+ return n
+}
+func (m *BroadcastTransactionResponse_Confirmed_) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.Confirmed != nil {
+ l = m.Confirmed.Size()
+ n += 1 + l + sovView(uint64(l))
+ }
+ return n
+}
+func (m *BroadcastTransactionResponse_BroadcastSuccess) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.Id != nil {
+ l = m.Id.Size()
+ n += 1 + l + sovView(uint64(l))
+ }
+ return n
+}
+
+func (m *BroadcastTransactionResponse_Confirmed) Size() (n int) {
if m == nil {
return 0
}
@@ -7831,16 +9421,13 @@ func (m *TransactionPlannerRequest) Size() (n int) {
if m.ExpiryHeight != 0 {
n += 1 + sovView(uint64(m.ExpiryHeight))
}
- if m.Fee != nil {
- l = m.Fee.Size()
- n += 1 + l + sovView(uint64(l))
- }
if m.Memo != nil {
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,24 +9459,76 @@ 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.UndelegationClaims) > 0 {
+ for _, e := range m.UndelegationClaims {
+ l = e.Size()
+ n += 2 + l + sovView(uint64(l))
+ }
+ }
+ if len(m.IbcRelayActions) > 0 {
+ for _, e := range m.IbcRelayActions {
+ l = e.Size()
+ n += 2 + l + sovView(uint64(l))
+ }
+ }
+ if len(m.Ics20Withdrawals) > 0 {
+ for _, e := range m.Ics20Withdrawals {
+ l = e.Size()
+ n += 2 + 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))
}
}
+ if m.FeeMode != nil {
+ n += m.FeeMode.Size()
+ }
+ if m.EpochIndex != 0 {
+ n += 2 + sovView(uint64(m.EpochIndex))
+ }
+ if m.Epoch != nil {
+ l = m.Epoch.Size()
+ n += 2 + l + sovView(uint64(l))
+ }
return n
}
-func (m *TransactionPlannerRequest_AccountGroupId) Size() (n int) {
+func (m *TransactionPlannerRequest_AutoFee) 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))
+ if m.AutoFee != nil {
+ l = m.AutoFee.Size()
+ n += 2 + l + sovView(uint64(l))
+ }
+ return n
+}
+func (m *TransactionPlannerRequest_ManualFee) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.ManualFee != nil {
+ l = m.ManualFee.Size()
+ n += 2 + l + sovView(uint64(l))
}
return n
}
@@ -7928,6 +9567,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,86 +9621,94 @@ func (m *TransactionPlannerRequest_Undelegate) Size() (n int) {
return n
}
-func (m *TransactionPlannerResponse) Size() (n int) {
+func (m *TransactionPlannerRequest_UndelegateClaim) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.Plan != nil {
- l = m.Plan.Size()
+ if m.ValidatorIdentity != nil {
+ l = m.ValidatorIdentity.Size()
n += 1 + l + sovView(uint64(l))
}
- return n
-}
-
-func (m *AddressByIndexRequest) Size() (n int) {
- if m == nil {
- return 0
+ if m.StartEpochIndex != 0 {
+ n += 1 + sovView(uint64(m.StartEpochIndex))
}
- var l int
- _ = l
- if m.AddressIndex != nil {
- l = m.AddressIndex.Size()
+ if m.Penalty != nil {
+ l = m.Penalty.Size()
n += 1 + l + sovView(uint64(l))
}
- if m.DisplayConfirm {
- n += 2
+ if m.UnbondingAmount != nil {
+ l = m.UnbondingAmount.Size()
+ n += 1 + l + sovView(uint64(l))
+ }
+ if m.UnbondingStartHeight != 0 {
+ n += 1 + sovView(uint64(m.UnbondingStartHeight))
}
return n
}
-func (m *AddressByIndexResponse) Size() (n int) {
+func (m *TransactionPlannerRequest_PositionOpen) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.Address != nil {
- l = m.Address.Size()
+ if m.Position != nil {
+ l = m.Position.Size()
n += 1 + l + sovView(uint64(l))
}
return n
}
-func (m *IndexByAddressRequest) Size() (n int) {
+func (m *TransactionPlannerRequest_PositionClose) 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))
}
return n
}
-func (m *IndexByAddressResponse) Size() (n int) {
+func (m *TransactionPlannerRequest_PositionWithdraw) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.XAddressIndex != nil {
- n += m.XAddressIndex.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 *IndexByAddressResponse_AddressIndex) Size() (n int) {
+func (m *TransactionPlannerResponse) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.AddressIndex != nil {
- l = m.AddressIndex.Size()
+ if m.Plan != nil {
+ l = m.Plan.Size()
n += 1 + l + sovView(uint64(l))
}
return n
}
-func (m *EphemeralAddressRequest) Size() (n int) {
+
+func (m *AddressByIndexRequest) Size() (n int) {
if m == nil {
return 0
}
@@ -8067,13 +9718,10 @@ func (m *EphemeralAddressRequest) Size() (n int) {
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 *AddressByIndexResponse) Size() (n int) {
if m == nil {
return 0
}
@@ -8086,142 +9734,158 @@ func (m *EphemeralAddressResponse) Size() (n int) {
return n
}
-func (m *BalancesRequest) Size() (n int) {
+func (m *WalletIdRequest) 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()
- n += 1 + l + sovView(uint64(l))
- }
return n
}
-func (m *BalancesResponse) Size() (n int) {
+func (m *WalletIdResponse) 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.WalletId != nil {
+ l = m.WalletId.Size()
n += 1 + l + sovView(uint64(l))
}
return n
}
-func (m *ViewAuthToken) Size() (n int) {
+func (m *IndexByAddressRequest) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- l = len(m.Inner)
- if l > 0 {
+ if m.Address != nil {
+ l = m.Address.Size()
n += 1 + l + sovView(uint64(l))
}
return n
}
-func (m *ViewAuthRequest) Size() (n int) {
+func (m *IndexByAddressResponse) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.Fvk != nil {
- l = m.Fvk.Size()
+ if m.AddressIndex != nil {
+ l = m.AddressIndex.Size()
n += 1 + l + sovView(uint64(l))
}
return n
}
-func (m *ViewAuthResponse) Size() (n int) {
+func (m *EphemeralAddressRequest) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.Token != nil {
- l = m.Token.Size()
+ if m.AddressIndex != nil {
+ l = m.AddressIndex.Size()
n += 1 + l + sovView(uint64(l))
}
return n
}
-func (m *StatusRequest) Size() (n int) {
+func (m *EphemeralAddressResponse) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.XAccountGroupId != nil {
- n += m.XAccountGroupId.Size()
+ if m.Address != nil {
+ l = m.Address.Size()
+ n += 1 + l + sovView(uint64(l))
}
return n
}
-func (m *StatusRequest_AccountGroupId) Size() (n int) {
+func (m *BalancesRequest) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.AccountGroupId != nil {
- l = m.AccountGroupId.Size()
+ if m.AccountFilter != nil {
+ l = m.AccountFilter.Size()
n += 1 + l + sovView(uint64(l))
}
- return n
-}
-func (m *StatusResponse) Size() (n int) {
+ if m.AssetIdFilter != nil {
+ l = m.AssetIdFilter.Size()
+ n += 1 + l + sovView(uint64(l))
+ }
+ return n
+}
+
+func (m *BalancesResponse) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.SyncHeight != 0 {
- n += 1 + sovView(uint64(m.SyncHeight))
+ if m.Account != nil {
+ l = m.Account.Size()
+ n += 1 + l + sovView(uint64(l))
}
- if m.CatchingUp {
- n += 2
+ if m.Balance != nil {
+ l = m.Balance.Size()
+ n += 1 + l + sovView(uint64(l))
+ }
+ if m.AccountAddress != nil {
+ l = m.AccountAddress.Size()
+ n += 1 + l + sovView(uint64(l))
+ }
+ if m.BalanceView != nil {
+ l = m.BalanceView.Size()
+ n += 1 + l + sovView(uint64(l))
}
return n
}
-func (m *StatusStreamRequest) Size() (n int) {
+func (m *StatusRequest) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.XAccountGroupId != nil {
- n += m.XAccountGroupId.Size()
- }
return n
}
-func (m *StatusStreamRequest_AccountGroupId) Size() (n int) {
+func (m *StatusResponse) 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))
+ 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
+ }
+ return n
+}
+
+func (m *StatusStreamRequest) Size() (n int) {
+ if m == nil {
+ return 0
}
+ var l int
+ _ = l
return n
}
+
func (m *StatusStreamResponse) Size() (n int) {
if m == nil {
return 0
@@ -8231,8 +9895,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,120 +9925,117 @@ 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) {
+func (m *NotesForVotingRequest) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.AccountGroupId != nil {
- l = m.AccountGroupId.Size()
+ if m.VotableAtHeight != 0 {
+ n += 1 + sovView(uint64(m.VotableAtHeight))
+ }
+ if m.AddressIndex != nil {
+ l = m.AddressIndex.Size()
n += 1 + l + sovView(uint64(l))
}
return n
}
-func (m *NotesForVotingRequest) Size() (n int) {
+
+func (m *WitnessRequest) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.VotableAtHeight != 0 {
- n += 1 + sovView(uint64(m.VotableAtHeight))
- }
- if m.AddressIndex != nil {
- l = m.AddressIndex.Size()
+ if m.TransactionPlan != nil {
+ l = m.TransactionPlan.Size()
n += 1 + l + sovView(uint64(l))
}
- if m.XAccountGroupId != nil {
- n += m.XAccountGroupId.Size()
- }
return n
}
-func (m *NotesForVotingRequest_AccountGroupId) Size() (n int) {
+func (m *WitnessResponse) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.AccountGroupId != nil {
- l = m.AccountGroupId.Size()
+ if m.WitnessData != nil {
+ l = m.WitnessData.Size()
n += 1 + l + sovView(uint64(l))
}
return n
}
-func (m *WitnessRequest) Size() (n int) {
+
+func (m *WitnessAndBuildRequest) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if len(m.NoteCommitments) > 0 {
- for _, e := range m.NoteCommitments {
- l = e.Size()
- n += 1 + l + sovView(uint64(l))
- }
- }
if m.TransactionPlan != nil {
l = m.TransactionPlan.Size()
n += 1 + l + sovView(uint64(l))
}
- if m.XAccountGroupId != nil {
- n += m.XAccountGroupId.Size()
+ if m.AuthorizationData != nil {
+ l = m.AuthorizationData.Size()
+ n += 1 + l + sovView(uint64(l))
}
return n
}
-func (m *WitnessRequest_AccountGroupId) Size() (n int) {
+func (m *WitnessAndBuildResponse) 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))
+ if m.Status != nil {
+ n += m.Status.Size()
}
return n
}
-func (m *WitnessResponse) Size() (n int) {
+
+func (m *WitnessAndBuildResponse_BuildProgress_) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.WitnessData != nil {
- l = m.WitnessData.Size()
+ if m.BuildProgress != nil {
+ l = m.BuildProgress.Size()
n += 1 + l + sovView(uint64(l))
}
return n
}
-
-func (m *WitnessAndBuildRequest) Size() (n int) {
+func (m *WitnessAndBuildResponse_Complete_) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.TransactionPlan != nil {
- l = m.TransactionPlan.Size()
+ if m.Complete != nil {
+ l = m.Complete.Size()
n += 1 + l + sovView(uint64(l))
}
- if m.AuthorizationData != nil {
- l = m.AuthorizationData.Size()
- n += 1 + l + sovView(uint64(l))
+ return n
+}
+func (m *WitnessAndBuildResponse_BuildProgress) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.Progress != 0 {
+ n += 5
}
return n
}
-func (m *WitnessAndBuildResponse) Size() (n int) {
+func (m *WitnessAndBuildResponse_Complete) Size() (n int) {
if m == nil {
return 0
}
@@ -8430,7 +10094,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 +10103,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,6 +10116,28 @@ func (m *ChainParametersResponse) Size() (n int) {
return n
}
+func (m *GasPricesRequest) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ return n
+}
+
+func (m *GasPricesResponse) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.GasPrices != nil {
+ l = m.GasPrices.Size()
+ n += 1 + l + sovView(uint64(l))
+ }
+ return n
+}
+
func (m *FMDParametersRequest) Size() (n int) {
if m == nil {
return 0
@@ -8487,24 +10173,9 @@ func (m *NoteByCommitmentRequest) Size() (n int) {
if m.AwaitDetection {
n += 2
}
- if m.XAccountGroupId != nil {
- n += m.XAccountGroupId.Size()
- }
return n
}
-func (m *NoteByCommitmentRequest_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 *NoteByCommitmentResponse) Size() (n int) {
if m == nil {
return 0
@@ -8531,25 +10202,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 +10253,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 +10287,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 +10324,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 +10405,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))
@@ -8779,18 +10415,13 @@ func (m *SpendableNoteRecord) Size() (n int) {
l = m.Source.Size()
n += 1 + l + sovView(uint64(l))
}
- return n
-}
-
-func (m *SpendableNoteRecord_HeightSpent) Size() (n int) {
- if m == nil {
- return 0
+ if m.ReturnAddress != nil {
+ l = m.ReturnAddress.Size()
+ n += 1 + l + sovView(uint64(l))
}
- 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 +10447,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,62 +10457,86 @@ func (m *SwapRecord) Size() (n int) {
return n
}
-func (m *SwapRecord_HeightClaimed) Size() (n int) {
+func (m *OwnedPositionIdsRequest) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- n += 1 + sovView(uint64(m.HeightClaimed))
+ if m.PositionState != nil {
+ l = m.PositionState.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 *OwnedPositionIdsRequest) Size() (n int) {
+
+func (m *OwnedPositionIdsResponse) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.XPositionState != nil {
- n += m.XPositionState.Size()
+ if m.PositionId != nil {
+ l = m.PositionId.Size()
+ n += 1 + l + sovView(uint64(l))
+ }
+ return n
+}
+
+func (m *AssetMetadataByIdRequest) Size() (n int) {
+ if m == nil {
+ return 0
}
- if m.XTradingPair != nil {
- n += m.XTradingPair.Size()
+ var l int
+ _ = l
+ if m.AssetId != nil {
+ l = m.AssetId.Size()
+ n += 1 + l + sovView(uint64(l))
}
return n
}
-func (m *OwnedPositionIdsRequest_PositionState) Size() (n int) {
+func (m *AssetMetadataByIdResponse) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.PositionState != nil {
- l = m.PositionState.Size()
+ if m.DenomMetadata != nil {
+ l = m.DenomMetadata.Size()
n += 1 + l + sovView(uint64(l))
}
return n
}
-func (m *OwnedPositionIdsRequest_TradingPair) Size() (n int) {
+
+func (m *DelegationsByAddressIndexRequest) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.TradingPair != nil {
- l = m.TradingPair.Size()
+ if m.AddressIndex != nil {
+ l = m.AddressIndex.Size()
n += 1 + l + sovView(uint64(l))
}
+ if m.Filter != 0 {
+ n += 1 + sovView(uint64(m.Filter))
+ }
return n
}
-func (m *OwnedPositionIdsResponse) Size() (n int) {
+
+func (m *DelegationsByAddressIndexResponse) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
- if m.PositionId != nil {
- l = m.PositionId.Size()
+ if m.ValueView != nil {
+ l = m.ValueView.Size()
n += 1 + l + sovView(uint64(l))
}
return n
@@ -8952,48 +10607,12 @@ func (m *AuthorizeAndBuildRequest) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.TransactionPlan == nil {
- m.TransactionPlan = &v1alpha1.TransactionPlan{}
+ m.TransactionPlan = &v1.TransactionPlan{}
}
if err := m.TransactionPlan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
- case 2:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field AuthorizationData", 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.AuthorizationData == nil {
- m.AuthorizationData = &v1alpha1.AuthorizationData{}
- }
- if err := m.AuthorizationData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
- }
- iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipView(dAtA[iNdEx:])
@@ -9046,7 +10665,7 @@ func (m *AuthorizeAndBuildResponse) Unmarshal(dAtA []byte) error {
switch fieldNum {
case 1:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Transaction", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field BuildProgress", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -9073,14 +10692,48 @@ func (m *AuthorizeAndBuildResponse) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Transaction == nil {
- m.Transaction = &v1alpha1.Transaction{}
- }
- if err := m.Transaction.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ v := &AuthorizeAndBuildResponse_BuildProgress{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
+ m.Status = &AuthorizeAndBuildResponse_BuildProgress_{v}
iNdEx = postIndex
- default:
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Complete", 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 := &AuthorizeAndBuildResponse_Complete{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ m.Status = &AuthorizeAndBuildResponse_Complete_{v}
+ iNdEx = postIndex
+ default:
iNdEx = preIndex
skippy, err := skipView(dAtA[iNdEx:])
if err != nil {
@@ -9101,7 +10754,7 @@ func (m *AuthorizeAndBuildResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *BroadcastTransactionRequest) Unmarshal(dAtA []byte) error {
+func (m *AuthorizeAndBuildResponse_BuildProgress) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -9124,10 +10777,71 @@ func (m *BroadcastTransactionRequest) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: BroadcastTransactionRequest: wiretype end group for non-group")
+ return fmt.Errorf("proto: BuildProgress: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: BroadcastTransactionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: BuildProgress: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 5 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Progress", wireType)
+ }
+ var v uint32
+ if (iNdEx + 4) > l {
+ return io.ErrUnexpectedEOF
+ }
+ v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
+ iNdEx += 4
+ m.Progress = float32(math.Float32frombits(v))
+ 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 *AuthorizeAndBuildResponse_Complete) Unmarshal(dAtA []byte) 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: Complete: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Complete: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
@@ -9160,32 +10874,12 @@ func (m *BroadcastTransactionRequest) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.Transaction == nil {
- m.Transaction = &v1alpha1.Transaction{}
+ m.Transaction = &v1.Transaction{}
}
if err := m.Transaction.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
- case 2:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field AwaitDetection", 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.AwaitDetection = bool(v != 0)
default:
iNdEx = preIndex
skippy, err := skipView(dAtA[iNdEx:])
@@ -9207,7 +10901,7 @@ func (m *BroadcastTransactionRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *BroadcastTransactionResponse) Unmarshal(dAtA []byte) error {
+func (m *BroadcastTransactionRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -9230,15 +10924,15 @@ func (m *BroadcastTransactionResponse) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: BroadcastTransactionResponse: wiretype end group for non-group")
+ return fmt.Errorf("proto: BroadcastTransactionRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: BroadcastTransactionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: BroadcastTransactionRequest: 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)
+ return fmt.Errorf("proto: wrong wireType = %d for field Transaction", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -9265,18 +10959,18 @@ func (m *BroadcastTransactionResponse) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Id == nil {
- m.Id = &v1alpha1.Id{}
+ if m.Transaction == nil {
+ m.Transaction = &v1.Transaction{}
}
- if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.Transaction.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field DetectionHeight", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field AwaitDetection", wireType)
}
- m.DetectionHeight = 0
+ var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowView
@@ -9286,11 +10980,12 @@ func (m *BroadcastTransactionResponse) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- m.DetectionHeight |= uint64(b&0x7F) << shift
+ v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
+ m.AwaitDetection = bool(v != 0)
default:
iNdEx = preIndex
skippy, err := skipView(dAtA[iNdEx:])
@@ -9312,7 +11007,7 @@ func (m *BroadcastTransactionResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *TransactionPlannerRequest) Unmarshal(dAtA []byte) error {
+func (m *BroadcastTransactionResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -9335,34 +11030,15 @@ func (m *TransactionPlannerRequest) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: TransactionPlannerRequest: wiretype end group for non-group")
+ return fmt.Errorf("proto: BroadcastTransactionResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: TransactionPlannerRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: BroadcastTransactionResponse: 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 ErrIntOverflowView
- }
- 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 Fee", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field BroadcastSuccess", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -9389,16 +11065,15 @@ func (m *TransactionPlannerRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Fee == nil {
- m.Fee = &v1alpha11.Fee{}
- }
- if err := m.Fee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ v := &BroadcastTransactionResponse_BroadcastSuccess{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
+ m.Status = &BroadcastTransactionResponse_BroadcastSuccess_{v}
iNdEx = postIndex
- case 3:
+ case 2:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Memo", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Confirmed", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -9425,51 +11100,65 @@ func (m *TransactionPlannerRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Memo == nil {
- m.Memo = &v1alpha1.MemoPlaintext{}
- }
- if err := m.Memo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ v := &BroadcastTransactionResponse_Confirmed{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
+ m.Status = &BroadcastTransactionResponse_Confirmed_{v}
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
- }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipView(dAtA[iNdEx:])
+ if err != nil {
+ return err
}
- if msglen < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthView
}
- postIndex := iNdEx + msglen
- if postIndex < 0 {
- return ErrInvalidLengthView
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
}
- if postIndex > l {
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *BroadcastTransactionResponse_BroadcastSuccess) Unmarshal(dAtA []byte) 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
}
- v := &v1alpha11.AccountGroupId{}
- 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.XAccountGroupId = &TransactionPlannerRequest_AccountGroupId{v}
- iNdEx = postIndex
- case 20:
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: BroadcastSuccess: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: BroadcastSuccess: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Outputs", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -9496,82 +11185,66 @@ func (m *TransactionPlannerRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- m.Outputs = append(m.Outputs, &TransactionPlannerRequest_Output{})
- if err := m.Outputs[len(m.Outputs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if m.Id == nil {
+ m.Id = &v11.TransactionId{}
+ }
+ if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
- case 30:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Swaps", wireType)
+ default:
+ iNdEx = preIndex
+ skippy, err := skipView(dAtA[iNdEx:])
+ if err != nil {
+ return err
}
- 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 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthView
}
- if postIndex > l {
+ if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
- m.Swaps = append(m.Swaps, &TransactionPlannerRequest_Swap{})
- if err := m.Swaps[len(m.Swaps)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
- }
- iNdEx = postIndex
- case 31:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field SwapClaims", 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
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *BroadcastTransactionResponse_Confirmed) Unmarshal(dAtA []byte) 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 postIndex > l {
+ if iNdEx >= l {
return io.ErrUnexpectedEOF
}
- m.SwapClaims = append(m.SwapClaims, &TransactionPlannerRequest_SwapClaim{})
- if err := m.SwapClaims[len(m.SwapClaims)-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 40:
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Confirmed: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Confirmed: 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 Id", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -9598,50 +11271,18 @@ func (m *TransactionPlannerRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- m.Delegations = append(m.Delegations, &TransactionPlannerRequest_Delegate{})
- if err := m.Delegations[len(m.Delegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
- }
- iNdEx = postIndex
- case 50:
- 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 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.Id == nil {
+ m.Id = &v11.TransactionId{}
}
- m.Undelegations = append(m.Undelegations, &TransactionPlannerRequest_Undelegate{})
- if err := m.Undelegations[len(m.Undelegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
- case 60:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field IbcActions", wireType)
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DetectionHeight", wireType)
}
- var msglen int
+ m.DetectionHeight = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowView
@@ -9651,26 +11292,11 @@ func (m *TransactionPlannerRequest) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- msglen |= int(b&0x7F) << shift
+ m.DetectionHeight |= uint64(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.IbcActions = append(m.IbcActions, &v1alpha12.IbcAction{})
- if err := m.IbcActions[len(m.IbcActions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
- }
- iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipView(dAtA[iNdEx:])
@@ -9692,7 +11318,7 @@ func (m *TransactionPlannerRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *TransactionPlannerRequest_Output) Unmarshal(dAtA []byte) error {
+func (m *TransactionPlannerRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -9715,15 +11341,34 @@ 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: TransactionPlannerRequest: 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: TransactionPlannerRequest: 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 ErrIntOverflowView
+ }
+ 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 Value", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Memo", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -9750,16 +11395,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.Memo == nil {
+ m.Memo = &v1.MemoPlaintext{}
}
- if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.Memo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
- case 2:
+ case 4:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -9786,66 +11431,16 @@ func (m *TransactionPlannerRequest_Output) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Address == nil {
- m.Address = &v1alpha11.Address{}
+ if m.Source == nil {
+ m.Source = &v12.AddressIndex{}
}
- if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.Source.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:
+ case 20:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Outputs", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -9872,16 +11467,14 @@ func (m *TransactionPlannerRequest_Swap) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Value == nil {
- m.Value = &v1alpha11.Value{}
- }
- if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ m.Outputs = append(m.Outputs, &TransactionPlannerRequest_Output{})
+ if err := m.Outputs[len(m.Outputs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
- case 2:
+ case 30:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field TargetAsset", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Swaps", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -9908,16 +11501,14 @@ func (m *TransactionPlannerRequest_Swap) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.TargetAsset == nil {
- m.TargetAsset = &v1alpha11.AssetId{}
- }
- if err := m.TargetAsset.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ m.Swaps = append(m.Swaps, &TransactionPlannerRequest_Swap{})
+ if err := m.Swaps[len(m.Swaps)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
- case 3:
+ case 31:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field SwapClaims", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -9944,13 +11535,1422 @@ func (m *TransactionPlannerRequest_Swap) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Fee == nil {
- m.Fee = &v1alpha11.Fee{}
+ m.SwapClaims = append(m.SwapClaims, &TransactionPlannerRequest_SwapClaim{})
+ if err := m.SwapClaims[len(m.SwapClaims)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 40:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Delegations", 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.Delegations = append(m.Delegations, &TransactionPlannerRequest_Delegate{})
+ if err := m.Delegations[len(m.Delegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 50:
+ 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 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.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 51:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field UndelegationClaims", 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.UndelegationClaims = append(m.UndelegationClaims, &TransactionPlannerRequest_UndelegateClaim{})
+ if err := m.UndelegationClaims[len(m.UndelegationClaims)-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, &v13.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, &v13.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
+ case 100:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field AutoFee", 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 := &v14.FeeTier{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ m.FeeMode = &TransactionPlannerRequest_AutoFee{v}
+ iNdEx = postIndex
+ case 101:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field ManualFee", 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 := &v14.Fee{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ m.FeeMode = &TransactionPlannerRequest_ManualFee{v}
+ iNdEx = postIndex
+ case 200:
+ 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 ErrIntOverflowView
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.EpochIndex |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 201:
+ 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 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.Epoch == nil {
+ m.Epoch = &v15.Epoch{}
+ }
+ if err := m.Epoch.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 = &v16.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 = &v12.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 = &v16.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 = &v16.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 = &v14.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 = &v12.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
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ 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 SwapCommitment", 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.SwapCommitment == nil {
+ m.SwapCommitment = &v17.StateCommitment{}
+ }
+ if err := m.SwapCommitment.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_Delegate) Unmarshal(dAtA []byte) 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: Delegate: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ 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 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 = &v18.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)
+ }
+ 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.RateData == nil {
+ m.RateData = &v19.RateData{}
+ }
+ if err := m.RateData.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_Undelegate) Unmarshal(dAtA []byte) 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: Undelegate: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ 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 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 = &v16.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 RateData", 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.RateData == nil {
+ m.RateData = &v19.RateData{}
+ }
+ if err := m.RateData.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_UndelegateClaim) Unmarshal(dAtA []byte) 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: UndelegateClaim: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: UndelegateClaim: 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)
+ }
+ 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.ValidatorIdentity == nil {
+ m.ValidatorIdentity = &v12.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 StartEpochIndex", wireType)
+ }
+ m.StartEpochIndex = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowView
+ }
+ 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)
+ }
+ 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.Penalty == nil {
+ m.Penalty = &v19.Penalty{}
+ }
+ if err := m.Penalty.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field UnbondingAmount", 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.UnbondingAmount == nil {
+ m.UnbondingAmount = &v18.Amount{}
+ }
+ if err := m.UnbondingAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field UnbondingStartHeight", wireType)
+ }
+ m.UnbondingStartHeight = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowView
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.UnbondingStartHeight |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ 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_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 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: 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 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.Position == nil {
+ m.Position = &v110.Position{}
+ }
+ if err := m.Position.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_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 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: 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 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.PositionId == nil {
+ m.PositionId = &v110.PositionId{}
+ }
+ if err := m.PositionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipView(dAtA[iNdEx:])
@@ -9972,7 +12972,7 @@ func (m *TransactionPlannerRequest_Swap) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *TransactionPlannerRequest_SwapClaim) Unmarshal(dAtA []byte) error {
+func (m *TransactionPlannerRequest_PositionWithdraw) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -9995,15 +12995,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: PositionWithdraw: 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: 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 SwapCommitment", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field PositionId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -10030,10 +13030,82 @@ func (m *TransactionPlannerRequest_SwapClaim) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.SwapCommitment == nil {
- m.SwapCommitment = &v1alpha11.StateCommitment{}
+ if m.PositionId == nil {
+ m.PositionId = &v110.PositionId{}
}
- if err := m.SwapCommitment.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 Reserves", 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.Reserves == nil {
+ m.Reserves = &v110.Reserves{}
+ }
+ if err := m.Reserves.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ 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 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.TradingPair == nil {
+ m.TradingPair = &v110.TradingPair{}
+ }
+ if err := m.TradingPair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@@ -10058,7 +13130,7 @@ func (m *TransactionPlannerRequest_SwapClaim) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *TransactionPlannerRequest_Delegate) Unmarshal(dAtA []byte) error {
+func (m *TransactionPlannerResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -10081,15 +13153,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: TransactionPlannerResponse: 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: 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 Amount", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Plan", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -10116,16 +13188,66 @@ func (m *TransactionPlannerRequest_Delegate) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Amount == nil {
- m.Amount = &v1alpha11.Amount{}
+ if m.Plan == nil {
+ m.Plan = &v1.TransactionPlan{}
}
- if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.Plan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
- case 3:
+ 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 *AddressByIndexRequest) Unmarshal(dAtA []byte) 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: AddressByIndexRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ 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 RateData", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field AddressIndex", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -10152,10 +13274,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.AddressIndex == nil {
+ m.AddressIndex = &v12.AddressIndex{}
}
- if err := m.RateData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.AddressIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@@ -10180,7 +13302,7 @@ func (m *TransactionPlannerRequest_Delegate) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *TransactionPlannerRequest_Undelegate) Unmarshal(dAtA []byte) error {
+func (m *AddressByIndexResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -10203,15 +13325,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: AddressByIndexResponse: 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: AddressByIndexResponse: 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 Address", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -10238,16 +13360,116 @@ func (m *TransactionPlannerRequest_Undelegate) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Value == nil {
- m.Value = &v1alpha11.Value{}
+ if m.Address == nil {
+ m.Address = &v12.Address{}
}
- if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ 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 *WalletIdRequest) Unmarshal(dAtA []byte) 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: WalletIdRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: WalletIdRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ default:
+ iNdEx = preIndex
+ skippy, err := skipView(dAtA[iNdEx:])
+ if err != nil {
return err
}
- iNdEx = postIndex
- case 2:
+ 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 *WalletIdResponse) Unmarshal(dAtA []byte) 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: WalletIdResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ 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 RateData", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field WalletId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -10274,10 +13496,10 @@ func (m *TransactionPlannerRequest_Undelegate) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.RateData == nil {
- m.RateData = &v1alpha13.RateData{}
+ if m.WalletId == nil {
+ m.WalletId = &v12.WalletId{}
}
- if err := m.RateData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.WalletId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@@ -10302,7 +13524,7 @@ func (m *TransactionPlannerRequest_Undelegate) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *TransactionPlannerResponse) Unmarshal(dAtA []byte) error {
+func (m *IndexByAddressRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -10325,15 +13547,15 @@ func (m *TransactionPlannerResponse) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: TransactionPlannerResponse: wiretype end group for non-group")
+ return fmt.Errorf("proto: IndexByAddressRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: TransactionPlannerResponse: 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:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Plan", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -10360,10 +13582,10 @@ func (m *TransactionPlannerResponse) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Plan == nil {
- m.Plan = &v1alpha1.TransactionPlan{}
+ if m.Address == nil {
+ m.Address = &v12.Address{}
}
- if err := m.Plan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@@ -10388,7 +13610,7 @@ func (m *TransactionPlannerResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *AddressByIndexRequest) Unmarshal(dAtA []byte) error {
+func (m *IndexByAddressResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -10411,10 +13633,10 @@ 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: IndexByAddressResponse: 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: IndexByAddressResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
@@ -10447,32 +13669,12 @@ func (m *AddressByIndexRequest) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.AddressIndex == nil {
- m.AddressIndex = &v1alpha11.AddressIndex{}
+ m.AddressIndex = &v12.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)
- }
- 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:])
@@ -10494,7 +13696,7 @@ func (m *AddressByIndexRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *AddressByIndexResponse) Unmarshal(dAtA []byte) error {
+func (m *EphemeralAddressRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -10517,15 +13719,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: EphemeralAddressRequest: 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: 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 Address", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field AddressIndex", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -10552,10 +13754,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 = &v12.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 +13782,7 @@ func (m *AddressByIndexResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *IndexByAddressRequest) Unmarshal(dAtA []byte) error {
+func (m *EphemeralAddressResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -10603,10 +13805,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: EphemeralAddressResponse: 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: EphemeralAddressResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
@@ -10639,7 +13841,7 @@ func (m *IndexByAddressRequest) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.Address == nil {
- m.Address = &v1alpha11.Address{}
+ m.Address = &v12.Address{}
}
if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@@ -10666,7 +13868,7 @@ func (m *IndexByAddressRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *IndexByAddressResponse) Unmarshal(dAtA []byte) error {
+func (m *BalancesRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -10689,15 +13891,15 @@ 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: BalancesRequest: 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: 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 AddressIndex", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field AccountFilter", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -10724,11 +13926,48 @@ func (m *IndexByAddressResponse) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha11.AddressIndex{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if m.AccountFilter == nil {
+ m.AccountFilter = &v12.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 {
+ 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.AssetIdFilter == nil {
+ m.AssetIdFilter = &v16.AssetId{}
+ }
+ if err := m.AssetIdFilter.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.XAddressIndex = &IndexByAddressResponse_AddressIndex{v}
iNdEx = postIndex
default:
iNdEx = preIndex
@@ -10751,7 +13990,7 @@ func (m *IndexByAddressResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *EphemeralAddressRequest) Unmarshal(dAtA []byte) error {
+func (m *BalancesResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -10774,15 +14013,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: BalancesResponse: 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: 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 AddressIndex", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Account", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -10809,18 +14048,18 @@ func (m *EphemeralAddressRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.AddressIndex == nil {
- m.AddressIndex = &v1alpha11.AddressIndex{}
+ if m.Account == nil {
+ m.Account = &v12.AddressIndex{}
}
- if err := m.AddressIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.Account.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 wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType)
}
- var v int
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowView
@@ -10830,12 +14069,100 @@ func (m *EphemeralAddressRequest) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- v |= int(b&0x7F) << shift
+ 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.Balance == nil {
+ m.Balance = &v16.Value{}
+ }
+ if err := m.Balance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field AccountAddress", 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.AccountAddress == nil {
+ m.AccountAddress = &v12.AddressView{}
+ }
+ if err := m.AccountAddress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field BalanceView", 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
}
}
- m.DisplayConfirm = bool(v != 0)
+ if msglen < 0 {
+ return ErrInvalidLengthView
+ }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthView
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.BalanceView == nil {
+ m.BalanceView = &v16.ValueView{}
+ }
+ if err := m.BalanceView.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipView(dAtA[iNdEx:])
@@ -10857,7 +14184,7 @@ func (m *EphemeralAddressRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *EphemeralAddressResponse) Unmarshal(dAtA []byte) error {
+func (m *StatusRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -10880,48 +14207,12 @@ 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: StatusRequest: 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: StatusRequest: 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 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 = &v1alpha11.Address{}
- }
- if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
- }
- iNdEx = postIndex
+ switch fieldNum {
default:
iNdEx = preIndex
skippy, err := skipView(dAtA[iNdEx:])
@@ -10943,7 +14234,7 @@ func (m *EphemeralAddressResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *BalancesRequest) Unmarshal(dAtA []byte) error {
+func (m *StatusResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -10966,17 +14257,17 @@ 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: StatusResponse: 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: StatusResponse: 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)
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FullSyncHeight", wireType)
}
- var msglen int
+ m.FullSyncHeight = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowView
@@ -10986,33 +14277,16 @@ func (m *BalancesRequest) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- msglen |= int(b&0x7F) << shift
+ m.FullSyncHeight |= uint64(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)
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PartialSyncHeight", wireType)
}
- var msglen int
+ m.PartialSyncHeight = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowView
@@ -11022,28 +14296,31 @@ func (m *BalancesRequest) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- msglen |= int(b&0x7F) << shift
+ m.PartialSyncHeight |= uint64(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.AssetIdFilter == nil {
- m.AssetIdFilter = &v1alpha11.AssetId{}
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field CatchingUp", wireType)
}
- if err := m.AssetIdFilter.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
+ 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
+ }
}
- iNdEx = postIndex
+ m.CatchingUp = bool(v != 0)
default:
iNdEx = preIndex
skippy, err := skipView(dAtA[iNdEx:])
@@ -11065,7 +14342,7 @@ func (m *BalancesRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *BalancesResponse) Unmarshal(dAtA []byte) error {
+func (m *StatusStreamRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -11088,84 +14365,12 @@ 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: StatusStreamRequest: 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: StatusStreamRequest: 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)
- }
- 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 = &v1alpha11.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 {
- 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.Balance == nil {
- m.Balance = &v1alpha11.Value{}
- }
- if err := m.Balance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
- }
- iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipView(dAtA[iNdEx:])
@@ -11187,7 +14392,7 @@ func (m *BalancesResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *ViewAuthToken) Unmarshal(dAtA []byte) error {
+func (m *StatusStreamResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -11210,17 +14415,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: StatusStreamResponse: 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: StatusStreamResponse: 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)
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field LatestKnownBlockHeight", wireType)
}
- var byteLen int
+ m.LatestKnownBlockHeight = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowView
@@ -11230,26 +14435,49 @@ func (m *ViewAuthToken) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- byteLen |= int(b&0x7F) << shift
+ m.LatestKnownBlockHeight |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
- if byteLen < 0 {
- return ErrInvalidLengthView
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FullSyncHeight", wireType)
}
- postIndex := iNdEx + byteLen
- if postIndex < 0 {
- return ErrInvalidLengthView
+ 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
+ }
}
- if postIndex > l {
- return io.ErrUnexpectedEOF
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field PartialSyncHeight", wireType)
}
- m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...)
- if m.Inner == nil {
- m.Inner = []byte{}
+ 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
+ }
}
- iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipView(dAtA[iNdEx:])
@@ -11271,7 +14499,7 @@ func (m *ViewAuthToken) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *ViewAuthRequest) Unmarshal(dAtA []byte) error {
+func (m *NotesRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -11294,15 +14522,35 @@ 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: NotesRequest: 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: NotesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
- case 1:
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field IncludeSpent", 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.IncludeSpent = bool(v != 0)
+ case 3:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Fvk", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field AssetId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11329,66 +14577,52 @@ func (m *ViewAuthRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Fvk == nil {
- m.Fvk = &v1alpha11.FullViewingKey{}
+ if m.AssetId == nil {
+ m.AssetId = &v16.AssetId{}
}
- if err := m.Fvk.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.AssetId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
- default:
- iNdEx = preIndex
- skippy, err := skipView(dAtA[iNdEx:])
- if err != nil {
- return err
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field AddressIndex", wireType)
}
- if (skippy < 0) || (iNdEx+skippy) < 0 {
- return ErrInvalidLengthView
+ 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 (iNdEx + skippy) > l {
- return io.ErrUnexpectedEOF
+ if msglen < 0 {
+ return ErrInvalidLengthView
}
- iNdEx += skippy
- }
- }
-
- if iNdEx > l {
- return io.ErrUnexpectedEOF
- }
- return nil
-}
-func (m *ViewAuthResponse) Unmarshal(dAtA []byte) 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
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthView
}
- if iNdEx >= l {
+ if postIndex > l {
return io.ErrUnexpectedEOF
}
- b := dAtA[iNdEx]
- iNdEx++
- wire |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
+ if m.AddressIndex == nil {
+ m.AddressIndex = &v12.AddressIndex{}
}
- }
- fieldNum := int32(wire >> 3)
- wireType := int(wire & 0x7)
- if wireType == 4 {
- return fmt.Errorf("proto: ViewAuthResponse: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: ViewAuthResponse: illegal tag %d (wire type %d)", fieldNum, wire)
- }
- switch fieldNum {
- case 1:
+ if err := m.AddressIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 6:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field AmountToSpend", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11415,10 +14649,10 @@ func (m *ViewAuthResponse) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Token == nil {
- m.Token = &ViewAuthToken{}
+ if m.AmountToSpend == nil {
+ m.AmountToSpend = &v18.Amount{}
}
- if err := m.Token.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.AmountToSpend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@@ -11443,7 +14677,7 @@ func (m *ViewAuthResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *StatusRequest) Unmarshal(dAtA []byte) error {
+func (m *NotesForVotingRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -11466,15 +14700,34 @@ func (m *StatusRequest) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: StatusRequest: wiretype end group for non-group")
+ return fmt.Errorf("proto: NotesForVotingRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: StatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: NotesForVotingRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
- case 14:
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field VotableAtHeight", wireType)
+ }
+ m.VotableAtHeight = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowView
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.VotableAtHeight |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 3:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field AccountGroupId", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field AddressIndex", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11501,11 +14754,12 @@ func (m *StatusRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha11.AccountGroupId{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if m.AddressIndex == nil {
+ m.AddressIndex = &v12.AddressIndex{}
+ }
+ if err := m.AddressIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.XAccountGroupId = &StatusRequest_AccountGroupId{v}
iNdEx = postIndex
default:
iNdEx = preIndex
@@ -11528,7 +14782,7 @@ func (m *StatusRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *StatusResponse) Unmarshal(dAtA []byte) error {
+func (m *WitnessRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -11551,17 +14805,17 @@ func (m *StatusResponse) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: StatusResponse: wiretype end group for non-group")
+ return fmt.Errorf("proto: WitnessRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: StatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: WitnessRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
- case 1:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field SyncHeight", wireType)
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TransactionPlan", wireType)
}
- m.SyncHeight = 0
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowView
@@ -11571,31 +14825,28 @@ func (m *StatusResponse) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- m.SyncHeight |= uint64(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 CatchingUp", wireType)
+ if msglen < 0 {
+ return ErrInvalidLengthView
}
- 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
- }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthView
}
- m.CatchingUp = bool(v != 0)
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.TransactionPlan == nil {
+ m.TransactionPlan = &v1.TransactionPlan{}
+ }
+ if err := m.TransactionPlan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipView(dAtA[iNdEx:])
@@ -11617,7 +14868,7 @@ func (m *StatusResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *StatusStreamRequest) Unmarshal(dAtA []byte) error {
+func (m *WitnessResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -11640,15 +14891,15 @@ func (m *StatusStreamRequest) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: StatusStreamRequest: wiretype end group for non-group")
+ return fmt.Errorf("proto: WitnessResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: StatusStreamRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: WitnessResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
- case 14:
+ 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 WitnessData", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11675,11 +14926,12 @@ func (m *StatusStreamRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha11.AccountGroupId{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if m.WitnessData == nil {
+ m.WitnessData = &v1.WitnessData{}
+ }
+ if err := m.WitnessData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.XAccountGroupId = &StatusStreamRequest_AccountGroupId{v}
iNdEx = postIndex
default:
iNdEx = preIndex
@@ -11702,7 +14954,7 @@ func (m *StatusStreamRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *StatusStreamResponse) Unmarshal(dAtA []byte) error {
+func (m *WitnessAndBuildRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -11725,17 +14977,17 @@ func (m *StatusStreamResponse) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: StatusStreamResponse: wiretype end group for non-group")
+ return fmt.Errorf("proto: WitnessAndBuildRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: StatusStreamResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: WitnessAndBuildRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field LatestKnownBlockHeight", wireType)
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TransactionPlan", wireType)
}
- m.LatestKnownBlockHeight = 0
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowView
@@ -11745,16 +14997,33 @@ func (m *StatusStreamResponse) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- m.LatestKnownBlockHeight |= uint64(b&0x7F) << shift
+ 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.TransactionPlan == nil {
+ m.TransactionPlan = &v1.TransactionPlan{}
+ }
+ if err := m.TransactionPlan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
case 2:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field SyncHeight", wireType)
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field AuthorizationData", wireType)
}
- m.SyncHeight = 0
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowView
@@ -11764,11 +15033,28 @@ func (m *StatusStreamResponse) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- m.SyncHeight |= uint64(b&0x7F) << shift
+ 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.AuthorizationData == nil {
+ m.AuthorizationData = &v1.AuthorizationData{}
+ }
+ if err := m.AuthorizationData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipView(dAtA[iNdEx:])
@@ -11790,7 +15076,7 @@ func (m *StatusStreamResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *NotesRequest) Unmarshal(dAtA []byte) error {
+func (m *WitnessAndBuildResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -11813,35 +15099,15 @@ func (m *NotesRequest) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: NotesRequest: wiretype end group for non-group")
+ return fmt.Errorf("proto: WitnessAndBuildResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: NotesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: WitnessAndBuildResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
- case 2:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field IncludeSpent", 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.IncludeSpent = bool(v != 0)
- case 3:
+ case 1:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field AssetId", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field BuildProgress", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11868,16 +15134,15 @@ func (m *NotesRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.AssetId == nil {
- m.AssetId = &v1alpha11.AssetId{}
- }
- if err := m.AssetId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ v := &WitnessAndBuildResponse_BuildProgress{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
+ m.Status = &WitnessAndBuildResponse_BuildProgress_{v}
iNdEx = postIndex
- case 4:
+ case 2:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field AddressIndex", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Complete", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11904,52 +15169,126 @@ func (m *NotesRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.AddressIndex == nil {
- m.AddressIndex = &v1alpha11.AddressIndex{}
+ v := &WitnessAndBuildResponse_Complete{}
+ if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ m.Status = &WitnessAndBuildResponse_Complete_{v}
+ 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 *WitnessAndBuildResponse_BuildProgress) Unmarshal(dAtA []byte) 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: BuildProgress: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: BuildProgress: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 5 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Progress", wireType)
+ }
+ var v uint32
+ if (iNdEx + 4) > l {
+ return io.ErrUnexpectedEOF
}
- if err := m.AddressIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
+ iNdEx += 4
+ m.Progress = float32(math.Float32frombits(v))
+ default:
+ iNdEx = preIndex
+ skippy, err := skipView(dAtA[iNdEx:])
+ if err != nil {
return err
}
- iNdEx = postIndex
- case 6:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field AmountToSpend", 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 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthView
}
- if postIndex > l {
+ if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
- if m.AmountToSpend == nil {
- m.AmountToSpend = &v1alpha11.Amount{}
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *WitnessAndBuildResponse_Complete) Unmarshal(dAtA []byte) 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 err := m.AmountToSpend.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
}
- iNdEx = postIndex
- case 14:
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Complete: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Complete: 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 Transaction", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -11976,11 +15315,12 @@ func (m *NotesRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha11.AccountGroupId{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if m.Transaction == nil {
+ m.Transaction = &v1.Transaction{}
+ }
+ if err := m.Transaction.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.XAccountGroupId = &NotesRequest_AccountGroupId{v}
iNdEx = postIndex
default:
iNdEx = preIndex
@@ -12003,7 +15343,7 @@ func (m *NotesRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *NotesForVotingRequest) Unmarshal(dAtA []byte) error {
+func (m *AssetsRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -12026,17 +15366,17 @@ func (m *NotesForVotingRequest) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: NotesForVotingRequest: wiretype end group for non-group")
+ return fmt.Errorf("proto: AssetsRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: NotesForVotingRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: AssetsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field VotableAtHeight", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Filtered", wireType)
}
- m.VotableAtHeight = 0
+ var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowView
@@ -12046,14 +15386,15 @@ func (m *NotesForVotingRequest) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- m.VotableAtHeight |= uint64(b&0x7F) << shift
+ v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
- case 3:
+ m.Filtered = bool(v != 0)
+ case 2:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field AddressIndex", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field IncludeSpecificDenominations", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12080,18 +15421,16 @@ func (m *NotesForVotingRequest) 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 {
+ m.IncludeSpecificDenominations = append(m.IncludeSpecificDenominations, &v16.Denom{})
+ if err := m.IncludeSpecificDenominations[len(m.IncludeSpecificDenominations)-1].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)
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field IncludeDelegationTokens", wireType)
}
- var msglen int
+ var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowView
@@ -12101,27 +15440,92 @@ func (m *NotesForVotingRequest) 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
+ m.IncludeDelegationTokens = bool(v != 0)
+ case 4:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field IncludeUnbondingTokens", wireType)
}
- postIndex := iNdEx + msglen
- if postIndex < 0 {
- return ErrInvalidLengthView
+ 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 postIndex > l {
- return io.ErrUnexpectedEOF
+ m.IncludeUnbondingTokens = bool(v != 0)
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field IncludeLpNfts", wireType)
}
- v := &v1alpha11.AccountGroupId{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
+ 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.XAccountGroupId = &NotesForVotingRequest_AccountGroupId{v}
- iNdEx = postIndex
+ m.IncludeLpNfts = bool(v != 0)
+ case 6:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field IncludeProposalNfts", 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.IncludeProposalNfts = bool(v != 0)
+ case 7:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field IncludeVotingReceiptTokens", 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.IncludeVotingReceiptTokens = bool(v != 0)
default:
iNdEx = preIndex
skippy, err := skipView(dAtA[iNdEx:])
@@ -12143,7 +15547,7 @@ func (m *NotesForVotingRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *WitnessRequest) Unmarshal(dAtA []byte) error {
+func (m *AssetsResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -12166,49 +15570,15 @@ func (m *WitnessRequest) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: WitnessRequest: wiretype end group for non-group")
+ return fmt.Errorf("proto: AssetsResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: WitnessRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ 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 NoteCommitments", 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.NoteCommitments = append(m.NoteCommitments, &v1alpha11.StateCommitment{})
- if err := m.NoteCommitments[len(m.NoteCommitments)-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 TransactionPlan", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field DenomMetadata", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12235,48 +15605,63 @@ func (m *WitnessRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.TransactionPlan == nil {
- m.TransactionPlan = &v1alpha1.TransactionPlan{}
+ if m.DenomMetadata == nil {
+ m.DenomMetadata = &v16.Metadata{}
}
- if err := m.TransactionPlan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.DenomMetadata.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
- }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipView(dAtA[iNdEx:])
+ if err != nil {
+ return err
}
- if msglen < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthView
}
- postIndex := iNdEx + msglen
- if postIndex < 0 {
- return ErrInvalidLengthView
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
}
- if postIndex > l {
+ 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 ErrIntOverflowView
+ }
+ if iNdEx >= l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha11.AccountGroupId{}
- 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.XAccountGroupId = &WitnessRequest_AccountGroupId{v}
- iNdEx = postIndex
+ }
+ 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 {
default:
iNdEx = preIndex
skippy, err := skipView(dAtA[iNdEx:])
@@ -12298,7 +15683,7 @@ func (m *WitnessRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *WitnessResponse) Unmarshal(dAtA []byte) error {
+func (m *AppParametersResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -12321,15 +15706,15 @@ func (m *WitnessResponse) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: WitnessResponse: wiretype end group for non-group")
+ return fmt.Errorf("proto: AppParametersResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: WitnessResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ 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 WitnessData", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Parameters", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12356,10 +15741,10 @@ func (m *WitnessResponse) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.WitnessData == nil {
- m.WitnessData = &v1alpha1.WitnessData{}
+ if m.Parameters == nil {
+ m.Parameters = &v111.AppParameters{}
}
- if err := m.WitnessData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.Parameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@@ -12384,7 +15769,7 @@ func (m *WitnessResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *WitnessAndBuildRequest) Unmarshal(dAtA []byte) error {
+func (m *GasPricesRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -12407,51 +15792,65 @@ func (m *WitnessAndBuildRequest) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: WitnessAndBuildRequest: wiretype end group for non-group")
+ return fmt.Errorf("proto: GasPricesRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: WitnessAndBuildRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: GasPricesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
- case 1:
- 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 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
+ default:
+ iNdEx = preIndex
+ skippy, err := skipView(dAtA[iNdEx:])
+ if err != nil {
+ return err
}
- postIndex := iNdEx + msglen
- if postIndex < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthView
}
- if postIndex > l {
+ if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
- if m.TransactionPlan == nil {
- m.TransactionPlan = &v1alpha1.TransactionPlan{}
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *GasPricesResponse) Unmarshal(dAtA []byte) 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 err := m.TransactionPlan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
}
- iNdEx = postIndex
- case 2:
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: GasPricesResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ 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 AuthorizationData", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field GasPrices", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12478,10 +15877,10 @@ func (m *WitnessAndBuildRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.AuthorizationData == nil {
- m.AuthorizationData = &v1alpha1.AuthorizationData{}
+ if m.GasPrices == nil {
+ m.GasPrices = &v14.GasPrices{}
}
- if err := m.AuthorizationData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.GasPrices.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@@ -12506,7 +15905,7 @@ func (m *WitnessAndBuildRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *WitnessAndBuildResponse) Unmarshal(dAtA []byte) error {
+func (m *FMDParametersRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -12529,48 +15928,12 @@ func (m *WitnessAndBuildResponse) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: WitnessAndBuildResponse: wiretype end group for non-group")
+ return fmt.Errorf("proto: FMDParametersRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: WitnessAndBuildResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: FMDParametersRequest: 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 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.Transaction == nil {
- m.Transaction = &v1alpha1.Transaction{}
- }
- if err := m.Transaction.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
- }
- iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipView(dAtA[iNdEx:])
@@ -12592,7 +15955,7 @@ func (m *WitnessAndBuildResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *AssetsRequest) Unmarshal(dAtA []byte) error {
+func (m *FMDParametersResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -12615,35 +15978,15 @@ func (m *AssetsRequest) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: AssetsRequest: wiretype end group for non-group")
+ return fmt.Errorf("proto: FMDParametersResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: AssetsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: FMDParametersResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field Filtered", 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.Filtered = bool(v != 0)
- case 2:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field IncludeSpecificDenominations", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Parameters", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12670,36 +16013,68 @@ func (m *AssetsRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- m.IncludeSpecificDenominations = append(m.IncludeSpecificDenominations, &v1alpha11.Denom{})
- if err := m.IncludeSpecificDenominations[len(m.IncludeSpecificDenominations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if m.Parameters == nil {
+ m.Parameters = &v112.FmdParameters{}
+ }
+ if err := m.Parameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
- case 3:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field IncludeDelegationTokens", wireType)
+ default:
+ iNdEx = preIndex
+ skippy, err := skipView(dAtA[iNdEx:])
+ if err != nil {
+ return err
}
- 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 (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 *NoteByCommitmentRequest) Unmarshal(dAtA []byte) 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
}
- m.IncludeDelegationTokens = bool(v != 0)
- case 4:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field IncludeUnbondingTokens", wireType)
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NoteByCommitmentRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NoteByCommitmentRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field NoteCommitment", wireType)
}
- var v int
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowView
@@ -12709,55 +16084,31 @@ 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.IncludeUnbondingTokens = bool(v != 0)
- case 5:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field IncludeLpNfts", wireType)
+ if msglen < 0 {
+ return ErrInvalidLengthView
}
- 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
- }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthView
}
- m.IncludeLpNfts = bool(v != 0)
- case 6:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field IncludeProposalNfts", wireType)
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
}
- 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 m.NoteCommitment == nil {
+ m.NoteCommitment = &v17.StateCommitment{}
}
- m.IncludeProposalNfts = bool(v != 0)
- case 7:
+ if err := m.NoteCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field IncludeVotingReceiptTokens", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field AwaitDetection", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
@@ -12774,7 +16125,7 @@ func (m *AssetsRequest) Unmarshal(dAtA []byte) error {
break
}
}
- m.IncludeVotingReceiptTokens = bool(v != 0)
+ m.AwaitDetection = bool(v != 0)
default:
iNdEx = preIndex
skippy, err := skipView(dAtA[iNdEx:])
@@ -12796,7 +16147,7 @@ func (m *AssetsRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *AssetsResponse) Unmarshal(dAtA []byte) error {
+func (m *NoteByCommitmentResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -12819,15 +16170,15 @@ 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: NoteByCommitmentResponse: 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: NoteByCommitmentResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
- case 2:
+ 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 SpendableNote", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12854,10 +16205,10 @@ func (m *AssetsResponse) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.DenomMetadata == nil {
- m.DenomMetadata = &v1alpha11.DenomMetadata{}
+ if m.SpendableNote == nil {
+ m.SpendableNote = &SpendableNoteRecord{}
}
- if err := m.DenomMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.SpendableNote.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@@ -12882,7 +16233,7 @@ func (m *AssetsResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *ChainParametersRequest) Unmarshal(dAtA []byte) error {
+func (m *SwapByCommitmentRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -12905,12 +16256,68 @@ 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: SwapByCommitmentRequest: 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: SwapByCommitmentRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
+ case 2:
+ 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 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.SwapCommitment == nil {
+ m.SwapCommitment = &v17.StateCommitment{}
+ }
+ if err := m.SwapCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field AwaitDetection", 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.AwaitDetection = bool(v != 0)
default:
iNdEx = preIndex
skippy, err := skipView(dAtA[iNdEx:])
@@ -12932,7 +16339,7 @@ func (m *ChainParametersRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *ChainParametersResponse) Unmarshal(dAtA []byte) error {
+func (m *SwapByCommitmentResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -12955,15 +16362,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: SwapByCommitmentResponse: 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: 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 Parameters", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -12990,10 +16397,10 @@ func (m *ChainParametersResponse) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Parameters == nil {
- m.Parameters = &v1alpha14.ChainParameters{}
+ if m.Swap == nil {
+ m.Swap = &SwapRecord{}
}
- if err := m.Parameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.Swap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@@ -13018,7 +16425,7 @@ func (m *ChainParametersResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *FMDParametersRequest) Unmarshal(dAtA []byte) error {
+func (m *UnclaimedSwapsRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -13041,10 +16448,10 @@ func (m *FMDParametersRequest) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: FMDParametersRequest: wiretype end group for non-group")
+ return fmt.Errorf("proto: UnclaimedSwapsRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: FMDParametersRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: UnclaimedSwapsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
default:
@@ -13068,7 +16475,7 @@ func (m *FMDParametersRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *FMDParametersResponse) Unmarshal(dAtA []byte) error {
+func (m *UnclaimedSwapsResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -13091,15 +16498,15 @@ func (m *FMDParametersResponse) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: FMDParametersResponse: wiretype end group for non-group")
+ return fmt.Errorf("proto: UnclaimedSwapsResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: FMDParametersResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: UnclaimedSwapsResponse: 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 Swap", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -13126,10 +16533,10 @@ func (m *FMDParametersResponse) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Parameters == nil {
- m.Parameters = &v1alpha14.FmdParameters{}
+ if m.Swap == nil {
+ m.Swap = &SwapRecord{}
}
- if err := m.Parameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.Swap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@@ -13154,7 +16561,7 @@ func (m *FMDParametersResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *NoteByCommitmentRequest) Unmarshal(dAtA []byte) error {
+func (m *NullifierStatusRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -13177,15 +16584,15 @@ func (m *NoteByCommitmentRequest) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: NoteByCommitmentRequest: wiretype end group for non-group")
+ return fmt.Errorf("proto: NullifierStatusRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: NoteByCommitmentRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: NullifierStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 2:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field NoteCommitment", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Nullifier", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -13212,10 +16619,10 @@ func (m *NoteByCommitmentRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.NoteCommitment == nil {
- m.NoteCommitment = &v1alpha11.StateCommitment{}
+ if m.Nullifier == nil {
+ m.Nullifier = &v15.Nullifier{}
}
- if err := m.NoteCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.Nullifier.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@@ -13239,41 +16646,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:])
@@ -13295,7 +16667,7 @@ func (m *NoteByCommitmentRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *NoteByCommitmentResponse) Unmarshal(dAtA []byte) error {
+func (m *NullifierStatusResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -13318,48 +16690,32 @@ func (m *NoteByCommitmentResponse) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: NoteByCommitmentResponse: wiretype end group for non-group")
+ return fmt.Errorf("proto: NullifierStatusResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: NoteByCommitmentResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: NullifierStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field SpendableNote", wireType)
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Spent", wireType)
}
- var msglen 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++
- 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.SpendableNote == nil {
- m.SpendableNote = &SpendableNoteRecord{}
- }
- if err := m.SpendableNote.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ v |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
}
- iNdEx = postIndex
+ m.Spent = bool(v != 0)
default:
iNdEx = preIndex
skippy, err := skipView(dAtA[iNdEx:])
@@ -13381,7 +16737,7 @@ func (m *NoteByCommitmentResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *SwapByCommitmentRequest) Unmarshal(dAtA []byte) error {
+func (m *TransactionInfoByHashRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -13404,15 +16760,15 @@ func (m *SwapByCommitmentRequest) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: SwapByCommitmentRequest: wiretype end group for non-group")
+ return fmt.Errorf("proto: TransactionInfoByHashRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: SwapByCommitmentRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: TransactionInfoByHashRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 2:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field SwapCommitment", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -13439,67 +16795,12 @@ func (m *SwapByCommitmentRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.SwapCommitment == nil {
- m.SwapCommitment = &v1alpha11.StateCommitment{}
- }
- if err := m.SwapCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
- }
- iNdEx = postIndex
- case 3:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field AwaitDetection", 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.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
+ if m.Id == nil {
+ m.Id = &v11.TransactionId{}
}
- v := &v1alpha11.AccountGroupId{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.XAccountGroupId = &SwapByCommitmentRequest_AccountGroupId{v}
iNdEx = postIndex
default:
iNdEx = preIndex
@@ -13522,7 +16823,7 @@ func (m *SwapByCommitmentRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *SwapByCommitmentResponse) Unmarshal(dAtA []byte) error {
+func (m *TransactionInfoRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -13545,17 +16846,17 @@ 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: TransactionInfoRequest: 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: TransactionInfoRequest: 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)
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field StartHeight", wireType)
}
- var msglen int
+ m.StartHeight = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowView
@@ -13565,28 +16866,30 @@ func (m *SwapByCommitmentResponse) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- msglen |= int(b&0x7F) << shift
+ m.StartHeight |= uint64(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.Swap == nil {
- m.Swap = &SwapRecord{}
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field EndHeight", wireType)
}
- if err := m.Swap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
+ m.EndHeight = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowView
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.EndHeight |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
}
- iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipView(dAtA[iNdEx:])
@@ -13608,7 +16911,7 @@ func (m *SwapByCommitmentResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *NullifierStatusRequest) Unmarshal(dAtA []byte) error {
+func (m *TransactionInfo) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -13631,15 +16934,34 @@ func (m *NullifierStatusRequest) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: NullifierStatusRequest: wiretype end group for non-group")
+ return fmt.Errorf("proto: TransactionInfo: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: NullifierStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: TransactionInfo: 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 ErrIntOverflowView
+ }
+ 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 Nullifier", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -13666,18 +16988,18 @@ func (m *NullifierStatusRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Nullifier == nil {
- m.Nullifier = &v1alpha11.Nullifier{}
+ if m.Id == nil {
+ m.Id = &v11.TransactionId{}
}
- if err := m.Nullifier.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field AwaitDetection", wireType)
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Transaction", wireType)
}
- var v int
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowView
@@ -13687,15 +17009,31 @@ func (m *NullifierStatusRequest) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- v |= int(b&0x7F) << shift
+ msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
- m.AwaitDetection = bool(v != 0)
- case 14:
+ if msglen < 0 {
+ return ErrInvalidLengthView
+ }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthView
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Transaction == nil {
+ m.Transaction = &v1.Transaction{}
+ }
+ if err := m.Transaction.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ 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 Perspective", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -13722,67 +17060,18 @@ func (m *NullifierStatusRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- v := &v1alpha11.AccountGroupId{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
+ if m.Perspective == nil {
+ m.Perspective = &v1.TransactionPerspective{}
}
- m.XAccountGroupId = &NullifierStatusRequest_AccountGroupId{v}
- iNdEx = postIndex
- default:
- iNdEx = preIndex
- skippy, err := skipView(dAtA[iNdEx:])
- if err != nil {
+ if err := m.Perspective.Unmarshal(dAtA[iNdEx:postIndex]); 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 *NullifierStatusResponse) Unmarshal(dAtA []byte) 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: NullifierStatusResponse: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: NullifierStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
- }
- switch fieldNum {
- case 1:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field Spent", wireType)
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field View", wireType)
}
- var v int
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowView
@@ -13792,12 +17081,28 @@ func (m *NullifierStatusResponse) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- v |= int(b&0x7F) << shift
+ msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
- m.Spent = bool(v != 0)
+ if msglen < 0 {
+ return ErrInvalidLengthView
+ }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthView
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.View == nil {
+ m.View = &v1.TransactionView{}
+ }
+ if err := m.View.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipView(dAtA[iNdEx:])
@@ -13819,7 +17124,7 @@ func (m *NullifierStatusResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *TransactionInfoByHashRequest) Unmarshal(dAtA []byte) error {
+func (m *TransactionInfoResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -13842,15 +17147,15 @@ func (m *TransactionInfoByHashRequest) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: TransactionInfoByHashRequest: wiretype end group for non-group")
+ return fmt.Errorf("proto: TransactionInfoResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: TransactionInfoByHashRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: TransactionInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
- case 2:
+ case 1:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field TxInfo", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -13877,10 +17182,10 @@ func (m *TransactionInfoByHashRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Id == nil {
- m.Id = &v1alpha1.Id{}
+ if m.TxInfo == nil {
+ m.TxInfo = &TransactionInfo{}
}
- if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.TxInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@@ -13905,7 +17210,7 @@ func (m *TransactionInfoByHashRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *TransactionInfoRequest) Unmarshal(dAtA []byte) error {
+func (m *TransactionInfoByHashResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -13928,17 +17233,17 @@ func (m *TransactionInfoRequest) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: TransactionInfoRequest: wiretype end group for non-group")
+ return fmt.Errorf("proto: TransactionInfoByHashResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: TransactionInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: TransactionInfoByHashResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field StartHeight", wireType)
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field TxInfo", wireType)
}
- var v uint64
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowView
@@ -13948,32 +17253,28 @@ func (m *TransactionInfoRequest) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- v |= uint64(b&0x7F) << shift
+ msglen |= int(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)
+ if msglen < 0 {
+ return ErrInvalidLengthView
}
- var v uint64
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowView
- }
- 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 ErrInvalidLengthView
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
}
- m.XEndHeight = &TransactionInfoRequest_EndHeight{v}
+ if m.TxInfo == nil {
+ m.TxInfo = &TransactionInfo{}
+ }
+ if err := m.TxInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipView(dAtA[iNdEx:])
@@ -13995,7 +17296,7 @@ func (m *TransactionInfoRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *TransactionInfo) Unmarshal(dAtA []byte) error {
+func (m *NotesResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -14018,35 +17319,15 @@ func (m *TransactionInfo) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: TransactionInfo: wiretype end group for non-group")
+ return fmt.Errorf("proto: NotesResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: TransactionInfo: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: NotesResponse: 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)
- }
- var v uint64
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowView
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- v |= 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)
+ return fmt.Errorf("proto: wrong wireType = %d for field NoteRecord", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -14073,52 +17354,66 @@ func (m *TransactionInfo) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Id == nil {
- m.Id = &v1alpha1.Id{}
+ if m.NoteRecord == nil {
+ m.NoteRecord = &SpendableNoteRecord{}
}
- if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.NoteRecord.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
- case 3:
- 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 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
+ default:
+ iNdEx = preIndex
+ skippy, err := skipView(dAtA[iNdEx:])
+ if err != nil {
+ return err
}
- postIndex := iNdEx + msglen
- if postIndex < 0 {
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthView
}
- if postIndex > l {
+ if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
- if m.Transaction == nil {
- m.Transaction = &v1alpha1.Transaction{}
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *NotesForVotingResponse) Unmarshal(dAtA []byte) 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 err := m.Transaction.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
}
- iNdEx = postIndex
- case 4:
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: NotesForVotingResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: NotesForVotingResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field Perspective", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field NoteRecord", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -14145,16 +17440,16 @@ func (m *TransactionInfo) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Perspective == nil {
- m.Perspective = &v1alpha1.TransactionPerspective{}
+ if m.NoteRecord == nil {
+ m.NoteRecord = &SpendableNoteRecord{}
}
- if err := m.Perspective.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.NoteRecord.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 View", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -14181,10 +17476,10 @@ func (m *TransactionInfo) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.View == nil {
- m.View = &v1alpha1.TransactionView{}
+ if m.IdentityKey == nil {
+ m.IdentityKey = &v12.IdentityKey{}
}
- if err := m.View.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@@ -14209,7 +17504,7 @@ func (m *TransactionInfo) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *TransactionInfoResponse) Unmarshal(dAtA []byte) error {
+func (m *SpendableNoteRecord) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -14232,15 +17527,15 @@ func (m *TransactionInfoResponse) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: TransactionInfoResponse: wiretype end group for non-group")
+ return fmt.Errorf("proto: SpendableNoteRecord: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: TransactionInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: SpendableNoteRecord: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field TxInfo", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field NoteCommitment", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -14267,66 +17562,52 @@ func (m *TransactionInfoResponse) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.TxInfo == nil {
- m.TxInfo = &TransactionInfo{}
+ if m.NoteCommitment == nil {
+ m.NoteCommitment = &v17.StateCommitment{}
}
- if err := m.TxInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.NoteCommitment.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
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Note", wireType)
}
- iNdEx += skippy
- }
- }
-
- if iNdEx > l {
- return io.ErrUnexpectedEOF
- }
- return nil
-}
-func (m *TransactionInfoByHashResponse) Unmarshal(dAtA []byte) 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
+ 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 iNdEx >= l {
- return io.ErrUnexpectedEOF
+ if msglen < 0 {
+ return ErrInvalidLengthView
}
- b := dAtA[iNdEx]
- iNdEx++
- wire |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthView
}
- }
- fieldNum := int32(wire >> 3)
- wireType := int(wire & 0x7)
- if wireType == 4 {
- return fmt.Errorf("proto: TransactionInfoByHashResponse: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: TransactionInfoByHashResponse: illegal tag %d (wire type %d)", fieldNum, wire)
- }
- switch fieldNum {
- case 1:
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.Note == nil {
+ m.Note = &v112.Note{}
+ }
+ 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 TxInfo", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field AddressIndex", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -14353,66 +17634,16 @@ func (m *TransactionInfoByHashResponse) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.TxInfo == nil {
- m.TxInfo = &TransactionInfo{}
+ if m.AddressIndex == nil {
+ m.AddressIndex = &v12.AddressIndex{}
}
- if err := m.TxInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.AddressIndex.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 *NotesResponse) Unmarshal(dAtA []byte) 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: NotesResponse: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: NotesResponse: 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 NoteRecord", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Nullifier", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -14439,66 +17670,73 @@ func (m *NotesResponse) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.NoteRecord == nil {
- m.NoteRecord = &SpendableNoteRecord{}
+ if m.Nullifier == nil {
+ m.Nullifier = &v15.Nullifier{}
}
- if err := m.NoteRecord.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.Nullifier.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
- default:
- iNdEx = preIndex
- skippy, err := skipView(dAtA[iNdEx:])
- if err != nil {
- return err
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field HeightCreated", wireType)
}
- if (skippy < 0) || (iNdEx+skippy) < 0 {
- return ErrInvalidLengthView
+ m.HeightCreated = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowView
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.HeightCreated |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
}
- if (iNdEx + skippy) > l {
- return io.ErrUnexpectedEOF
+ case 6:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field HeightSpent", wireType)
}
- iNdEx += skippy
- }
- }
-
- if iNdEx > l {
- return io.ErrUnexpectedEOF
- }
- return nil
-}
-func (m *NotesForVotingResponse) Unmarshal(dAtA []byte) 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
+ m.HeightSpent = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowView
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.HeightSpent |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
}
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
+ case 7:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
}
- b := dAtA[iNdEx]
- iNdEx++
- wire |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
+ m.Position = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowView
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.Position |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
}
- }
- fieldNum := int32(wire >> 3)
- wireType := int(wire & 0x7)
- if wireType == 4 {
- return fmt.Errorf("proto: NotesForVotingResponse: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: NotesForVotingResponse: illegal tag %d (wire type %d)", fieldNum, wire)
- }
- switch fieldNum {
- case 1:
+ case 8:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field NoteRecord", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -14525,16 +17763,16 @@ func (m *NotesForVotingResponse) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.NoteRecord == nil {
- m.NoteRecord = &SpendableNoteRecord{}
+ if m.Source == nil {
+ m.Source = &v15.CommitmentSource{}
}
- if err := m.NoteRecord.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
- case 2:
+ case 9:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field ReturnAddress", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -14561,10 +17799,10 @@ func (m *NotesForVotingResponse) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.IdentityKey == nil {
- m.IdentityKey = &v1alpha11.IdentityKey{}
+ if m.ReturnAddress == nil {
+ m.ReturnAddress = &v12.AddressView{}
}
- if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.ReturnAddress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@@ -14589,7 +17827,7 @@ func (m *NotesForVotingResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *SpendableNoteRecord) Unmarshal(dAtA []byte) error {
+func (m *SwapRecord) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -14612,15 +17850,15 @@ func (m *SpendableNoteRecord) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: SpendableNoteRecord: wiretype end group for non-group")
+ return fmt.Errorf("proto: SwapRecord: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: SpendableNoteRecord: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: SwapRecord: 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)
+ return fmt.Errorf("proto: wrong wireType = %d for field SwapCommitment", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -14647,16 +17885,16 @@ func (m *SpendableNoteRecord) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.NoteCommitment == nil {
- m.NoteCommitment = &v1alpha11.StateCommitment{}
+ if m.SwapCommitment == nil {
+ m.SwapCommitment = &v17.StateCommitment{}
}
- if err := m.NoteCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.SwapCommitment.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)
+ return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -14683,18 +17921,18 @@ func (m *SpendableNoteRecord) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Note == nil {
- m.Note = &v1alpha11.Note{}
+ if m.Swap == nil {
+ m.Swap = &v110.SwapPlaintext{}
}
- if err := m.Note.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ 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 AddressIndex", wireType)
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
}
- var msglen int
+ m.Position = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowView
@@ -14704,28 +17942,11 @@ func (m *SpendableNoteRecord) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- msglen |= int(b&0x7F) << shift
+ m.Position |= uint64(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.AddressIndex == nil {
- m.AddressIndex = &v1alpha11.AddressIndex{}
- }
- if err := m.AddressIndex.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)
@@ -14756,17 +17977,17 @@ func (m *SpendableNoteRecord) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.Nullifier == nil {
- m.Nullifier = &v1alpha11.Nullifier{}
+ m.Nullifier = &v15.Nullifier{}
}
if err := m.Nullifier.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 5:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field HeightCreated", wireType)
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field OutputData", wireType)
}
- m.HeightCreated = 0
+ var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowView
@@ -14776,36 +17997,33 @@ func (m *SpendableNoteRecord) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- m.HeightCreated |= uint64(b&0x7F) << shift
+ msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
- case 6:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field HeightSpent", wireType)
+ if msglen < 0 {
+ return ErrInvalidLengthView
}
- var v uint64
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowView
- }
- 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 ErrInvalidLengthView
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.OutputData == nil {
+ m.OutputData = &v110.BatchSwapOutputData{}
}
- m.XHeightSpent = &SpendableNoteRecord_HeightSpent{v}
- case 7:
+ if err := m.OutputData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 6:
if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field HeightClaimed", wireType)
}
- m.Position = 0
+ m.HeightClaimed = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowView
@@ -14815,12 +18033,12 @@ func (m *SpendableNoteRecord) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- m.Position |= uint64(b&0x7F) << shift
+ m.HeightClaimed |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
- case 8:
+ case 7:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
}
@@ -14850,7 +18068,7 @@ func (m *SpendableNoteRecord) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.Source == nil {
- m.Source = &v1alpha14.NoteSource{}
+ m.Source = &v15.CommitmentSource{}
}
if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@@ -14877,7 +18095,7 @@ func (m *SpendableNoteRecord) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *SwapRecord) Unmarshal(dAtA []byte) error {
+func (m *OwnedPositionIdsRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -14900,15 +18118,15 @@ func (m *SwapRecord) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: SwapRecord: wiretype end group for non-group")
+ return fmt.Errorf("proto: OwnedPositionIdsRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: SwapRecord: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: OwnedPositionIdsRequest: 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 PositionState", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -14935,16 +18153,16 @@ func (m *SwapRecord) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.SwapCommitment == nil {
- m.SwapCommitment = &v1alpha11.StateCommitment{}
+ if m.PositionState == nil {
+ m.PositionState = &v110.PositionState{}
}
- if err := m.SwapCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.PositionState.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)
+ return fmt.Errorf("proto: wrong wireType = %d for field TradingPair", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -14971,35 +18189,66 @@ func (m *SwapRecord) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Swap == nil {
- m.Swap = &v1alpha15.SwapPlaintext{}
+ if m.TradingPair == nil {
+ m.TradingPair = &v110.TradingPair{}
}
- if err := m.Swap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.TradingPair.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
- case 3:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
+ default:
+ iNdEx = preIndex
+ skippy, err := skipView(dAtA[iNdEx:])
+ if err != nil {
+ return err
}
- m.Position = 0
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowView
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- m.Position |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthView
}
- case 4:
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *OwnedPositionIdsResponse) Unmarshal(dAtA []byte) 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: OwnedPositionIdsResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: OwnedPositionIdsResponse: 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)
+ return fmt.Errorf("proto: wrong wireType = %d for field PositionId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -15026,16 +18275,66 @@ func (m *SwapRecord) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Nullifier == nil {
- m.Nullifier = &v1alpha11.Nullifier{}
+ if m.PositionId == nil {
+ m.PositionId = &v110.PositionId{}
}
- if err := m.Nullifier.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.PositionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
- case 5:
+ 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 *AssetMetadataByIdRequest) Unmarshal(dAtA []byte) 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: AssetMetadataByIdRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: AssetMetadataByIdRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 2:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field OutputData", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field AssetId", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -15062,36 +18361,66 @@ func (m *SwapRecord) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.OutputData == nil {
- m.OutputData = &v1alpha15.BatchSwapOutputData{}
+ if m.AssetId == nil {
+ m.AssetId = &v16.AssetId{}
}
- if err := m.OutputData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.AssetId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
- case 6:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field HeightClaimed", wireType)
+ default:
+ iNdEx = preIndex
+ skippy, err := skipView(dAtA[iNdEx:])
+ if err != nil {
+ return err
}
- var v uint64
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowView
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- v |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthView
}
- m.XHeightClaimed = &SwapRecord_HeightClaimed{v}
- case 7:
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *AssetMetadataByIdResponse) Unmarshal(dAtA []byte) 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: AssetMetadataByIdResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: AssetMetadataByIdResponse: 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)
+ return fmt.Errorf("proto: wrong wireType = %d for field DenomMetadata", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -15118,10 +18447,10 @@ func (m *SwapRecord) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.Source == nil {
- m.Source = &v1alpha14.NoteSource{}
+ if m.DenomMetadata == nil {
+ m.DenomMetadata = &v16.Metadata{}
}
- if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.DenomMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@@ -15146,7 +18475,7 @@ func (m *SwapRecord) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *OwnedPositionIdsRequest) Unmarshal(dAtA []byte) error {
+func (m *DelegationsByAddressIndexRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -15169,15 +18498,15 @@ func (m *OwnedPositionIdsRequest) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: OwnedPositionIdsRequest: wiretype end group for non-group")
+ return fmt.Errorf("proto: DelegationsByAddressIndexRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: OwnedPositionIdsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: DelegationsByAddressIndexRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field PositionState", wireType)
+ return fmt.Errorf("proto: wrong wireType = %d for field AddressIndex", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -15204,17 +18533,18 @@ 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.AddressIndex == nil {
+ m.AddressIndex = &v12.AddressIndex{}
+ }
+ if err := m.AddressIndex.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
- m.XPositionState = &OwnedPositionIdsRequest_PositionState{v}
iNdEx = postIndex
case 2:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field TradingPair", wireType)
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Filter", wireType)
}
- var msglen int
+ m.Filter = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowView
@@ -15224,27 +18554,11 @@ func (m *OwnedPositionIdsRequest) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
- msglen |= int(b&0x7F) << shift
+ m.Filter |= DelegationsByAddressIndexRequest_Filter(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 := &v1alpha15.TradingPair{}
- if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
- }
- m.XTradingPair = &OwnedPositionIdsRequest_TradingPair{v}
- iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipView(dAtA[iNdEx:])
@@ -15266,7 +18580,7 @@ func (m *OwnedPositionIdsRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
-func (m *OwnedPositionIdsResponse) Unmarshal(dAtA []byte) error {
+func (m *DelegationsByAddressIndexResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -15289,15 +18603,15 @@ func (m *OwnedPositionIdsResponse) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
- return fmt.Errorf("proto: OwnedPositionIdsResponse: wiretype end group for non-group")
+ return fmt.Errorf("proto: DelegationsByAddressIndexResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
- return fmt.Errorf("proto: OwnedPositionIdsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ return fmt.Errorf("proto: DelegationsByAddressIndexResponse: 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)
+ return fmt.Errorf("proto: wrong wireType = %d for field ValueView", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@@ -15324,10 +18638,10 @@ func (m *OwnedPositionIdsResponse) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
- if m.PositionId == nil {
- m.PositionId = &v1alpha15.PositionId{}
+ if m.ValueView == nil {
+ m.ValueView = &v16.ValueView{}
}
- if err := m.PositionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ if err := m.ValueView.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
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..0ad34b1bc 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)
@@ -263,8 +284,9 @@ func MsgUpdateClient(
dstClientState, err = dst.ChainProvider.QueryClientState(ctx, dsth, dst.ClientID())
return err
}, retry.Context(ctx), RtyAtt, RtyDel, RtyErr, retry.OnRetry(func(n uint, err error) {
- dst.log.Info(
+ dst.log.Error(
"Failed to query client state when updating clients",
+ zap.String("chain_id", dst.ChainID()),
zap.String("client_id", dst.ClientID()),
zap.Uint("attempt", n+1),
zap.Uint("max_attempts", RtyAttNum),
@@ -280,12 +302,20 @@ func MsgUpdateClient(
eg.Go(func() error {
return retry.Do(func() error {
var err error
+ src.log.Debug(
+ "Query IBC header",
+ zap.String("chain_id", src.ChainID()),
+ zap.String("client_id", src.ClientID()),
+ zap.Int64("height", srch),
+ )
srcHeader, err = src.ChainProvider.QueryIBCHeader(egCtx, srch)
return err
}, retry.Context(egCtx), RtyAtt, RtyDel, RtyErr, retry.OnRetry(func(n uint, err error) {
- src.log.Info(
+ src.log.Error(
"Failed to query IBC header when building update client message",
- zap.String("client_id", dst.ClientID()),
+ zap.String("chain_id", src.ChainID()),
+ zap.String("client_id", src.ClientID()),
+ zap.Int64("height", srch),
zap.Uint("attempt", n+1),
zap.Uint("max_attempts", RtyAttNum),
zap.Error(err),
@@ -295,12 +325,20 @@ func MsgUpdateClient(
eg.Go(func() error {
return retry.Do(func() error {
var err error
+ src.log.Debug(
+ "Query IBC header",
+ zap.String("chain_id", src.ChainID()),
+ zap.String("client_id", src.ClientID()),
+ zap.Int64("height", int64(dstClientState.GetLatestHeight().GetRevisionHeight())+1),
+ )
dstTrustedHeader, err = src.ChainProvider.QueryIBCHeader(egCtx, int64(dstClientState.GetLatestHeight().GetRevisionHeight())+1)
return err
}, retry.Context(egCtx), RtyAtt, RtyDel, RtyErr, retry.OnRetry(func(n uint, err error) {
- src.log.Info(
+ src.log.Error(
"Failed to query IBC header when building update client message",
- zap.String("client_id", dst.ClientID()),
+ zap.String("chain_id", src.ChainID()),
+ zap.String("client_id", src.ClientID()),
+ zap.Int64("height", int64(dstClientState.GetLatestHeight().GetRevisionHeight())+1),
zap.Uint("attempt", n+1),
zap.Uint("max_attempts", RtyAttNum),
zap.Error(err),
@@ -456,7 +494,7 @@ func UpgradeClient(
return nil
}
-// MustGetHeight takes the height inteface and returns the actual height
+// MustGetHeight takes the height interface and returns the actual height
func MustGetHeight(h ibcexported.Height) clienttypes.Height {
height, ok := h.(clienttypes.Height)
if !ok {
@@ -525,6 +563,7 @@ func parseClientIDFromEvents(events []provider.RelayerEvent) (string, error) {
}
}
}
+
return "", fmt.Errorf("client identifier event attribute not found")
}
@@ -532,6 +571,7 @@ type ClientStateInfo struct {
ChainID string
TrustingPeriod time.Duration
LatestHeight ibcexported.Height
+ UnbondingTime time.Duration
}
func ClientInfoFromClientState(clientState *codectypes.Any) (ClientStateInfo, error) {
@@ -546,6 +586,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/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/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/chain_processor.go b/relayer/processor/chain_processor.go
index aaccbd06d..86ae75deb 100644
--- a/relayer/processor/chain_processor.go
+++ b/relayer/processor/chain_processor.go
@@ -6,7 +6,7 @@ import (
"github.com/cosmos/relayer/v2/relayer/provider"
)
-// The ChainProcessor interface is reponsible for polling blocks and emitting IBC message events to the PathProcessors.
+// The ChainProcessor interface is responsible for polling blocks and emitting IBC message events to the PathProcessors.
// It is also responsible for tracking open channels and not sending messages to the PathProcessors for closed channels.
type ChainProcessor interface {
// Run starts the query loop for the chain which will gather applicable ibc messages and push events out to the relevant PathProcessors.
diff --git a/relayer/processor/message_processor.go b/relayer/processor/message_processor.go
index c73bab303..602c588c8 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"
@@ -34,8 +34,14 @@ type messageProcessor struct {
isLocalhost bool
}
-// 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}
+// categories of tx errors for a Prometheus counter. If the error doesn't fall into one of the below categories, it is labeled as "Tx Failure"
+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..37c6b9c74 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{
@@ -90,7 +101,7 @@ func NewPrometheusMetrics() *PrometheusMetrics {
}, walletLabels),
TxFailureError: registerer.NewCounterVec(prometheus.CounterOpts{
Name: "cosmos_relayer_tx_errors_total",
- Help: "The total number of tx failures broken up into categories. See https://github.com/cosmos/relayer/blob/main/docs/advanced_usage.md#monitoring for list of catagories. 'Tx Failure' is the catch-all category",
+ Help: "The total number of tx failures broken up into categories. See https://github.com/cosmos/relayer/blob/main/docs/advanced_usage.md#monitoring for list of categories. 'Tx Failure' is the catch-all category",
}, txFailureLabels),
BlockQueryFailure: registerer.NewCounterVec(prometheus.CounterOpts{
Name: "cosmos_relayer_block_query_errors_total",
@@ -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..7e3125f85 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 = "transfer"
+ 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 section 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 section 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..a6e31bd60 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
}
@@ -297,7 +296,12 @@ func (pp *PathProcessor) HandleNewData(chainID string, cacheData ChainProcessorC
func (pp *PathProcessor) handleFlush(ctx context.Context) {
flushTimer := pp.flushInterval
if err := pp.flush(ctx); err != nil {
- pp.log.Warn("Flush not complete", zap.Error(err))
+ pp.log.Warn("Flush not complete",
+ zap.String("chain_id_1", pp.pathEnd1.chainProvider.ChainId()),
+ zap.String("client_id_1", pp.pathEnd1.info.ClientID),
+ zap.String("chain_id_2", pp.pathEnd2.chainProvider.ChainId()),
+ zap.String("client_id_2", pp.pathEnd2.info.ClientID),
+ zap.Error(err))
flushTimer = flushFailureRetry
}
pp.flushTimer.Stop()
@@ -317,17 +321,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 +404,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 60d10b19c..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),
@@ -674,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
}
}
@@ -692,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
}
@@ -1006,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,
@@ -1017,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)
@@ -1223,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
}
@@ -1233,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
@@ -1272,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
@@ -1346,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
@@ -1428,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,
@@ -1441,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,
@@ -1481,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
})
}
@@ -1500,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..24f91032d 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,16 +73,8 @@ 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)
+ return nil, fmt.Errorf("unexpected packet message eventType for message assembly: %s", msg.eventType)
}
if src.clientState.ClientID == ibcexported.LocalhostClientID {
packetProof = src.localhostSentinelProofPacket
@@ -173,7 +166,7 @@ func (msg channelIBCMessage) assemble(
chanProof = src.chainProvider.ChannelProof
assembleMessage = dst.chainProvider.MsgChannelCloseConfirm
default:
- return nil, fmt.Errorf("unexepected channel message eventType for message assembly: %s", msg.eventType)
+ return nil, fmt.Errorf("unexpected channel message eventType for message assembly: %s", msg.eventType)
}
if src.clientState.ClientID == ibcexported.LocalhostClientID {
chanProof = src.localhostSentinelProofChannel
@@ -249,7 +242,7 @@ func (msg connectionIBCMessage) assemble(
connProof = src.chainProvider.ConnectionProof
assembleMessage = dst.chainProvider.MsgConnectionOpenConfirm
default:
- return nil, fmt.Errorf("unexepected connection message eventType for message assembly: %s", msg.eventType)
+ return nil, fmt.Errorf("unexpected connection message eventType for message assembly: %s", msg.eventType)
}
var proof provider.ConnectionProof
@@ -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..01be3b9cf 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)
@@ -468,6 +468,7 @@ type QueryProvider interface {
// ics 20 - transfer
QueryDenomTrace(ctx context.Context, denom string) (*transfertypes.DenomTrace, error)
QueryDenomTraces(ctx context.Context, offset, limit uint64, height int64) ([]transfertypes.DenomTrace, error)
+ QueryDenomHash(ctx context.Context, trace string) (string, error)
}
type RelayPacket interface {
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..23e55fdad 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
@@ -120,7 +124,7 @@ func (r SendMsgsResult) PartiallySent() bool {
(r.SrcSendError != nil || r.DstSendError != nil)
}
-// Error returns any accumulated erors that occurred while sending messages.
+// Error returns any accumulated errors that occurred while sending messages.
func (r SendMsgsResult) Error() error {
return multierr.Append(r.SrcSendError, r.DstSendError)
}
@@ -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