From b905769a7fc2222034d194ac2d0e811b0ea03e30 Mon Sep 17 00:00:00 2001 From: Gjermund Garaba Date: Tue, 26 Nov 2024 19:18:00 +0100 Subject: [PATCH 1/6] feat: create 08-wasm-light-clients structure --- .github/workflows/wasm-light-clients.yml | 60 + .gitignore | 4 + Makefile | 15 + .../08-wasm-light-clients/.cargo/config.toml | 3 + .../08-wasm-light-clients/Cargo.lock | 1265 +++++++++++++ .../08-wasm-light-clients/Cargo.toml | 39 + .../08-wasm-light-clients/README.md | 3 + .../ethereum-light-client/Cargo.toml | 22 + .../ethereum-light-client/src/contract.rs | 299 +++ .../ethereum-light-client/src/error.rs | 11 + .../ethereum-light-client/src/lib.rs | 4 + .../ethereum-light-client/src/msg.rs | 152 ++ .../ethereum-light-client/src/state.rs | 19 + .../packages/ibc-go-proto/Cargo.toml | 11 + .../src/ibc.applications.fee.v1.rs | 587 ++++++ ...tions.interchain_accounts.controller.v1.rs | 147 ++ ...ications.interchain_accounts.genesis.v1.rs | 83 + ...pplications.interchain_accounts.host.v1.rs | 114 ++ ...ibc.applications.interchain_accounts.v1.rs | 101 + .../src/ibc.applications.transfer.v1.rs | 304 +++ .../src/ibc.applications.transfer.v2.rs | 193 ++ .../ibc-go-proto/src/ibc.core.channel.v1.rs | 1645 +++++++++++++++++ .../ibc-go-proto/src/ibc.core.channel.v2.rs | 675 +++++++ .../ibc-go-proto/src/ibc.core.client.v1.rs | 668 +++++++ .../src/ibc.core.commitment.v1.rs | 43 + .../src/ibc.core.commitment.v2.rs | 16 + .../src/ibc.core.connection.v1.rs | 584 ++++++ .../ibc-go-proto/src/ibc.core.types.v1.rs | 21 + .../src/ibc.lightclients.solomachine.v2.rs | 323 ++++ .../src/ibc.lightclients.solomachine.v3.rs | 146 ++ .../src/ibc.lightclients.tendermint.v1.rs | 131 ++ .../src/ibc.lightclients.wasm.v1.rs | 213 +++ .../packages/ibc-go-proto/src/lib.rs | 127 ++ proto/buf.gen.prost.yaml | 16 + scripts/protocgen.sh | 11 + 35 files changed, 8055 insertions(+) create mode 100644 .github/workflows/wasm-light-clients.yml create mode 100644 modules/light-clients/08-wasm-light-clients/.cargo/config.toml create mode 100644 modules/light-clients/08-wasm-light-clients/Cargo.lock create mode 100644 modules/light-clients/08-wasm-light-clients/Cargo.toml create mode 100644 modules/light-clients/08-wasm-light-clients/README.md create mode 100644 modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/Cargo.toml create mode 100644 modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/contract.rs create mode 100644 modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/error.rs create mode 100644 modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/lib.rs create mode 100644 modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/msg.rs create mode 100644 modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/state.rs create mode 100644 modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/Cargo.toml create mode 100644 modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.fee.v1.rs create mode 100644 modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.interchain_accounts.controller.v1.rs create mode 100644 modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.interchain_accounts.genesis.v1.rs create mode 100644 modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.interchain_accounts.host.v1.rs create mode 100644 modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.interchain_accounts.v1.rs create mode 100644 modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.transfer.v1.rs create mode 100644 modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.transfer.v2.rs create mode 100644 modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.channel.v1.rs create mode 100644 modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.channel.v2.rs create mode 100644 modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.client.v1.rs create mode 100644 modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.commitment.v1.rs create mode 100644 modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.commitment.v2.rs create mode 100644 modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.connection.v1.rs create mode 100644 modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.types.v1.rs create mode 100644 modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.lightclients.solomachine.v2.rs create mode 100644 modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.lightclients.solomachine.v3.rs create mode 100644 modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.lightclients.tendermint.v1.rs create mode 100644 modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.lightclients.wasm.v1.rs create mode 100644 modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/lib.rs create mode 100644 proto/buf.gen.prost.yaml diff --git a/.github/workflows/wasm-light-clients.yml b/.github/workflows/wasm-light-clients.yml new file mode 100644 index 00000000000..2d2cdeaa740 --- /dev/null +++ b/.github/workflows/wasm-light-clients.yml @@ -0,0 +1,60 @@ +name: Wasm Light Clients +# This workflow runs when a PR is opened that targets code that is part of the 08-wasm-light-clients +on: + merge_group: + pull_request: + push: + branches: + - main + - feat/ibc-eureka # TODO: Remove before merging to main +permissions: + contents: read + pull-requests: read + +jobs: + lint: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Install stable toolchain + uses: actions-rs/toolchain@v1 + with: + profile: minimal + toolchain: stable + components: rustfmt, clippy + target: wasm32-unknown-unknown + + - name: Lint 08-wasm-light-clients workspace + run: make lint-wasm-light-clients + + + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Install stable toolchain + uses: actions-rs/toolchain@v1 + with: + profile: minimal + toolchain: stable + components: rustfmt, clippy + + - name: Cargo build 08-wasm-light-clients workspace + run: make build-wasm-light-clients + + tests: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Install stable toolchain + uses: actions-rs/toolchain@v1 + with: + profile: minimal + toolchain: stable + components: rustfmt, clippy + + - name: Unit test 08-wasm-light-clients workspace + run: make test-wasm-light-clients diff --git a/.gitignore b/.gitignore index e593116b68f..85ab4b46094 100644 --- a/.gitignore +++ b/.gitignore @@ -70,3 +70,7 @@ go.work.sum # Python venv + +# Rust +target +artifacts diff --git a/Makefile b/Makefile index 1c0a3fdf24d..179361264bc 100644 --- a/Makefile +++ b/Makefile @@ -141,6 +141,11 @@ build-docker-wasm: .PHONY: build-docker-wasm +build-wasm-light-clients: + cd modules/light-clients/08-wasm-light-clients && cargo wasm + +.PHONY: build-wasm-light-clients + ############################################################################### ### Tools & Dependencies ### ############################################################################### @@ -310,6 +315,11 @@ benchmark: @go test -mod=readonly -bench=. $(PACKAGES_NOSIMULATION) .PHONY: benchmark +test-wasm-light-clients: + cd modules/light-clients/08-wasm-light-clients && cargo test + +.PHONY: test-wasm-light-clients + ############################################################################### ### Linting ### ############################################################################### @@ -351,6 +361,11 @@ docs-link-check: .PHONY: lint lint-fix docs-lint docs-lint-fix docs-link-check +lint-wasm-light-clients: + cd modules/light-clients/08-wasm-light-clients && cargo fmt -- --check && cargo clippy + +.PHONY: lint-wasm-light-clients + ############################################################################### ### Protobuf ### ############################################################################### diff --git a/modules/light-clients/08-wasm-light-clients/.cargo/config.toml b/modules/light-clients/08-wasm-light-clients/.cargo/config.toml new file mode 100644 index 00000000000..86f292b69cd --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/.cargo/config.toml @@ -0,0 +1,3 @@ +[alias] +wasm = "build --release --lib --target wasm32-unknown-unknown" + diff --git a/modules/light-clients/08-wasm-light-clients/Cargo.lock b/modules/light-clients/08-wasm-light-clients/Cargo.lock new file mode 100644 index 00000000000..7cd6d2cb9c4 --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/Cargo.lock @@ -0,0 +1,1265 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "ahash" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011" +dependencies = [ + "cfg-if", + "once_cell", + "version_check", + "zerocopy", +] + +[[package]] +name = "allocator-api2" +version = "0.2.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "45862d1c77f2228b9e10bc609d5bc203d86ebc9b87ad8d5d5167a6c9abf739d9" + +[[package]] +name = "anyhow" +version = "1.0.93" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c95c10ba0b00a02636238b814946408b1322d5ac4760326e6fb8ec956d85775" + +[[package]] +name = "ark-bls12-381" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c775f0d12169cba7aae4caeb547bb6a50781c7449a8aa53793827c9ec4abf488" +dependencies = [ + "ark-ec", + "ark-ff", + "ark-serialize", + "ark-std", +] + +[[package]] +name = "ark-ec" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "defd9a439d56ac24968cca0571f598a61bc8c55f71d50a89cda591cb750670ba" +dependencies = [ + "ark-ff", + "ark-poly", + "ark-serialize", + "ark-std", + "derivative", + "hashbrown 0.13.2", + "itertools 0.10.5", + "num-traits", + "rayon", + "zeroize", +] + +[[package]] +name = "ark-ff" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec847af850f44ad29048935519032c33da8aa03340876d351dfab5660d2966ba" +dependencies = [ + "ark-ff-asm", + "ark-ff-macros", + "ark-serialize", + "ark-std", + "derivative", + "digest", + "itertools 0.10.5", + "num-bigint", + "num-traits", + "paste", + "rayon", + "rustc_version", + "zeroize", +] + +[[package]] +name = "ark-ff-asm" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ed4aa4fe255d0bc6d79373f7e31d2ea147bcf486cba1be5ba7ea85abdb92348" +dependencies = [ + "quote", + "syn 1.0.109", +] + +[[package]] +name = "ark-ff-macros" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7abe79b0e4288889c4574159ab790824d0033b9fdcb2a112a3182fac2e514565" +dependencies = [ + "num-bigint", + "num-traits", + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "ark-poly" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d320bfc44ee185d899ccbadfa8bc31aab923ce1558716e1997a1e74057fe86bf" +dependencies = [ + "ark-ff", + "ark-serialize", + "ark-std", + "derivative", + "hashbrown 0.13.2", +] + +[[package]] +name = "ark-serialize" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "adb7b85a02b83d2f22f89bd5cac66c9c89474240cb6207cb1efc16d098e822a5" +dependencies = [ + "ark-serialize-derive", + "ark-std", + "digest", + "num-bigint", +] + +[[package]] +name = "ark-serialize-derive" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae3281bc6d0fd7e549af32b52511e1302185bd688fd3359fa36423346ff682ea" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "ark-std" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94893f1e0c6eeab764ade8dc4c0db24caf4fe7cbbaafc0eba0a9030f447b5185" +dependencies = [ + "num-traits", + "rand", + "rayon", +] + +[[package]] +name = "autocfg" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26" + +[[package]] +name = "base16ct" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf" + +[[package]] +name = "base64" +version = "0.22.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" + +[[package]] +name = "bech32" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d965446196e3b7decd44aa7ee49e31d630118f90ef12f97900f262eb915c951d" + +[[package]] +name = "block-buffer" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" +dependencies = [ + "generic-array", +] + +[[package]] +name = "bnum" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3e31ea183f6ee62ac8b8a8cf7feddd766317adfb13ff469de57ce033efd6a790" + +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + +[[package]] +name = "bytes" +version = "1.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ac0150caa2ae65ca5bd83f25c7de183dea78d4d366469f148435e2acfbad0da" +dependencies = [ + "serde", +] + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "const-oid" +version = "0.9.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8" + +[[package]] +name = "cosmos-sdk-proto" +version = "0.26.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "462e1f6a8e005acc8835d32d60cbd7973ed65ea2a8d8473830e675f050956427" +dependencies = [ + "prost", + "tendermint-proto", +] + +[[package]] +name = "cosmwasm-core" +version = "2.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f6ceb8624260d0d3a67c4e1a1d43fc7e9406720afbcb124521501dd138f90aa" + +[[package]] +name = "cosmwasm-crypto" +version = "2.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4125381e5fd7fefe9f614640049648088015eca2b60d861465329a5d87dfa538" +dependencies = [ + "ark-bls12-381", + "ark-ec", + "ark-ff", + "ark-serialize", + "cosmwasm-core", + "digest", + "ecdsa", + "ed25519-zebra", + "k256", + "num-traits", + "p256", + "rand_core", + "rayon", + "sha2", + "thiserror 1.0.69", +] + +[[package]] +name = "cosmwasm-derive" +version = "2.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b5658b1dc64e10b56ae7a449f678f96932a96f6cfad1769d608d1d1d656480a" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.89", +] + +[[package]] +name = "cosmwasm-schema" +version = "2.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f86b4d949b6041519c58993a73f4bbfba8083ba14f7001eae704865a09065845" +dependencies = [ + "cosmwasm-schema-derive", + "schemars", + "serde", + "serde_json", + "thiserror 1.0.69", +] + +[[package]] +name = "cosmwasm-schema-derive" +version = "2.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8ef1b5835a65fcca3ab8b9a02b4f4dacc78e233a5c2f20b270efb9db0666d12" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.89", +] + +[[package]] +name = "cosmwasm-std" +version = "2.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70eb7ab0c1e99dd6207496963ba2a457c4128ac9ad9c72a83f8d9808542b849b" +dependencies = [ + "base64", + "bech32", + "bnum", + "cosmwasm-core", + "cosmwasm-crypto", + "cosmwasm-derive", + "derive_more", + "hex", + "rand_core", + "schemars", + "serde", + "serde-json-wasm", + "sha2", + "static_assertions", + "thiserror 1.0.69", +] + +[[package]] +name = "cpufeatures" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "16b80225097f2e5ae4e7179dd2266824648f3e2f49d9134d584b76389d31c4c3" +dependencies = [ + "libc", +] + +[[package]] +name = "crossbeam-deque" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d" +dependencies = [ + "crossbeam-epoch", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-epoch" +version = "0.9.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80" + +[[package]] +name = "crypto-bigint" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76" +dependencies = [ + "generic-array", + "rand_core", + "subtle", + "zeroize", +] + +[[package]] +name = "crypto-common" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3" +dependencies = [ + "generic-array", + "typenum", +] + +[[package]] +name = "curve25519-dalek" +version = "4.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be" +dependencies = [ + "cfg-if", + "cpufeatures", + "curve25519-dalek-derive", + "digest", + "fiat-crypto", + "rustc_version", + "subtle", + "zeroize", +] + +[[package]] +name = "curve25519-dalek-derive" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.89", +] + +[[package]] +name = "cw-multi-test" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1149fe104344cc4f4ca0fc784b7411042fd1626813fe85fd412b05252a0ae9d8" +dependencies = [ + "anyhow", + "bech32", + "cosmwasm-schema", + "cosmwasm-std", + "cw-storage-plus", + "cw-utils", + "itertools 0.13.0", + "prost", + "schemars", + "serde", + "sha2", + "thiserror 2.0.3", +] + +[[package]] +name = "cw-storage-plus" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f13360e9007f51998d42b1bc6b7fa0141f74feae61ed5fd1e5b0a89eec7b5de1" +dependencies = [ + "cosmwasm-std", + "schemars", + "serde", +] + +[[package]] +name = "cw-utils" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07dfee7f12f802431a856984a32bce1cb7da1e6c006b5409e3981035ce562dec" +dependencies = [ + "cosmwasm-schema", + "cosmwasm-std", + "schemars", + "serde", + "thiserror 1.0.69", +] + +[[package]] +name = "der" +version = "0.7.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f55bf8e7b65898637379c1b74eb1551107c8294ed26d855ceb9fd1a09cfc9bc0" +dependencies = [ + "const-oid", + "zeroize", +] + +[[package]] +name = "deranged" +version = "0.3.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4" +dependencies = [ + "powerfmt", +] + +[[package]] +name = "derivative" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "derive_more" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a9b99b9cbbe49445b21764dc0625032a89b145a2642e67603e1c936f5458d05" +dependencies = [ + "derive_more-impl", +] + +[[package]] +name = "derive_more-impl" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb7330aeadfbe296029522e6c40f315320aba36fc43a5b3632f3795348f3bd22" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.89", + "unicode-xid", +] + +[[package]] +name = "digest" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" +dependencies = [ + "block-buffer", + "const-oid", + "crypto-common", + "subtle", +] + +[[package]] +name = "dyn-clone" +version = "1.0.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d6ef0072f8a535281e4876be788938b528e9a1d43900b82c2569af7da799125" + +[[package]] +name = "ecdsa" +version = "0.16.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca" +dependencies = [ + "der", + "digest", + "elliptic-curve", + "rfc6979", + "signature", +] + +[[package]] +name = "ed25519" +version = "2.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "115531babc129696a58c64a4fef0a8bf9e9698629fb97e9e40767d235cfbcd53" +dependencies = [ + "signature", +] + +[[package]] +name = "ed25519-zebra" +version = "4.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d9ce6874da5d4415896cd45ffbc4d1cfc0c4f9c079427bd870742c30f2f65a9" +dependencies = [ + "curve25519-dalek", + "ed25519", + "hashbrown 0.14.5", + "hex", + "rand_core", + "sha2", + "zeroize", +] + +[[package]] +name = "either" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0" + +[[package]] +name = "elliptic-curve" +version = "0.13.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47" +dependencies = [ + "base16ct", + "crypto-bigint", + "digest", + "ff", + "generic-array", + "group", + "rand_core", + "sec1", + "subtle", + "zeroize", +] + +[[package]] +name = "ethereum-light-client" +version = "0.1.0" +dependencies = [ + "cosmwasm-schema", + "cosmwasm-std", + "cw-multi-test", + "cw-storage-plus", + "ibc-go-proto", + "prost", + "serde", + "tendermint-proto", + "thiserror 2.0.3", +] + +[[package]] +name = "ff" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449" +dependencies = [ + "rand_core", + "subtle", +] + +[[package]] +name = "fiat-crypto" +version = "0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d" + +[[package]] +name = "flex-error" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c606d892c9de11507fa0dcffc116434f94e105d0bbdc4e405b61519464c49d7b" +dependencies = [ + "paste", +] + +[[package]] +name = "generic-array" +version = "0.14.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" +dependencies = [ + "typenum", + "version_check", + "zeroize", +] + +[[package]] +name = "getrandom" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + +[[package]] +name = "group" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63" +dependencies = [ + "ff", + "rand_core", + "subtle", +] + +[[package]] +name = "hashbrown" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e" +dependencies = [ + "ahash", +] + +[[package]] +name = "hashbrown" +version = "0.14.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1" +dependencies = [ + "ahash", + "allocator-api2", +] + +[[package]] +name = "hex" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" + +[[package]] +name = "hmac" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e" +dependencies = [ + "digest", +] + +[[package]] +name = "ibc-go-proto" +version = "0.1.0" +dependencies = [ + "cosmos-sdk-proto", + "ics23", + "prost", + "tendermint-proto", +] + +[[package]] +name = "ics23" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73b17f1a5bd7d12ad30a21445cfa5f52fd7651cb3243ba866f9916b1ec112f12" +dependencies = [ + "anyhow", + "bytes", + "hex", + "prost", +] + +[[package]] +name = "itertools" +version = "0.10.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473" +dependencies = [ + "either", +] + +[[package]] +name = "itertools" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674" + +[[package]] +name = "k256" +version = "0.13.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6e3919bbaa2945715f0bb6d3934a173d1e9a59ac23767fbaaef277265a7411b" +dependencies = [ + "cfg-if", + "ecdsa", + "elliptic-curve", + "sha2", +] + +[[package]] +name = "libc" +version = "0.2.165" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fcb4d3d38eab6c5239a362fa8bae48c03baf980a6e7079f063942d563ef3533e" + +[[package]] +name = "memchr" +version = "2.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" + +[[package]] +name = "num-bigint" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9" +dependencies = [ + "num-integer", + "num-traits", +] + +[[package]] +name = "num-conv" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9" + +[[package]] +name = "num-integer" +version = "0.1.46" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "once_cell" +version = "1.20.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775" + +[[package]] +name = "p256" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c9863ad85fa8f4460f9c48cb909d38a0d689dba1f6f6988a5e3e0d31071bcd4b" +dependencies = [ + "ecdsa", + "elliptic-curve", + "primeorder", + "sha2", +] + +[[package]] +name = "paste" +version = "1.0.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" + +[[package]] +name = "powerfmt" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391" + +[[package]] +name = "ppv-lite86" +version = "0.2.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04" +dependencies = [ + "zerocopy", +] + +[[package]] +name = "primeorder" +version = "0.13.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "353e1ca18966c16d9deb1c69278edbc5f194139612772bd9537af60ac231e1e6" +dependencies = [ + "elliptic-curve", +] + +[[package]] +name = "proc-macro2" +version = "1.0.92" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "prost" +version = "0.13.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b0487d90e047de87f984913713b85c601c05609aad5b0df4b4573fbf69aa13f" +dependencies = [ + "bytes", + "prost-derive", +] + +[[package]] +name = "prost-derive" +version = "0.13.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e9552f850d5f0964a4e4d0bf306459ac29323ddfbae05e35a7c0d35cb0803cc5" +dependencies = [ + "anyhow", + "itertools 0.13.0", + "proc-macro2", + "quote", + "syn 2.0.89", +] + +[[package]] +name = "quote" +version = "1.0.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rand" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +dependencies = [ + "rand_chacha", + "rand_core", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom", +] + +[[package]] +name = "rayon" +version = "1.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa" +dependencies = [ + "either", + "rayon-core", +] + +[[package]] +name = "rayon-core" +version = "1.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2" +dependencies = [ + "crossbeam-deque", + "crossbeam-utils", +] + +[[package]] +name = "rfc6979" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2" +dependencies = [ + "hmac", + "subtle", +] + +[[package]] +name = "rustc_version" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92" +dependencies = [ + "semver", +] + +[[package]] +name = "ryu" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f" + +[[package]] +name = "schemars" +version = "0.8.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09c024468a378b7e36765cd36702b7a90cc3cba11654f6685c8f233408e89e92" +dependencies = [ + "dyn-clone", + "schemars_derive", + "serde", + "serde_json", +] + +[[package]] +name = "schemars_derive" +version = "0.8.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1eee588578aff73f856ab961cd2f79e36bc45d7ded33a7562adba4667aecc0e" +dependencies = [ + "proc-macro2", + "quote", + "serde_derive_internals", + "syn 2.0.89", +] + +[[package]] +name = "sec1" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc" +dependencies = [ + "base16ct", + "der", + "generic-array", + "subtle", + "zeroize", +] + +[[package]] +name = "semver" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b" + +[[package]] +name = "serde" +version = "1.0.215" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6513c1ad0b11a9376da888e3e0baa0077f1aed55c17f50e7b2397136129fb88f" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde-json-wasm" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f05da0d153dd4595bdffd5099dc0e9ce425b205ee648eb93437ff7302af8c9a5" +dependencies = [ + "serde", +] + +[[package]] +name = "serde_bytes" +version = "0.11.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "387cc504cb06bb40a96c8e04e951fe01854cf6bc921053c954e4a606d9675c6a" +dependencies = [ + "serde", +] + +[[package]] +name = "serde_derive" +version = "1.0.215" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad1e866f866923f252f05c889987993144fb74e722403468a4ebd70c3cd756c0" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.89", +] + +[[package]] +name = "serde_derive_internals" +version = "0.29.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.89", +] + +[[package]] +name = "serde_json" +version = "1.0.133" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c7fceb2473b9166b2294ef05efcb65a3db80803f0b03ef86a5fc88a2b85ee377" +dependencies = [ + "itoa", + "memchr", + "ryu", + "serde", +] + +[[package]] +name = "sha2" +version = "0.10.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8" +dependencies = [ + "cfg-if", + "cpufeatures", + "digest", +] + +[[package]] +name = "signature" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de" +dependencies = [ + "digest", + "rand_core", +] + +[[package]] +name = "static_assertions" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" + +[[package]] +name = "subtle" +version = "2.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" + +[[package]] +name = "subtle-encoding" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7dcb1ed7b8330c5eed5441052651dd7a12c75e2ed88f2ec024ae1fa3a5e59945" +dependencies = [ + "zeroize", +] + +[[package]] +name = "syn" +version = "1.0.109" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "2.0.89" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44d46482f1c1c87acd84dea20c1bf5ebff4c757009ed6bf19cfd36fb10e92c4e" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "tendermint-proto" +version = "0.40.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c81ba1b023ec00763c3bc4f4376c67c0047f185cccf95c416c7a2f16272c4cbb" +dependencies = [ + "bytes", + "flex-error", + "prost", + "serde", + "serde_bytes", + "subtle-encoding", + "time", +] + +[[package]] +name = "thiserror" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" +dependencies = [ + "thiserror-impl 1.0.69", +] + +[[package]] +name = "thiserror" +version = "2.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c006c85c7651b3cf2ada4584faa36773bd07bac24acfb39f3c431b36d7e667aa" +dependencies = [ + "thiserror-impl 2.0.3", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.89", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f077553d607adc1caf65430528a576c757a71ed73944b66ebb58ef2bbd243568" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.89", +] + +[[package]] +name = "time" +version = "0.3.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885" +dependencies = [ + "deranged", + "num-conv", + "powerfmt", + "time-core", + "time-macros", +] + +[[package]] +name = "time-core" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3" + +[[package]] +name = "time-macros" +version = "0.2.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf" +dependencies = [ + "num-conv", + "time-core", +] + +[[package]] +name = "typenum" +version = "1.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825" + +[[package]] +name = "unicode-ident" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83" + +[[package]] +name = "unicode-xid" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "wasi" +version = "0.11.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" + +[[package]] +name = "zerocopy" +version = "0.7.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0" +dependencies = [ + "byteorder", + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.7.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.89", +] + +[[package]] +name = "zeroize" +version = "1.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde" +dependencies = [ + "zeroize_derive", +] + +[[package]] +name = "zeroize_derive" +version = "1.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.89", +] diff --git a/modules/light-clients/08-wasm-light-clients/Cargo.toml b/modules/light-clients/08-wasm-light-clients/Cargo.toml new file mode 100644 index 00000000000..5328b8b4d96 --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/Cargo.toml @@ -0,0 +1,39 @@ +[workspace] +resolver = "2" +members = [ + "contracts/*", + "packages/*", +] + +[workspace.package] +edition = "2021" +repository = "https://github.com/cosmos/ibc-go" +version = "0.1.0" + +[workspace.metadata.scripts] +optimize = """docker run --rm -v "$(pwd)":/code \ + --mount type=volume,source="$(basename "$(pwd)")_cache",target=/target \ + --mount type=volume,source=registry_cache,target=/usr/local/cargo/registry \ + cosmwasm/optimizer:0.16.0""" + +[workspace.dependencies] +# Local packages +ibc-go-proto = { path = "packages/ibc-go-proto" } + +# CosmWasm related dependencies +cosmwasm-schema = "2.1.4" +cosmwasm-std = { version = "2.1.4" } +cw-storage-plus = "2.0.0" +serde = { version = "1.0.215", default-features = false, features = ["derive"] } +thiserror = { version = "2.0.3" } + +# Proto related dependencies +ics23 = { version = "0.12.0", default-features = false } +tendermint-proto = { version = "0.40.0", default-features = false } +cosmos-sdk-proto = { version = "0.26.1", default-features = false } +prost = { version = "0.13.3", default-features = false, features = ["prost-derive"] } + +# dev-dependencies +cw-multi-test = "2.2.0" + + diff --git a/modules/light-clients/08-wasm-light-clients/README.md b/modules/light-clients/08-wasm-light-clients/README.md new file mode 100644 index 00000000000..f8022ebea89 --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/README.md @@ -0,0 +1,3 @@ +# 08-wasm Light Clients + +TODO: Document (cargo test, cargo wasm, cargo run-script optimize) diff --git a/modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/Cargo.toml b/modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/Cargo.toml new file mode 100644 index 00000000000..0e08dbcc9ba --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/Cargo.toml @@ -0,0 +1,22 @@ +[package] +name = "ethereum-light-client" +version = { workspace = true } +edition = { workspace = true } +repository = { workspace = true } + +[dependencies] +ibc-go-proto = { workspace = true } + +cosmwasm-std = { workspace = true } +cosmwasm-schema = { workspace = true } +cw-storage-plus = { workspace = true } +tendermint-proto = { workspace = true } +prost = { workspace = true } +serde = { workspace = true } +thiserror = { workspace = true } + +[dev-dependencies] +cw-multi-test = { workspace = true } + +[lib] +crate-type = ["cdylib", "rlib"] diff --git a/modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/contract.rs b/modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/contract.rs new file mode 100644 index 00000000000..d2b8af2a3db --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/contract.rs @@ -0,0 +1,299 @@ +use cosmwasm_std::entry_point; +use cosmwasm_std::{to_json_binary, Binary, Deps, DepsMut, Env, MessageInfo, Response}; +use ibc_go_proto::ibc::{ + core::client::v1::Height as IbcProtoHeight, + lightclients::wasm::v1::ClientState as WasmClientState, +}; +use prost::Message; +use tendermint_proto::google::protobuf::Any; + +use crate::error::ContractError; +use crate::msg::{ + CheckForMisbehaviourResult, ExecuteMsg, ExportMetadataResult, Height, InstantiateMsg, QueryMsg, + StatusResult, SudoMsg, TimestampAtHeightResult, UpdateStateResult, +}; +use crate::state::{consensus_db_key, HOST_CLIENT_STATE_KEY}; + +#[entry_point] +pub fn instantiate( + deps: DepsMut, + _env: Env, + _info: MessageInfo, + msg: InstantiateMsg, +) -> Result { + let client_state = WasmClientState { + checksum: msg.checksum.into(), + data: msg.client_state.clone().into(), + latest_height: Some(IbcProtoHeight { + revision_number: 0, + revision_height: 1, + }), + }; + + let client_state_any = Any::from_msg(&client_state).unwrap(); + + deps.storage.set( + HOST_CLIENT_STATE_KEY.as_bytes(), + client_state_any.encode_to_vec().as_slice(), + ); + + let height = Height { + revision_number: 0, + revision_height: 1, + }; + deps.storage.set( + consensus_db_key(&height).as_bytes(), + msg.consensus_state.as_slice(), + ); + + Ok(Response::default()) +} + +#[entry_point] +pub fn sudo(_deps: DepsMut, _env: Env, msg: SudoMsg) -> Result { + let result = match msg { + SudoMsg::VerifyMembership(_) => verify_membership()?, + SudoMsg::VerifyNonMembership(_) => verify_non_membership()?, + SudoMsg::UpdateState(_) => update_state()?, + SudoMsg::UpdateStateOnMisbehaviour(_) => unimplemented!(), + SudoMsg::VerifyUpgradeAndUpdateState(_) => unimplemented!(), + SudoMsg::MigrateClientStore(_) => unimplemented!(), + }; + + Ok(Response::default().set_data(result)) +} + +pub fn verify_membership() -> Result { + Ok(to_json_binary(&Ok::<(), ()>(()))?) +} + +pub fn verify_non_membership() -> Result { + Ok(to_json_binary(&Ok::<(), ()>(()))?) +} + +pub fn update_state() -> Result { + Ok(to_json_binary(&UpdateStateResult { heights: vec![] })?) +} + +#[entry_point] +pub fn execute( + _deps: DepsMut, + _env: Env, + _info: MessageInfo, + _msg: ExecuteMsg, +) -> Result { + unimplemented!() +} + +#[entry_point] +pub fn query(_deps: Deps, env: Env, msg: QueryMsg) -> Result { + match msg { + QueryMsg::VerifyClientMessage(_) => verify_client_message(), + QueryMsg::CheckForMisbehaviour(_) => check_for_misbehaviour(), + QueryMsg::TimestampAtHeight(_) => timestamp_at_height(env), + QueryMsg::Status(_) => status(), + QueryMsg::ExportMetadata(_) => export_metadata(), + } +} + +pub fn verify_client_message() -> Result { + Ok(to_json_binary(&Ok::<(), ()>(()))?) +} + +pub fn check_for_misbehaviour() -> Result { + Ok(to_json_binary(&CheckForMisbehaviourResult { + found_misbehaviour: false, + })?) +} + +pub fn timestamp_at_height(env: Env) -> Result { + let now = env.block.time.seconds(); + Ok(to_json_binary(&TimestampAtHeightResult { timestamp: now })?) +} + +pub fn status() -> Result { + Ok(to_json_binary(&StatusResult { + status: "Active".to_string(), + })?) +} + +pub fn export_metadata() -> Result { + Ok(to_json_binary(&ExportMetadataResult { + genesis_metadata: vec![], + })?) +} + +#[cfg(test)] +mod tests { + mod instantiate_tests { + use cosmwasm_std::{ + coins, + testing::{message_info, mock_dependencies, mock_env}, + }; + + use crate::{contract::instantiate, msg::InstantiateMsg}; + + #[test] + fn test_instantiate() { + let mut deps = mock_dependencies(); + let creator = deps.api.addr_make("creator"); + let info = message_info(&creator, &coins(1, "uatom")); + + let msg = InstantiateMsg { + client_state: "does not matter yet".as_bytes().into(), + consensus_state: "also does not matter yet".as_bytes().into(), + checksum: "yet another that does not matter yet".as_bytes().into(), + }; + + let res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap(); + assert_eq!(0, res.messages.len()); + } + } + + mod sudo_tests { + use cosmwasm_std::{ + testing::{mock_dependencies, mock_env}, + Binary, + }; + + use crate::{ + contract::sudo, + msg::{ + Height, MerklePath, SudoMsg, UpdateStateMsg, VerifyMembershipMsg, + VerifyNonMembershipMsg, + }, + }; + + #[test] + fn test_verify_membership() { + let mut deps = mock_dependencies(); + let msg = SudoMsg::VerifyMembership(VerifyMembershipMsg { + height: Height { + revision_number: 0, + revision_height: 1, + }, + delay_time_period: 0, + delay_block_period: 0, + proof: Binary::default(), + merkle_path: MerklePath { key_path: vec![] }, + value: Binary::default(), + }); + let res = sudo(deps.as_mut(), mock_env(), msg).unwrap(); + assert_eq!(0, res.messages.len()); + } + + #[test] + fn test_verify_non_membership() { + let mut deps = mock_dependencies(); + let msg = SudoMsg::VerifyNonMembership(VerifyNonMembershipMsg { + height: Height { + revision_number: 0, + revision_height: 1, + }, + delay_time_period: 0, + delay_block_period: 0, + proof: Binary::default(), + merkle_path: MerklePath { key_path: vec![] }, + }); + let res = sudo(deps.as_mut(), mock_env(), msg).unwrap(); + assert_eq!(0, res.messages.len()); + } + + #[test] + fn test_update_state() { + let mut deps = mock_dependencies(); + let msg = SudoMsg::UpdateState(UpdateStateMsg { + client_message: Binary::default(), + }); + let res = sudo(deps.as_mut(), mock_env(), msg).unwrap(); + assert_eq!(0, res.messages.len()); + } + } + + mod query_tests { + use cosmwasm_std::{ + from_json, + testing::{mock_dependencies, mock_env}, + Binary, + }; + + use crate::{ + contract::query, + msg::{ + CheckForMisbehaviourMsg, CheckForMisbehaviourResult, ExportMetadataMsg, + ExportMetadataResult, Height, QueryMsg, StatusMsg, StatusResult, + TimestampAtHeightMsg, TimestampAtHeightResult, VerifyClientMessageMsg, + }, + }; + + #[test] + fn test_verify_client_message() { + let deps = mock_dependencies(); + query( + deps.as_ref(), + mock_env(), + QueryMsg::VerifyClientMessage(VerifyClientMessageMsg { + client_message: Binary::default(), + }), + ) + .unwrap(); + } + + #[test] + fn test_check_for_misbehaviour() { + let deps = mock_dependencies(); + let res = query( + deps.as_ref(), + mock_env(), + QueryMsg::CheckForMisbehaviour(CheckForMisbehaviourMsg { + client_message: Binary::default(), + }), + ) + .unwrap(); + let misbehaviour_result: CheckForMisbehaviourResult = from_json(&res).unwrap(); + assert!(!misbehaviour_result.found_misbehaviour); + } + + #[test] + fn test_timestamp_at_height() { + let deps = mock_dependencies(); + let res = query( + deps.as_ref(), + mock_env(), + QueryMsg::TimestampAtHeight(TimestampAtHeightMsg { + height: Height { + revision_number: 0, + revision_height: 1, + }, + }), + ) + .unwrap(); + let timestamp_at_height_result: TimestampAtHeightResult = from_json(&res).unwrap(); + assert_eq!( + mock_env().block.time.seconds(), + timestamp_at_height_result.timestamp + ); + } + + #[test] + fn test_status() { + let deps = mock_dependencies(); + let res = query(deps.as_ref(), mock_env(), QueryMsg::Status(StatusMsg {})).unwrap(); + let status_response: StatusResult = from_json(&res).unwrap(); + assert_eq!("Active", status_response.status); + } + + #[test] + fn test_export_metadata() { + let deps = mock_dependencies(); + let res = query( + deps.as_ref(), + mock_env(), + QueryMsg::ExportMetadata(ExportMetadataMsg {}), + ) + .unwrap(); + let export_metadata_result: ExportMetadataResult = from_json(&res).unwrap(); + assert_eq!(0, export_metadata_result.genesis_metadata.len()); + } + } +} diff --git a/modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/error.rs b/modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/error.rs new file mode 100644 index 00000000000..dc19f103399 --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/error.rs @@ -0,0 +1,11 @@ +use cosmwasm_std::StdError; +use thiserror::Error; + +#[derive(Error, Debug)] +pub enum ContractError { + #[error("{0}")] + Std(#[from] StdError), + + #[error("Unauthorized")] + Unauthorized {}, +} diff --git a/modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/lib.rs b/modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/lib.rs new file mode 100644 index 00000000000..d78159fb863 --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/lib.rs @@ -0,0 +1,4 @@ +pub mod contract; +mod error; +pub mod msg; +pub mod state; diff --git a/modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/msg.rs b/modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/msg.rs new file mode 100644 index 00000000000..4d4f129caba --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/msg.rs @@ -0,0 +1,152 @@ +use cosmwasm_schema::{cw_serde, QueryResponses}; +use cosmwasm_std::Binary; + +#[cw_serde] +pub struct InstantiateMsg { + pub client_state: Binary, + pub consensus_state: Binary, + pub checksum: Binary, +} + +#[cw_serde] +pub enum ExecuteMsg {} + +#[cw_serde] +pub enum SudoMsg { + VerifyMembership(VerifyMembershipMsg), + + VerifyNonMembership(VerifyNonMembershipMsg), + UpdateState(UpdateStateMsg), + + UpdateStateOnMisbehaviour(UpdateStateOnMisbehaviourMsg), + + VerifyUpgradeAndUpdateState(VerifyUpgradeAndUpdateStateMsg), + + MigrateClientStore(MigrateClientStoreMsg), +} + +#[cw_serde] +pub struct VerifyMembershipMsg { + pub height: Height, + pub delay_time_period: u64, + pub delay_block_period: u64, + pub proof: Binary, + pub merkle_path: MerklePath, + pub value: Binary, +} + +#[cw_serde] +pub struct VerifyNonMembershipMsg { + pub height: Height, + pub delay_time_period: u64, + pub delay_block_period: u64, + pub proof: Binary, + pub merkle_path: MerklePath, +} + +#[cw_serde] +pub struct UpdateStateMsg { + pub client_message: Binary, +} + +#[cw_serde] +pub struct UpdateStateOnMisbehaviourMsg { + pub client_message: Binary, +} + +#[cw_serde] +pub struct VerifyUpgradeAndUpdateStateMsg { + pub upgrade_client_state: Binary, + pub upgrade_consensus_state: Binary, + pub proof_upgrade_client: Binary, + pub proof_upgrade_consensus_state: Binary, +} + +#[cw_serde] +pub struct MigrateClientStoreMsg {} + +#[cw_serde] +#[derive(QueryResponses)] +pub enum QueryMsg { + #[returns[()]] + VerifyClientMessage(VerifyClientMessageMsg), + + #[returns[CheckForMisbehaviourResult]] + CheckForMisbehaviour(CheckForMisbehaviourMsg), + + #[returns[TimestampAtHeightResult]] + TimestampAtHeight(TimestampAtHeightMsg), + + #[returns(StatusResult)] + Status(StatusMsg), + + #[returns[ExportMetadataResult]] + ExportMetadata(ExportMetadataMsg), +} + +#[cw_serde] +pub struct VerifyClientMessageMsg { + pub client_message: Binary, +} + +#[cw_serde] +pub struct CheckForMisbehaviourMsg { + pub client_message: Binary, +} + +#[cw_serde] +pub struct TimestampAtHeightMsg { + pub height: Height, +} + +#[cw_serde] +pub struct StatusMsg {} + +#[cw_serde] +pub struct ExportMetadataMsg {} + +#[cw_serde] +pub struct Height { + /// the revision that the client is currently on + #[serde(default)] + pub revision_number: u64, + /// **height** is a height of remote chain + #[serde(default)] + pub revision_height: u64, +} + +#[cw_serde] +pub struct UpdateStateResult { + pub heights: Vec, +} + +#[cw_serde] +pub struct MerklePath { + pub key_path: Vec, +} + +#[cw_serde] +pub struct StatusResult { + pub status: String, +} + +#[cw_serde] +pub struct CheckForMisbehaviourResult { + pub found_misbehaviour: bool, +} + +#[cw_serde] +pub struct TimestampAtHeightResult { + pub timestamp: u64, +} + +#[cw_serde] +pub struct GenesisMetadata { + pub key: Vec, + pub value: Vec, +} + +#[cw_serde] +pub struct ExportMetadataResult { + pub genesis_metadata: Vec, +} diff --git a/modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/state.rs b/modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/state.rs new file mode 100644 index 00000000000..29c599bb847 --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/state.rs @@ -0,0 +1,19 @@ +use cosmwasm_schema::cw_serde; + +use crate::msg::Height; + +// Client state that is stored by the host +pub const HOST_CLIENT_STATE_KEY: &str = "clientState"; +pub const HOST_CONSENSUS_STATES_KEY: &str = "consensusStates"; + +#[cw_serde] +pub struct ClientState { + pub latest_height: u64, +} + +pub fn consensus_db_key(height: &Height) -> String { + format!( + "{}/{}-{}", + HOST_CONSENSUS_STATES_KEY, height.revision_number, height.revision_height + ) +} diff --git a/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/Cargo.toml b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/Cargo.toml new file mode 100644 index 00000000000..c770498e778 --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "ibc-go-proto" +version = { workspace = true } +edition = { workspace = true } +repository = { workspace = true } + +[dependencies] +tendermint-proto = { workspace = true } +prost = { workspace = true } +cosmos-sdk-proto = { workspace = true } +ics23 = { workspace = true } diff --git a/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.fee.v1.rs b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.fee.v1.rs new file mode 100644 index 00000000000..e0187e363c8 --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.fee.v1.rs @@ -0,0 +1,587 @@ +// @generated +// This file is @generated by prost-build. +/// IncentivizedAcknowledgement is the acknowledgement format to be used by applications wrapped in the fee middleware +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IncentivizedAcknowledgement { + /// the underlying app acknowledgement bytes + #[prost(bytes="vec", tag="1")] + pub app_acknowledgement: ::prost::alloc::vec::Vec, + /// the relayer address which submits the recv packet message + #[prost(string, tag="2")] + pub forward_relayer_address: ::prost::alloc::string::String, + /// success flag of the base application callback + #[prost(bool, tag="3")] + pub underlying_app_success: bool, +} +impl ::prost::Name for IncentivizedAcknowledgement { +const NAME: &'static str = "IncentivizedAcknowledgement"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.IncentivizedAcknowledgement".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.IncentivizedAcknowledgement".into() }} +/// Fee defines the ICS29 receive, acknowledgement and timeout fees +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Fee { + /// the packet receive fee + #[prost(message, repeated, tag="1")] + pub recv_fee: ::prost::alloc::vec::Vec<::cosmos_sdk_proto::cosmos::base::v1beta1::Coin>, + /// the packet acknowledgement fee + #[prost(message, repeated, tag="2")] + pub ack_fee: ::prost::alloc::vec::Vec<::cosmos_sdk_proto::cosmos::base::v1beta1::Coin>, + /// the packet timeout fee + #[prost(message, repeated, tag="3")] + pub timeout_fee: ::prost::alloc::vec::Vec<::cosmos_sdk_proto::cosmos::base::v1beta1::Coin>, +} +impl ::prost::Name for Fee { +const NAME: &'static str = "Fee"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.Fee".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.Fee".into() }} +/// PacketFee contains ICS29 relayer fees, refund address and optional list of permitted relayers +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PacketFee { + /// fee encapsulates the recv, ack and timeout fees associated with an IBC packet + #[prost(message, optional, tag="1")] + pub fee: ::core::option::Option, + /// the refund address for unspent fees + #[prost(string, tag="2")] + pub refund_address: ::prost::alloc::string::String, + /// optional list of relayers permitted to receive fees + #[prost(string, repeated, tag="3")] + pub relayers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +impl ::prost::Name for PacketFee { +const NAME: &'static str = "PacketFee"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.PacketFee".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.PacketFee".into() }} +/// PacketFees contains a list of type PacketFee +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PacketFees { + /// list of packet fees + #[prost(message, repeated, tag="1")] + pub packet_fees: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for PacketFees { +const NAME: &'static str = "PacketFees"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.PacketFees".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.PacketFees".into() }} +/// IdentifiedPacketFees contains a list of type PacketFee and associated PacketId +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IdentifiedPacketFees { + /// unique packet identifier comprised of the channel ID, port ID and sequence + #[prost(message, optional, tag="1")] + pub packet_id: ::core::option::Option, + /// list of packet fees + #[prost(message, repeated, tag="2")] + pub packet_fees: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for IdentifiedPacketFees { +const NAME: &'static str = "IdentifiedPacketFees"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.IdentifiedPacketFees".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.IdentifiedPacketFees".into() }} +/// GenesisState defines the ICS29 fee middleware genesis state +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GenesisState { + /// list of identified packet fees + #[prost(message, repeated, tag="1")] + pub identified_fees: ::prost::alloc::vec::Vec, + /// list of fee enabled channels + #[prost(message, repeated, tag="2")] + pub fee_enabled_channels: ::prost::alloc::vec::Vec, + /// list of registered payees + #[prost(message, repeated, tag="3")] + pub registered_payees: ::prost::alloc::vec::Vec, + /// list of registered counterparty payees + #[prost(message, repeated, tag="4")] + pub registered_counterparty_payees: ::prost::alloc::vec::Vec, + /// list of forward relayer addresses + #[prost(message, repeated, tag="5")] + pub forward_relayers: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for GenesisState { +const NAME: &'static str = "GenesisState"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.GenesisState".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.GenesisState".into() }} +/// FeeEnabledChannel contains the PortID & ChannelID for a fee enabled channel +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FeeEnabledChannel { + /// unique port identifier + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + /// unique channel identifier + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, +} +impl ::prost::Name for FeeEnabledChannel { +const NAME: &'static str = "FeeEnabledChannel"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.FeeEnabledChannel".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.FeeEnabledChannel".into() }} +/// RegisteredPayee contains the relayer address and payee address for a specific channel +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RegisteredPayee { + /// unique channel identifier + #[prost(string, tag="1")] + pub channel_id: ::prost::alloc::string::String, + /// the relayer address + #[prost(string, tag="2")] + pub relayer: ::prost::alloc::string::String, + /// the payee address + #[prost(string, tag="3")] + pub payee: ::prost::alloc::string::String, +} +impl ::prost::Name for RegisteredPayee { +const NAME: &'static str = "RegisteredPayee"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.RegisteredPayee".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.RegisteredPayee".into() }} +/// RegisteredCounterpartyPayee contains the relayer address and counterparty payee address for a specific channel (used +/// for recv fee distribution) +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RegisteredCounterpartyPayee { + /// unique channel identifier + #[prost(string, tag="1")] + pub channel_id: ::prost::alloc::string::String, + /// the relayer address + #[prost(string, tag="2")] + pub relayer: ::prost::alloc::string::String, + /// the counterparty payee address + #[prost(string, tag="3")] + pub counterparty_payee: ::prost::alloc::string::String, +} +impl ::prost::Name for RegisteredCounterpartyPayee { +const NAME: &'static str = "RegisteredCounterpartyPayee"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.RegisteredCounterpartyPayee".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.RegisteredCounterpartyPayee".into() }} +/// ForwardRelayerAddress contains the forward relayer address and PacketId used for async acknowledgements +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ForwardRelayerAddress { + /// the forward relayer address + #[prost(string, tag="1")] + pub address: ::prost::alloc::string::String, + /// unique packet identifier comprised of the channel ID, port ID and sequence + #[prost(message, optional, tag="2")] + pub packet_id: ::core::option::Option, +} +impl ::prost::Name for ForwardRelayerAddress { +const NAME: &'static str = "ForwardRelayerAddress"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.ForwardRelayerAddress".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.ForwardRelayerAddress".into() }} +/// Metadata defines the ICS29 channel specific metadata encoded into the channel version bytestring +/// See ICS004: +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Metadata { + /// fee_version defines the ICS29 fee version + #[prost(string, tag="1")] + pub fee_version: ::prost::alloc::string::String, + /// app_version defines the underlying application version, which may or may not be a JSON encoded bytestring + #[prost(string, tag="2")] + pub app_version: ::prost::alloc::string::String, +} +impl ::prost::Name for Metadata { +const NAME: &'static str = "Metadata"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.Metadata".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.Metadata".into() }} +/// QueryIncentivizedPacketsRequest defines the request type for the IncentivizedPackets rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryIncentivizedPacketsRequest { + /// pagination defines an optional pagination for the request. + #[prost(message, optional, tag="1")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageRequest>, + /// block height at which to query + #[prost(uint64, tag="2")] + pub query_height: u64, +} +impl ::prost::Name for QueryIncentivizedPacketsRequest { +const NAME: &'static str = "QueryIncentivizedPacketsRequest"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.QueryIncentivizedPacketsRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.QueryIncentivizedPacketsRequest".into() }} +/// QueryIncentivizedPacketsResponse defines the response type for the IncentivizedPackets rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryIncentivizedPacketsResponse { + /// list of identified fees for incentivized packets + #[prost(message, repeated, tag="1")] + pub incentivized_packets: ::prost::alloc::vec::Vec, + /// pagination defines the pagination in the response. + #[prost(message, optional, tag="2")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageResponse>, +} +impl ::prost::Name for QueryIncentivizedPacketsResponse { +const NAME: &'static str = "QueryIncentivizedPacketsResponse"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.QueryIncentivizedPacketsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.QueryIncentivizedPacketsResponse".into() }} +/// QueryIncentivizedPacketRequest defines the request type for the IncentivizedPacket rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryIncentivizedPacketRequest { + /// unique packet identifier comprised of channel ID, port ID and sequence + #[prost(message, optional, tag="1")] + pub packet_id: ::core::option::Option, + /// block height at which to query + #[prost(uint64, tag="2")] + pub query_height: u64, +} +impl ::prost::Name for QueryIncentivizedPacketRequest { +const NAME: &'static str = "QueryIncentivizedPacketRequest"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.QueryIncentivizedPacketRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.QueryIncentivizedPacketRequest".into() }} +/// QueryIncentivizedPacketResponse defines the response type for the IncentivizedPacket rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryIncentivizedPacketResponse { + /// the identified fees for the incentivized packet + #[prost(message, optional, tag="1")] + pub incentivized_packet: ::core::option::Option, +} +impl ::prost::Name for QueryIncentivizedPacketResponse { +const NAME: &'static str = "QueryIncentivizedPacketResponse"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.QueryIncentivizedPacketResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.QueryIncentivizedPacketResponse".into() }} +/// QueryIncentivizedPacketsForChannelRequest defines the request type for querying for all incentivized packets +/// for a specific channel +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryIncentivizedPacketsForChannelRequest { + /// pagination defines an optional pagination for the request. + #[prost(message, optional, tag="1")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageRequest>, + #[prost(string, tag="2")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag="3")] + pub channel_id: ::prost::alloc::string::String, + /// Height to query at + #[prost(uint64, tag="4")] + pub query_height: u64, +} +impl ::prost::Name for QueryIncentivizedPacketsForChannelRequest { +const NAME: &'static str = "QueryIncentivizedPacketsForChannelRequest"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.QueryIncentivizedPacketsForChannelRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.QueryIncentivizedPacketsForChannelRequest".into() }} +/// QueryIncentivizedPacketsForChannelResponse defines the response type for querying for all incentivized packets +/// for a specific channel +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryIncentivizedPacketsForChannelResponse { + /// Map of all incentivized_packets + #[prost(message, repeated, tag="1")] + pub incentivized_packets: ::prost::alloc::vec::Vec, + /// pagination defines the pagination in the response. + #[prost(message, optional, tag="2")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageResponse>, +} +impl ::prost::Name for QueryIncentivizedPacketsForChannelResponse { +const NAME: &'static str = "QueryIncentivizedPacketsForChannelResponse"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.QueryIncentivizedPacketsForChannelResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.QueryIncentivizedPacketsForChannelResponse".into() }} +/// QueryTotalRecvFeesRequest defines the request type for the TotalRecvFees rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryTotalRecvFeesRequest { + /// the packet identifier for the associated fees + #[prost(message, optional, tag="1")] + pub packet_id: ::core::option::Option, +} +impl ::prost::Name for QueryTotalRecvFeesRequest { +const NAME: &'static str = "QueryTotalRecvFeesRequest"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.QueryTotalRecvFeesRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.QueryTotalRecvFeesRequest".into() }} +/// QueryTotalRecvFeesResponse defines the response type for the TotalRecvFees rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryTotalRecvFeesResponse { + /// the total packet receive fees + #[prost(message, repeated, tag="1")] + pub recv_fees: ::prost::alloc::vec::Vec<::cosmos_sdk_proto::cosmos::base::v1beta1::Coin>, +} +impl ::prost::Name for QueryTotalRecvFeesResponse { +const NAME: &'static str = "QueryTotalRecvFeesResponse"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.QueryTotalRecvFeesResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.QueryTotalRecvFeesResponse".into() }} +/// QueryTotalAckFeesRequest defines the request type for the TotalAckFees rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryTotalAckFeesRequest { + /// the packet identifier for the associated fees + #[prost(message, optional, tag="1")] + pub packet_id: ::core::option::Option, +} +impl ::prost::Name for QueryTotalAckFeesRequest { +const NAME: &'static str = "QueryTotalAckFeesRequest"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.QueryTotalAckFeesRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.QueryTotalAckFeesRequest".into() }} +/// QueryTotalAckFeesResponse defines the response type for the TotalAckFees rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryTotalAckFeesResponse { + /// the total packet acknowledgement fees + #[prost(message, repeated, tag="1")] + pub ack_fees: ::prost::alloc::vec::Vec<::cosmos_sdk_proto::cosmos::base::v1beta1::Coin>, +} +impl ::prost::Name for QueryTotalAckFeesResponse { +const NAME: &'static str = "QueryTotalAckFeesResponse"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.QueryTotalAckFeesResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.QueryTotalAckFeesResponse".into() }} +/// QueryTotalTimeoutFeesRequest defines the request type for the TotalTimeoutFees rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryTotalTimeoutFeesRequest { + /// the packet identifier for the associated fees + #[prost(message, optional, tag="1")] + pub packet_id: ::core::option::Option, +} +impl ::prost::Name for QueryTotalTimeoutFeesRequest { +const NAME: &'static str = "QueryTotalTimeoutFeesRequest"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.QueryTotalTimeoutFeesRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.QueryTotalTimeoutFeesRequest".into() }} +/// QueryTotalTimeoutFeesResponse defines the response type for the TotalTimeoutFees rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryTotalTimeoutFeesResponse { + /// the total packet timeout fees + #[prost(message, repeated, tag="1")] + pub timeout_fees: ::prost::alloc::vec::Vec<::cosmos_sdk_proto::cosmos::base::v1beta1::Coin>, +} +impl ::prost::Name for QueryTotalTimeoutFeesResponse { +const NAME: &'static str = "QueryTotalTimeoutFeesResponse"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.QueryTotalTimeoutFeesResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.QueryTotalTimeoutFeesResponse".into() }} +/// QueryPayeeRequest defines the request type for the Payee rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryPayeeRequest { + /// unique channel identifier + #[prost(string, tag="1")] + pub channel_id: ::prost::alloc::string::String, + /// the relayer address to which the distribution address is registered + #[prost(string, tag="2")] + pub relayer: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryPayeeRequest { +const NAME: &'static str = "QueryPayeeRequest"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.QueryPayeeRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.QueryPayeeRequest".into() }} +/// QueryPayeeResponse defines the response type for the Payee rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryPayeeResponse { + /// the payee address to which packet fees are paid out + #[prost(string, tag="1")] + pub payee_address: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryPayeeResponse { +const NAME: &'static str = "QueryPayeeResponse"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.QueryPayeeResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.QueryPayeeResponse".into() }} +/// QueryCounterpartyPayeeRequest defines the request type for the CounterpartyPayee rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryCounterpartyPayeeRequest { + /// unique channel identifier + #[prost(string, tag="1")] + pub channel_id: ::prost::alloc::string::String, + /// the relayer address to which the counterparty is registered + #[prost(string, tag="2")] + pub relayer: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryCounterpartyPayeeRequest { +const NAME: &'static str = "QueryCounterpartyPayeeRequest"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.QueryCounterpartyPayeeRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.QueryCounterpartyPayeeRequest".into() }} +/// QueryCounterpartyPayeeResponse defines the response type for the CounterpartyPayee rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryCounterpartyPayeeResponse { + /// the counterparty payee address used to compensate forward relaying + #[prost(string, tag="1")] + pub counterparty_payee: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryCounterpartyPayeeResponse { +const NAME: &'static str = "QueryCounterpartyPayeeResponse"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.QueryCounterpartyPayeeResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.QueryCounterpartyPayeeResponse".into() }} +/// QueryFeeEnabledChannelsRequest defines the request type for the FeeEnabledChannels rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryFeeEnabledChannelsRequest { + /// pagination defines an optional pagination for the request. + #[prost(message, optional, tag="1")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageRequest>, + /// block height at which to query + #[prost(uint64, tag="2")] + pub query_height: u64, +} +impl ::prost::Name for QueryFeeEnabledChannelsRequest { +const NAME: &'static str = "QueryFeeEnabledChannelsRequest"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.QueryFeeEnabledChannelsRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.QueryFeeEnabledChannelsRequest".into() }} +/// QueryFeeEnabledChannelsResponse defines the response type for the FeeEnabledChannels rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryFeeEnabledChannelsResponse { + /// list of fee enabled channels + #[prost(message, repeated, tag="1")] + pub fee_enabled_channels: ::prost::alloc::vec::Vec, + /// pagination defines the pagination in the response. + #[prost(message, optional, tag="2")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageResponse>, +} +impl ::prost::Name for QueryFeeEnabledChannelsResponse { +const NAME: &'static str = "QueryFeeEnabledChannelsResponse"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.QueryFeeEnabledChannelsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.QueryFeeEnabledChannelsResponse".into() }} +/// QueryFeeEnabledChannelRequest defines the request type for the FeeEnabledChannel rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryFeeEnabledChannelRequest { + /// unique port identifier + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + /// unique channel identifier + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryFeeEnabledChannelRequest { +const NAME: &'static str = "QueryFeeEnabledChannelRequest"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.QueryFeeEnabledChannelRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.QueryFeeEnabledChannelRequest".into() }} +/// QueryFeeEnabledChannelResponse defines the response type for the FeeEnabledChannel rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct QueryFeeEnabledChannelResponse { + /// boolean flag representing the fee enabled channel status + #[prost(bool, tag="1")] + pub fee_enabled: bool, +} +impl ::prost::Name for QueryFeeEnabledChannelResponse { +const NAME: &'static str = "QueryFeeEnabledChannelResponse"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.QueryFeeEnabledChannelResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.QueryFeeEnabledChannelResponse".into() }} +/// MsgRegisterPayee defines the request type for the RegisterPayee rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgRegisterPayee { + /// unique port identifier + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + /// unique channel identifier + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + /// the relayer address + #[prost(string, tag="3")] + pub relayer: ::prost::alloc::string::String, + /// the payee address + #[prost(string, tag="4")] + pub payee: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgRegisterPayee { +const NAME: &'static str = "MsgRegisterPayee"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.MsgRegisterPayee".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.MsgRegisterPayee".into() }} +/// MsgRegisterPayeeResponse defines the response type for the RegisterPayee rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgRegisterPayeeResponse { +} +impl ::prost::Name for MsgRegisterPayeeResponse { +const NAME: &'static str = "MsgRegisterPayeeResponse"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.MsgRegisterPayeeResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.MsgRegisterPayeeResponse".into() }} +/// MsgRegisterCounterpartyPayee defines the request type for the RegisterCounterpartyPayee rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgRegisterCounterpartyPayee { + /// unique port identifier + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + /// unique channel identifier + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + /// the relayer address + #[prost(string, tag="3")] + pub relayer: ::prost::alloc::string::String, + /// the counterparty payee address + #[prost(string, tag="4")] + pub counterparty_payee: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgRegisterCounterpartyPayee { +const NAME: &'static str = "MsgRegisterCounterpartyPayee"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.MsgRegisterCounterpartyPayee".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.MsgRegisterCounterpartyPayee".into() }} +/// MsgRegisterCounterpartyPayeeResponse defines the response type for the RegisterCounterpartyPayee rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgRegisterCounterpartyPayeeResponse { +} +impl ::prost::Name for MsgRegisterCounterpartyPayeeResponse { +const NAME: &'static str = "MsgRegisterCounterpartyPayeeResponse"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.MsgRegisterCounterpartyPayeeResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.MsgRegisterCounterpartyPayeeResponse".into() }} +/// MsgPayPacketFee defines the request type for the PayPacketFee rpc +/// This Msg can be used to pay for a packet at the next sequence send & should be combined with the Msg that will be +/// paid for +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgPayPacketFee { + /// fee encapsulates the recv, ack and timeout fees associated with an IBC packet + #[prost(message, optional, tag="1")] + pub fee: ::core::option::Option, + /// the source port unique identifier + #[prost(string, tag="2")] + pub source_port_id: ::prost::alloc::string::String, + /// the source channel unique identifier + #[prost(string, tag="3")] + pub source_channel_id: ::prost::alloc::string::String, + /// account address to refund fee if necessary + #[prost(string, tag="4")] + pub signer: ::prost::alloc::string::String, + /// optional list of relayers permitted to the receive packet fees + #[prost(string, repeated, tag="5")] + pub relayers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +impl ::prost::Name for MsgPayPacketFee { +const NAME: &'static str = "MsgPayPacketFee"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.MsgPayPacketFee".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.MsgPayPacketFee".into() }} +/// MsgPayPacketFeeResponse defines the response type for the PayPacketFee rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgPayPacketFeeResponse { +} +impl ::prost::Name for MsgPayPacketFeeResponse { +const NAME: &'static str = "MsgPayPacketFeeResponse"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.MsgPayPacketFeeResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.MsgPayPacketFeeResponse".into() }} +/// MsgPayPacketFeeAsync defines the request type for the PayPacketFeeAsync rpc +/// This Msg can be used to pay for a packet at a specified sequence (instead of the next sequence send) +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgPayPacketFeeAsync { + /// unique packet identifier comprised of the channel ID, port ID and sequence + #[prost(message, optional, tag="1")] + pub packet_id: ::core::option::Option, + /// the packet fee associated with a particular IBC packet + #[prost(message, optional, tag="2")] + pub packet_fee: ::core::option::Option, +} +impl ::prost::Name for MsgPayPacketFeeAsync { +const NAME: &'static str = "MsgPayPacketFeeAsync"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.MsgPayPacketFeeAsync".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.MsgPayPacketFeeAsync".into() }} +/// MsgPayPacketFeeAsyncResponse defines the response type for the PayPacketFeeAsync rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgPayPacketFeeAsyncResponse { +} +impl ::prost::Name for MsgPayPacketFeeAsyncResponse { +const NAME: &'static str = "MsgPayPacketFeeAsyncResponse"; +const PACKAGE: &'static str = "ibc.applications.fee.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.fee.v1.MsgPayPacketFeeAsyncResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.fee.v1.MsgPayPacketFeeAsyncResponse".into() }} +// @@protoc_insertion_point(module) diff --git a/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.interchain_accounts.controller.v1.rs b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.interchain_accounts.controller.v1.rs new file mode 100644 index 00000000000..6ab62cb6320 --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.interchain_accounts.controller.v1.rs @@ -0,0 +1,147 @@ +// @generated +// This file is @generated by prost-build. +/// Params defines the set of on-chain interchain accounts parameters. +/// The following parameters may be used to disable the controller submodule. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct Params { + /// controller_enabled enables or disables the controller submodule. + #[prost(bool, tag="1")] + pub controller_enabled: bool, +} +impl ::prost::Name for Params { +const NAME: &'static str = "Params"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.controller.v1.Params".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.controller.v1.Params".into() }} +/// QueryInterchainAccountRequest is the request type for the Query/InterchainAccount RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryInterchainAccountRequest { + #[prost(string, tag="1")] + pub owner: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub connection_id: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryInterchainAccountRequest { +const NAME: &'static str = "QueryInterchainAccountRequest"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountRequest".into() }} +/// QueryInterchainAccountResponse the response type for the Query/InterchainAccount RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryInterchainAccountResponse { + #[prost(string, tag="1")] + pub address: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryInterchainAccountResponse { +const NAME: &'static str = "QueryInterchainAccountResponse"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountResponse".into() }} +/// QueryParamsRequest is the request type for the Query/Params RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct QueryParamsRequest { +} +impl ::prost::Name for QueryParamsRequest { +const NAME: &'static str = "QueryParamsRequest"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.controller.v1.QueryParamsRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.controller.v1.QueryParamsRequest".into() }} +/// QueryParamsResponse is the response type for the Query/Params RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct QueryParamsResponse { + /// params defines the parameters of the module. + #[prost(message, optional, tag="1")] + pub params: ::core::option::Option, +} +impl ::prost::Name for QueryParamsResponse { +const NAME: &'static str = "QueryParamsResponse"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.controller.v1.QueryParamsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.controller.v1.QueryParamsResponse".into() }} +/// MsgRegisterInterchainAccount defines the payload for Msg/RegisterAccount +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgRegisterInterchainAccount { + #[prost(string, tag="1")] + pub owner: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub connection_id: ::prost::alloc::string::String, + #[prost(string, tag="3")] + pub version: ::prost::alloc::string::String, + #[prost(enumeration="super::super::super::super::core::channel::v1::Order", tag="4")] + pub ordering: i32, +} +impl ::prost::Name for MsgRegisterInterchainAccount { +const NAME: &'static str = "MsgRegisterInterchainAccount"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccount".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccount".into() }} +/// MsgRegisterInterchainAccountResponse defines the response for Msg/RegisterAccount +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgRegisterInterchainAccountResponse { + #[prost(string, tag="1")] + pub channel_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub port_id: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgRegisterInterchainAccountResponse { +const NAME: &'static str = "MsgRegisterInterchainAccountResponse"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccountResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccountResponse".into() }} +/// MsgSendTx defines the payload for Msg/SendTx +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgSendTx { + #[prost(string, tag="1")] + pub owner: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub connection_id: ::prost::alloc::string::String, + #[prost(message, optional, tag="3")] + pub packet_data: ::core::option::Option, + /// Relative timeout timestamp provided will be added to the current block time during transaction execution. + /// The timeout timestamp must be non-zero. + #[prost(uint64, tag="4")] + pub relative_timeout: u64, +} +impl ::prost::Name for MsgSendTx { +const NAME: &'static str = "MsgSendTx"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.controller.v1.MsgSendTx".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.controller.v1.MsgSendTx".into() }} +/// MsgSendTxResponse defines the response for MsgSendTx +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgSendTxResponse { + #[prost(uint64, tag="1")] + pub sequence: u64, +} +impl ::prost::Name for MsgSendTxResponse { +const NAME: &'static str = "MsgSendTxResponse"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.controller.v1.MsgSendTxResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.controller.v1.MsgSendTxResponse".into() }} +/// MsgUpdateParams defines the payload for Msg/UpdateParams +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgUpdateParams { + /// signer address + #[prost(string, tag="1")] + pub signer: ::prost::alloc::string::String, + /// params defines the 27-interchain-accounts/controller parameters to update. + /// + /// NOTE: All parameters must be supplied. + #[prost(message, optional, tag="2")] + pub params: ::core::option::Option, +} +impl ::prost::Name for MsgUpdateParams { +const NAME: &'static str = "MsgUpdateParams"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.controller.v1.MsgUpdateParams".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.controller.v1.MsgUpdateParams".into() }} +/// MsgUpdateParamsResponse defines the response for Msg/UpdateParams +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgUpdateParamsResponse { +} +impl ::prost::Name for MsgUpdateParamsResponse { +const NAME: &'static str = "MsgUpdateParamsResponse"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.controller.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.controller.v1.MsgUpdateParamsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.controller.v1.MsgUpdateParamsResponse".into() }} +// @@protoc_insertion_point(module) diff --git a/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.interchain_accounts.genesis.v1.rs b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.interchain_accounts.genesis.v1.rs new file mode 100644 index 00000000000..f5b256e3b7e --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.interchain_accounts.genesis.v1.rs @@ -0,0 +1,83 @@ +// @generated +// This file is @generated by prost-build. +/// GenesisState defines the interchain accounts genesis state +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GenesisState { + #[prost(message, optional, tag="1")] + pub controller_genesis_state: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub host_genesis_state: ::core::option::Option, +} +impl ::prost::Name for GenesisState { +const NAME: &'static str = "GenesisState"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.genesis.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.genesis.v1.GenesisState".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.genesis.v1.GenesisState".into() }} +/// ControllerGenesisState defines the interchain accounts controller genesis state +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ControllerGenesisState { + #[prost(message, repeated, tag="1")] + pub active_channels: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="2")] + pub interchain_accounts: ::prost::alloc::vec::Vec, + #[prost(string, repeated, tag="3")] + pub ports: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(message, optional, tag="4")] + pub params: ::core::option::Option, +} +impl ::prost::Name for ControllerGenesisState { +const NAME: &'static str = "ControllerGenesisState"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.genesis.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.genesis.v1.ControllerGenesisState".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.genesis.v1.ControllerGenesisState".into() }} +/// HostGenesisState defines the interchain accounts host genesis state +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct HostGenesisState { + #[prost(message, repeated, tag="1")] + pub active_channels: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="2")] + pub interchain_accounts: ::prost::alloc::vec::Vec, + #[prost(string, tag="3")] + pub port: ::prost::alloc::string::String, + #[prost(message, optional, tag="4")] + pub params: ::core::option::Option, +} +impl ::prost::Name for HostGenesisState { +const NAME: &'static str = "HostGenesisState"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.genesis.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.genesis.v1.HostGenesisState".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.genesis.v1.HostGenesisState".into() }} +/// ActiveChannel contains a connection ID, port ID and associated active channel ID, as well as a boolean flag to +/// indicate if the channel is middleware enabled +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ActiveChannel { + #[prost(string, tag="1")] + pub connection_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag="3")] + pub channel_id: ::prost::alloc::string::String, + #[prost(bool, tag="4")] + pub is_middleware_enabled: bool, +} +impl ::prost::Name for ActiveChannel { +const NAME: &'static str = "ActiveChannel"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.genesis.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.genesis.v1.ActiveChannel".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.genesis.v1.ActiveChannel".into() }} +/// RegisteredInterchainAccount contains a connection ID, port ID and associated interchain account address +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RegisteredInterchainAccount { + #[prost(string, tag="1")] + pub connection_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag="3")] + pub account_address: ::prost::alloc::string::String, +} +impl ::prost::Name for RegisteredInterchainAccount { +const NAME: &'static str = "RegisteredInterchainAccount"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.genesis.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.genesis.v1.RegisteredInterchainAccount".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.genesis.v1.RegisteredInterchainAccount".into() }} +// @@protoc_insertion_point(module) diff --git a/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.interchain_accounts.host.v1.rs b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.interchain_accounts.host.v1.rs new file mode 100644 index 00000000000..4d5d45b7313 --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.interchain_accounts.host.v1.rs @@ -0,0 +1,114 @@ +// @generated +// This file is @generated by prost-build. +/// Params defines the set of on-chain interchain accounts parameters. +/// The following parameters may be used to disable the host submodule. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Params { + /// host_enabled enables or disables the host submodule. + #[prost(bool, tag="1")] + pub host_enabled: bool, + /// allow_messages defines a list of sdk message typeURLs allowed to be executed on a host chain. + #[prost(string, repeated, tag="2")] + pub allow_messages: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +impl ::prost::Name for Params { +const NAME: &'static str = "Params"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.host.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.host.v1.Params".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.host.v1.Params".into() }} +/// QueryRequest defines the parameters for a particular query request +/// by an interchain account. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryRequest { + /// path defines the path of the query request as defined by ADR-021. + /// + #[prost(string, tag="1")] + pub path: ::prost::alloc::string::String, + /// data defines the payload of the query request as defined by ADR-021. + /// + #[prost(bytes="vec", tag="2")] + pub data: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for QueryRequest { +const NAME: &'static str = "QueryRequest"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.host.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.host.v1.QueryRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.host.v1.QueryRequest".into() }} +/// QueryParamsRequest is the request type for the Query/Params RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct QueryParamsRequest { +} +impl ::prost::Name for QueryParamsRequest { +const NAME: &'static str = "QueryParamsRequest"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.host.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.host.v1.QueryParamsRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.host.v1.QueryParamsRequest".into() }} +/// QueryParamsResponse is the response type for the Query/Params RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryParamsResponse { + /// params defines the parameters of the module. + #[prost(message, optional, tag="1")] + pub params: ::core::option::Option, +} +impl ::prost::Name for QueryParamsResponse { +const NAME: &'static str = "QueryParamsResponse"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.host.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.host.v1.QueryParamsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.host.v1.QueryParamsResponse".into() }} +/// MsgUpdateParams defines the payload for Msg/UpdateParams +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgUpdateParams { + /// signer address + #[prost(string, tag="1")] + pub signer: ::prost::alloc::string::String, + /// params defines the 27-interchain-accounts/host parameters to update. + /// + /// NOTE: All parameters must be supplied. + #[prost(message, optional, tag="2")] + pub params: ::core::option::Option, +} +impl ::prost::Name for MsgUpdateParams { +const NAME: &'static str = "MsgUpdateParams"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.host.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.host.v1.MsgUpdateParams".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.host.v1.MsgUpdateParams".into() }} +/// MsgUpdateParamsResponse defines the response for Msg/UpdateParams +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgUpdateParamsResponse { +} +impl ::prost::Name for MsgUpdateParamsResponse { +const NAME: &'static str = "MsgUpdateParamsResponse"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.host.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.host.v1.MsgUpdateParamsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.host.v1.MsgUpdateParamsResponse".into() }} +/// MsgModuleQuerySafe defines the payload for Msg/ModuleQuerySafe +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgModuleQuerySafe { + /// signer address + #[prost(string, tag="1")] + pub signer: ::prost::alloc::string::String, + /// requests defines the module safe queries to execute. + #[prost(message, repeated, tag="2")] + pub requests: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for MsgModuleQuerySafe { +const NAME: &'static str = "MsgModuleQuerySafe"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.host.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafe".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafe".into() }} +/// MsgModuleQuerySafeResponse defines the response for Msg/ModuleQuerySafe +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgModuleQuerySafeResponse { + /// height at which the responses were queried + #[prost(uint64, tag="1")] + pub height: u64, + /// protobuf encoded responses for each query + #[prost(bytes="vec", repeated, tag="2")] + pub responses: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, +} +impl ::prost::Name for MsgModuleQuerySafeResponse { +const NAME: &'static str = "MsgModuleQuerySafeResponse"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.host.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafeResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafeResponse".into() }} +// @@protoc_insertion_point(module) diff --git a/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.interchain_accounts.v1.rs b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.interchain_accounts.v1.rs new file mode 100644 index 00000000000..5ce9931bd22 --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.interchain_accounts.v1.rs @@ -0,0 +1,101 @@ +// @generated +// This file is @generated by prost-build. +/// InterchainAccountPacketData is comprised of a raw transaction, type of transaction and optional memo field. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InterchainAccountPacketData { + #[prost(enumeration="Type", tag="1")] + pub r#type: i32, + #[prost(bytes="vec", tag="2")] + pub data: ::prost::alloc::vec::Vec, + #[prost(string, tag="3")] + pub memo: ::prost::alloc::string::String, +} +impl ::prost::Name for InterchainAccountPacketData { +const NAME: &'static str = "InterchainAccountPacketData"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.v1.InterchainAccountPacketData".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.v1.InterchainAccountPacketData".into() }} +/// CosmosTx contains a list of sdk.Msg's. It should be used when sending transactions to an SDK host chain. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CosmosTx { + #[prost(message, repeated, tag="1")] + pub messages: ::prost::alloc::vec::Vec<::tendermint_proto::google::protobuf::Any>, +} +impl ::prost::Name for CosmosTx { +const NAME: &'static str = "CosmosTx"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.v1.CosmosTx".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.v1.CosmosTx".into() }} +/// Type defines a classification of message issued from a controller chain to its associated interchain accounts +/// host +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum Type { + /// Default zero value enumeration + Unspecified = 0, + /// Execute a transaction on an interchain accounts host chain + ExecuteTx = 1, +} +impl Type { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Type::Unspecified => "TYPE_UNSPECIFIED", + Type::ExecuteTx => "TYPE_EXECUTE_TX", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "TYPE_UNSPECIFIED" => Some(Self::Unspecified), + "TYPE_EXECUTE_TX" => Some(Self::ExecuteTx), + _ => None, + } + } +} +/// An InterchainAccount is defined as a BaseAccount & the address of the account owner on the controller chain +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InterchainAccount { + #[prost(message, optional, tag="1")] + pub base_account: ::core::option::Option<::cosmos_sdk_proto::cosmos::auth::v1beta1::BaseAccount>, + #[prost(string, tag="2")] + pub account_owner: ::prost::alloc::string::String, +} +impl ::prost::Name for InterchainAccount { +const NAME: &'static str = "InterchainAccount"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.v1.InterchainAccount".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.v1.InterchainAccount".into() }} +/// Metadata defines a set of protocol specific data encoded into the ICS27 channel version bytestring +/// See ICS004: +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Metadata { + /// version defines the ICS27 protocol version + #[prost(string, tag="1")] + pub version: ::prost::alloc::string::String, + /// controller_connection_id is the connection identifier associated with the controller chain + #[prost(string, tag="2")] + pub controller_connection_id: ::prost::alloc::string::String, + /// host_connection_id is the connection identifier associated with the host chain + #[prost(string, tag="3")] + pub host_connection_id: ::prost::alloc::string::String, + /// address defines the interchain account address to be fulfilled upon the OnChanOpenTry handshake step + /// NOTE: the address field is empty on the OnChanOpenInit handshake step + #[prost(string, tag="4")] + pub address: ::prost::alloc::string::String, + /// encoding defines the supported codec format + #[prost(string, tag="5")] + pub encoding: ::prost::alloc::string::String, + /// tx_type defines the type of transactions the interchain account can execute + #[prost(string, tag="6")] + pub tx_type: ::prost::alloc::string::String, +} +impl ::prost::Name for Metadata { +const NAME: &'static str = "Metadata"; +const PACKAGE: &'static str = "ibc.applications.interchain_accounts.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.interchain_accounts.v1.Metadata".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.interchain_accounts.v1.Metadata".into() }} +// @@protoc_insertion_point(module) diff --git a/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.transfer.v1.rs b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.transfer.v1.rs new file mode 100644 index 00000000000..c41636b6b03 --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.transfer.v1.rs @@ -0,0 +1,304 @@ +// @generated +// This file is @generated by prost-build. +/// Params defines the set of IBC transfer parameters. +/// NOTE: To prevent a single token from being transferred, set the +/// TransfersEnabled parameter to true and then set the bank module's SendEnabled +/// parameter for the denomination to false. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct Params { + /// send_enabled enables or disables all cross-chain token transfers from this + /// chain. + #[prost(bool, tag="1")] + pub send_enabled: bool, + /// receive_enabled enables or disables all cross-chain token transfers to this + /// chain. + #[prost(bool, tag="2")] + pub receive_enabled: bool, +} +impl ::prost::Name for Params { +const NAME: &'static str = "Params"; +const PACKAGE: &'static str = "ibc.applications.transfer.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v1.Params".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v1.Params".into() }} +/// Forwarding defines a list of port ID, channel ID pairs determining the path +/// through which a packet must be forwarded, and an unwind boolean indicating if +/// the coin should be unwinded to its native chain before forwarding. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Forwarding { + /// optional unwinding for the token transfered + #[prost(bool, tag="1")] + pub unwind: bool, + /// optional intermediate path through which packet will be forwarded + #[prost(message, repeated, tag="2")] + pub hops: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for Forwarding { +const NAME: &'static str = "Forwarding"; +const PACKAGE: &'static str = "ibc.applications.transfer.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v1.Forwarding".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v1.Forwarding".into() }} +/// Hop defines a port ID, channel ID pair specifying where tokens must be forwarded +/// next in a multihop transfer. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Hop { + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, +} +impl ::prost::Name for Hop { +const NAME: &'static str = "Hop"; +const PACKAGE: &'static str = "ibc.applications.transfer.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v1.Hop".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v1.Hop".into() }} +/// Allocation defines the spend limit for a particular port and channel +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Allocation { + /// the port on which the packet will be sent + #[prost(string, tag="1")] + pub source_port: ::prost::alloc::string::String, + /// the channel by which the packet will be sent + #[prost(string, tag="2")] + pub source_channel: ::prost::alloc::string::String, + /// spend limitation on the channel + #[prost(message, repeated, tag="3")] + pub spend_limit: ::prost::alloc::vec::Vec<::cosmos_sdk_proto::cosmos::base::v1beta1::Coin>, + /// allow list of receivers, an empty allow list permits any receiver address + #[prost(string, repeated, tag="4")] + pub allow_list: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// allow list of memo strings, an empty list prohibits all memo strings; + /// a list only with "*" permits any memo string + #[prost(string, repeated, tag="5")] + pub allowed_packet_data: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Forwarding options that are allowed. + #[prost(message, repeated, tag="6")] + pub allowed_forwarding: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for Allocation { +const NAME: &'static str = "Allocation"; +const PACKAGE: &'static str = "ibc.applications.transfer.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v1.Allocation".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v1.Allocation".into() }} +/// AllowedForwarding defines which options are allowed for forwarding. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AllowedForwarding { + /// a list of allowed source port ID/channel ID pairs through which the packet is allowed to be forwarded until final + /// destination + #[prost(message, repeated, tag="1")] + pub hops: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for AllowedForwarding { +const NAME: &'static str = "AllowedForwarding"; +const PACKAGE: &'static str = "ibc.applications.transfer.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v1.AllowedForwarding".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v1.AllowedForwarding".into() }} +/// TransferAuthorization allows the grantee to spend up to spend_limit coins from +/// the granter's account for ibc transfer on a specific channel +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TransferAuthorization { + /// port and channel amounts + #[prost(message, repeated, tag="1")] + pub allocations: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for TransferAuthorization { +const NAME: &'static str = "TransferAuthorization"; +const PACKAGE: &'static str = "ibc.applications.transfer.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v1.TransferAuthorization".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v1.TransferAuthorization".into() }} +/// DenomTrace contains the base denomination for ICS20 fungible tokens and the +/// source tracing information path. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DenomTrace { + /// path defines the chain of port/channel identifiers used for tracing the + /// source of the fungible token. + #[prost(string, tag="1")] + pub path: ::prost::alloc::string::String, + /// base denomination of the relayed fungible token. + #[prost(string, tag="2")] + pub base_denom: ::prost::alloc::string::String, +} +impl ::prost::Name for DenomTrace { +const NAME: &'static str = "DenomTrace"; +const PACKAGE: &'static str = "ibc.applications.transfer.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v1.DenomTrace".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v1.DenomTrace".into() }} +/// QueryParamsRequest is the request type for the Query/Params RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct QueryParamsRequest { +} +impl ::prost::Name for QueryParamsRequest { +const NAME: &'static str = "QueryParamsRequest"; +const PACKAGE: &'static str = "ibc.applications.transfer.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v1.QueryParamsRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v1.QueryParamsRequest".into() }} +/// QueryParamsResponse is the response type for the Query/Params RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct QueryParamsResponse { + /// params defines the parameters of the module. + #[prost(message, optional, tag="1")] + pub params: ::core::option::Option, +} +impl ::prost::Name for QueryParamsResponse { +const NAME: &'static str = "QueryParamsResponse"; +const PACKAGE: &'static str = "ibc.applications.transfer.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v1.QueryParamsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v1.QueryParamsResponse".into() }} +/// QueryDenomHashRequest is the request type for the Query/DenomHash RPC +/// method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryDenomHashRequest { + /// The denomination trace (\[port_id\]/[channel_id])+/\[denom\] + #[prost(string, tag="1")] + pub trace: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryDenomHashRequest { +const NAME: &'static str = "QueryDenomHashRequest"; +const PACKAGE: &'static str = "ibc.applications.transfer.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v1.QueryDenomHashRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v1.QueryDenomHashRequest".into() }} +/// QueryDenomHashResponse is the response type for the Query/DenomHash RPC +/// method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryDenomHashResponse { + /// hash (in hex format) of the denomination trace information. + #[prost(string, tag="1")] + pub hash: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryDenomHashResponse { +const NAME: &'static str = "QueryDenomHashResponse"; +const PACKAGE: &'static str = "ibc.applications.transfer.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v1.QueryDenomHashResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v1.QueryDenomHashResponse".into() }} +/// QueryEscrowAddressRequest is the request type for the EscrowAddress RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryEscrowAddressRequest { + /// unique port identifier + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + /// unique channel identifier + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryEscrowAddressRequest { +const NAME: &'static str = "QueryEscrowAddressRequest"; +const PACKAGE: &'static str = "ibc.applications.transfer.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v1.QueryEscrowAddressRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v1.QueryEscrowAddressRequest".into() }} +/// QueryEscrowAddressResponse is the response type of the EscrowAddress RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryEscrowAddressResponse { + /// the escrow account address + #[prost(string, tag="1")] + pub escrow_address: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryEscrowAddressResponse { +const NAME: &'static str = "QueryEscrowAddressResponse"; +const PACKAGE: &'static str = "ibc.applications.transfer.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v1.QueryEscrowAddressResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v1.QueryEscrowAddressResponse".into() }} +/// QueryTotalEscrowForDenomRequest is the request type for TotalEscrowForDenom RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryTotalEscrowForDenomRequest { + #[prost(string, tag="1")] + pub denom: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryTotalEscrowForDenomRequest { +const NAME: &'static str = "QueryTotalEscrowForDenomRequest"; +const PACKAGE: &'static str = "ibc.applications.transfer.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v1.QueryTotalEscrowForDenomRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v1.QueryTotalEscrowForDenomRequest".into() }} +/// QueryTotalEscrowForDenomResponse is the response type for TotalEscrowForDenom RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryTotalEscrowForDenomResponse { + #[prost(message, optional, tag="1")] + pub amount: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::v1beta1::Coin>, +} +impl ::prost::Name for QueryTotalEscrowForDenomResponse { +const NAME: &'static str = "QueryTotalEscrowForDenomResponse"; +const PACKAGE: &'static str = "ibc.applications.transfer.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v1.QueryTotalEscrowForDenomResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v1.QueryTotalEscrowForDenomResponse".into() }} +/// MsgTransfer defines a msg to transfer fungible tokens (i.e Coins) between +/// ICS20 enabled chains. See ICS Spec here: +/// +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgTransfer { + /// the port on which the packet will be sent + #[prost(string, tag="1")] + pub source_port: ::prost::alloc::string::String, + /// the channel by which the packet will be sent + #[prost(string, tag="2")] + pub source_channel: ::prost::alloc::string::String, + /// the token to be transferred. this field has been replaced by the tokens field. + #[deprecated] + #[prost(message, optional, tag="3")] + pub token: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::v1beta1::Coin>, + /// the sender address + #[prost(string, tag="4")] + pub sender: ::prost::alloc::string::String, + /// the recipient address on the destination chain + #[prost(string, tag="5")] + pub receiver: ::prost::alloc::string::String, + /// Timeout height relative to the current block height. + /// The timeout is disabled when set to 0. + #[prost(message, optional, tag="6")] + pub timeout_height: ::core::option::Option, + /// Timeout timestamp in absolute nanoseconds since unix epoch. + /// The timeout is disabled when set to 0. + #[prost(uint64, tag="7")] + pub timeout_timestamp: u64, + /// optional memo + #[prost(string, tag="8")] + pub memo: ::prost::alloc::string::String, + /// tokens to be transferred + #[prost(message, repeated, tag="9")] + pub tokens: ::prost::alloc::vec::Vec<::cosmos_sdk_proto::cosmos::base::v1beta1::Coin>, + /// optional forwarding information + #[prost(message, optional, tag="10")] + pub forwarding: ::core::option::Option, +} +impl ::prost::Name for MsgTransfer { +const NAME: &'static str = "MsgTransfer"; +const PACKAGE: &'static str = "ibc.applications.transfer.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v1.MsgTransfer".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v1.MsgTransfer".into() }} +/// MsgTransferResponse defines the Msg/Transfer response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgTransferResponse { + /// sequence number of the transfer packet sent + #[prost(uint64, tag="1")] + pub sequence: u64, +} +impl ::prost::Name for MsgTransferResponse { +const NAME: &'static str = "MsgTransferResponse"; +const PACKAGE: &'static str = "ibc.applications.transfer.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v1.MsgTransferResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v1.MsgTransferResponse".into() }} +/// MsgUpdateParams is the Msg/UpdateParams request type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgUpdateParams { + /// signer address + #[prost(string, tag="1")] + pub signer: ::prost::alloc::string::String, + /// params defines the transfer parameters to update. + /// + /// NOTE: All parameters must be supplied. + #[prost(message, optional, tag="2")] + pub params: ::core::option::Option, +} +impl ::prost::Name for MsgUpdateParams { +const NAME: &'static str = "MsgUpdateParams"; +const PACKAGE: &'static str = "ibc.applications.transfer.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v1.MsgUpdateParams".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v1.MsgUpdateParams".into() }} +/// MsgUpdateParamsResponse defines the response structure for executing a +/// MsgUpdateParams message. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgUpdateParamsResponse { +} +impl ::prost::Name for MsgUpdateParamsResponse { +const NAME: &'static str = "MsgUpdateParamsResponse"; +const PACKAGE: &'static str = "ibc.applications.transfer.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v1.MsgUpdateParamsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v1.MsgUpdateParamsResponse".into() }} +// @@protoc_insertion_point(module) diff --git a/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.transfer.v2.rs b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.transfer.v2.rs new file mode 100644 index 00000000000..e9d12604f6e --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.applications.transfer.v2.rs @@ -0,0 +1,193 @@ +// @generated +// This file is @generated by prost-build. +/// Token defines a struct which represents a token to be transferred. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Token { + /// the token denomination + #[prost(message, optional, tag="1")] + pub denom: ::core::option::Option, + /// the token amount to be transferred + #[prost(string, tag="2")] + pub amount: ::prost::alloc::string::String, +} +impl ::prost::Name for Token { +const NAME: &'static str = "Token"; +const PACKAGE: &'static str = "ibc.applications.transfer.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v2.Token".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v2.Token".into() }} +/// Denom holds the base denom of a Token and a trace of the chains it was sent through. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Denom { + /// the base token denomination + #[prost(string, tag="1")] + pub base: ::prost::alloc::string::String, + /// the trace of the token + #[prost(message, repeated, tag="3")] + pub trace: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for Denom { +const NAME: &'static str = "Denom"; +const PACKAGE: &'static str = "ibc.applications.transfer.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v2.Denom".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v2.Denom".into() }} +/// GenesisState defines the ibc-transfer genesis state +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GenesisState { + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + #[prost(message, repeated, tag="2")] + pub denoms: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="3")] + pub params: ::core::option::Option, + /// total_escrowed contains the total amount of tokens escrowed + /// by the transfer module + #[prost(message, repeated, tag="4")] + pub total_escrowed: ::prost::alloc::vec::Vec<::cosmos_sdk_proto::cosmos::base::v1beta1::Coin>, + /// forwarded_packets contains the forwarded packets stored as part of the + /// packet forwarding lifecycle + #[prost(message, repeated, tag="5")] + pub forwarded_packets: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for GenesisState { +const NAME: &'static str = "GenesisState"; +const PACKAGE: &'static str = "ibc.applications.transfer.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v2.GenesisState".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v2.GenesisState".into() }} +/// ForwardedPacket defines the genesis type necessary to retrieve and store forwarded packets. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ForwardedPacket { + #[prost(message, optional, tag="1")] + pub forward_key: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub packet: ::core::option::Option, +} +impl ::prost::Name for ForwardedPacket { +const NAME: &'static str = "ForwardedPacket"; +const PACKAGE: &'static str = "ibc.applications.transfer.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v2.ForwardedPacket".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v2.ForwardedPacket".into() }} +/// FungibleTokenPacketData defines a struct for the packet payload +/// See FungibleTokenPacketData spec: +/// +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FungibleTokenPacketData { + /// the token denomination to be transferred + #[prost(string, tag="1")] + pub denom: ::prost::alloc::string::String, + /// the token amount to be transferred + #[prost(string, tag="2")] + pub amount: ::prost::alloc::string::String, + /// the sender address + #[prost(string, tag="3")] + pub sender: ::prost::alloc::string::String, + /// the recipient address on the destination chain + #[prost(string, tag="4")] + pub receiver: ::prost::alloc::string::String, + /// optional memo + #[prost(string, tag="5")] + pub memo: ::prost::alloc::string::String, +} +impl ::prost::Name for FungibleTokenPacketData { +const NAME: &'static str = "FungibleTokenPacketData"; +const PACKAGE: &'static str = "ibc.applications.transfer.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v2.FungibleTokenPacketData".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v2.FungibleTokenPacketData".into() }} +/// FungibleTokenPacketDataV2 defines a struct for the packet payload +/// See FungibleTokenPacketDataV2 spec: +/// +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct FungibleTokenPacketDataV2 { + /// the tokens to be transferred + #[prost(message, repeated, tag="1")] + pub tokens: ::prost::alloc::vec::Vec, + /// the sender address + #[prost(string, tag="2")] + pub sender: ::prost::alloc::string::String, + /// the recipient address on the destination chain + #[prost(string, tag="3")] + pub receiver: ::prost::alloc::string::String, + /// optional memo + #[prost(string, tag="4")] + pub memo: ::prost::alloc::string::String, + /// optional forwarding information + #[prost(message, optional, tag="5")] + pub forwarding: ::core::option::Option, +} +impl ::prost::Name for FungibleTokenPacketDataV2 { +const NAME: &'static str = "FungibleTokenPacketDataV2"; +const PACKAGE: &'static str = "ibc.applications.transfer.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v2.FungibleTokenPacketDataV2".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v2.FungibleTokenPacketDataV2".into() }} +/// ForwardingPacketData defines a list of port ID, channel ID pairs determining the path +/// through which a packet must be forwarded, and the destination memo string to be used in the +/// final destination of the tokens. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ForwardingPacketData { + /// optional memo consumed by final destination chain + #[prost(string, tag="1")] + pub destination_memo: ::prost::alloc::string::String, + /// optional intermediate path through which packet will be forwarded. + #[prost(message, repeated, tag="2")] + pub hops: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for ForwardingPacketData { +const NAME: &'static str = "ForwardingPacketData"; +const PACKAGE: &'static str = "ibc.applications.transfer.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v2.ForwardingPacketData".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v2.ForwardingPacketData".into() }} +/// QueryDenomRequest is the request type for the Query/Denom RPC +/// method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryDenomRequest { + /// hash (in hex format) or denom (full denom with ibc prefix) of the on chain denomination. + #[prost(string, tag="1")] + pub hash: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryDenomRequest { +const NAME: &'static str = "QueryDenomRequest"; +const PACKAGE: &'static str = "ibc.applications.transfer.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v2.QueryDenomRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v2.QueryDenomRequest".into() }} +/// QueryDenomResponse is the response type for the Query/Denom RPC +/// method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryDenomResponse { + /// denom returns the requested denomination. + #[prost(message, optional, tag="1")] + pub denom: ::core::option::Option, +} +impl ::prost::Name for QueryDenomResponse { +const NAME: &'static str = "QueryDenomResponse"; +const PACKAGE: &'static str = "ibc.applications.transfer.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v2.QueryDenomResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v2.QueryDenomResponse".into() }} +/// QueryDenomsRequest is the request type for the Query/Denoms RPC +/// method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryDenomsRequest { + /// pagination defines an optional pagination for the request. + #[prost(message, optional, tag="1")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageRequest>, +} +impl ::prost::Name for QueryDenomsRequest { +const NAME: &'static str = "QueryDenomsRequest"; +const PACKAGE: &'static str = "ibc.applications.transfer.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v2.QueryDenomsRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v2.QueryDenomsRequest".into() }} +/// QueryDenomsResponse is the response type for the Query/Denoms RPC +/// method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryDenomsResponse { + /// denoms returns all denominations. + #[prost(message, repeated, tag="1")] + pub denoms: ::prost::alloc::vec::Vec, + /// pagination defines the pagination in the response. + #[prost(message, optional, tag="2")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageResponse>, +} +impl ::prost::Name for QueryDenomsResponse { +const NAME: &'static str = "QueryDenomsResponse"; +const PACKAGE: &'static str = "ibc.applications.transfer.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.applications.transfer.v2.QueryDenomsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.applications.transfer.v2.QueryDenomsResponse".into() }} +// @@protoc_insertion_point(module) diff --git a/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.channel.v1.rs b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.channel.v1.rs new file mode 100644 index 00000000000..0b6afeea118 --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.channel.v1.rs @@ -0,0 +1,1645 @@ +// @generated +// This file is @generated by prost-build. +/// Channel defines pipeline for exactly-once packet delivery between specific +/// modules on separate blockchains, which has at least one end capable of +/// sending packets and one end capable of receiving packets. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Channel { + /// current state of the channel end + #[prost(enumeration="State", tag="1")] + pub state: i32, + /// whether the channel is ordered or unordered + #[prost(enumeration="Order", tag="2")] + pub ordering: i32, + /// counterparty channel end + #[prost(message, optional, tag="3")] + pub counterparty: ::core::option::Option, + /// list of connection identifiers, in order, along which packets sent on + /// this channel will travel + #[prost(string, repeated, tag="4")] + pub connection_hops: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// opaque channel version, which is agreed upon during the handshake + #[prost(string, tag="5")] + pub version: ::prost::alloc::string::String, + /// upgrade sequence indicates the latest upgrade attempt performed by this channel + /// the value of 0 indicates the channel has never been upgraded + #[prost(uint64, tag="6")] + pub upgrade_sequence: u64, +} +impl ::prost::Name for Channel { +const NAME: &'static str = "Channel"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.Channel".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.Channel".into() }} +/// IdentifiedChannel defines a channel with additional port and channel +/// identifier fields. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IdentifiedChannel { + /// current state of the channel end + #[prost(enumeration="State", tag="1")] + pub state: i32, + /// whether the channel is ordered or unordered + #[prost(enumeration="Order", tag="2")] + pub ordering: i32, + /// counterparty channel end + #[prost(message, optional, tag="3")] + pub counterparty: ::core::option::Option, + /// list of connection identifiers, in order, along which packets sent on + /// this channel will travel + #[prost(string, repeated, tag="4")] + pub connection_hops: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// opaque channel version, which is agreed upon during the handshake + #[prost(string, tag="5")] + pub version: ::prost::alloc::string::String, + /// port identifier + #[prost(string, tag="6")] + pub port_id: ::prost::alloc::string::String, + /// channel identifier + #[prost(string, tag="7")] + pub channel_id: ::prost::alloc::string::String, + /// upgrade sequence indicates the latest upgrade attempt performed by this channel + /// the value of 0 indicates the channel has never been upgraded + #[prost(uint64, tag="8")] + pub upgrade_sequence: u64, +} +impl ::prost::Name for IdentifiedChannel { +const NAME: &'static str = "IdentifiedChannel"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.IdentifiedChannel".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.IdentifiedChannel".into() }} +/// Counterparty defines a channel end counterparty +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Counterparty { + /// port on the counterparty chain which owns the other end of the channel. + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + /// channel end on the counterparty chain + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, +} +impl ::prost::Name for Counterparty { +const NAME: &'static str = "Counterparty"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.Counterparty".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.Counterparty".into() }} +/// Packet defines a type that carries data across different chains through IBC +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Packet { + /// number corresponds to the order of sends and receives, where a Packet + /// with an earlier sequence number must be sent and received before a Packet + /// with a later sequence number. + #[prost(uint64, tag="1")] + pub sequence: u64, + /// identifies the port on the sending chain. + #[prost(string, tag="2")] + pub source_port: ::prost::alloc::string::String, + /// identifies the channel end on the sending chain. + #[prost(string, tag="3")] + pub source_channel: ::prost::alloc::string::String, + /// identifies the port on the receiving chain. + #[prost(string, tag="4")] + pub destination_port: ::prost::alloc::string::String, + /// identifies the channel end on the receiving chain. + #[prost(string, tag="5")] + pub destination_channel: ::prost::alloc::string::String, + /// actual opaque bytes transferred directly to the application module + #[prost(bytes="vec", tag="6")] + pub data: ::prost::alloc::vec::Vec, + /// block height after which the packet times out + #[prost(message, optional, tag="7")] + pub timeout_height: ::core::option::Option, + /// block timestamp (in nanoseconds) after which the packet times out + #[prost(uint64, tag="8")] + pub timeout_timestamp: u64, +} +impl ::prost::Name for Packet { +const NAME: &'static str = "Packet"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.Packet".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.Packet".into() }} +/// PacketState defines the generic type necessary to retrieve and store +/// packet commitments, acknowledgements, and receipts. +/// Caller is responsible for knowing the context necessary to interpret this +/// state as a commitment, acknowledgement, or a receipt. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PacketState { + /// channel port identifier. + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + /// channel unique identifier. + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + /// packet sequence. + #[prost(uint64, tag="3")] + pub sequence: u64, + /// embedded data that represents packet state. + #[prost(bytes="vec", tag="4")] + pub data: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for PacketState { +const NAME: &'static str = "PacketState"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.PacketState".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.PacketState".into() }} +/// PacketId is an identifier for a unique Packet +/// Source chains refer to packets by source port/channel +/// Destination chains refer to packets by destination port/channel +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PacketId { + /// channel port identifier + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + /// channel unique identifier + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + /// packet sequence + #[prost(uint64, tag="3")] + pub sequence: u64, +} +impl ::prost::Name for PacketId { +const NAME: &'static str = "PacketId"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.PacketId".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.PacketId".into() }} +/// Acknowledgement is the recommended acknowledgement format to be used by +/// app-specific protocols. +/// NOTE: The field numbers 21 and 22 were explicitly chosen to avoid accidental +/// conflicts with other protobuf message formats used for acknowledgements. +/// The first byte of any message with this format will be the non-ASCII values +/// `0xaa` (result) or `0xb2` (error). Implemented as defined by ICS: +/// +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Acknowledgement { + /// response contains either a result or an error and must be non-empty + #[prost(oneof="acknowledgement::Response", tags="21, 22")] + pub response: ::core::option::Option, +} +/// Nested message and enum types in `Acknowledgement`. +pub mod acknowledgement { + /// response contains either a result or an error and must be non-empty + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Response { + #[prost(bytes, tag="21")] + Result(::prost::alloc::vec::Vec), + #[prost(string, tag="22")] + Error(::prost::alloc::string::String), + } +} +impl ::prost::Name for Acknowledgement { +const NAME: &'static str = "Acknowledgement"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.Acknowledgement".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.Acknowledgement".into() }} +/// Timeout defines an execution deadline structure for 04-channel handlers. +/// This includes packet lifecycle handlers as well as the upgrade handshake handlers. +/// A valid Timeout contains either one or both of a timestamp and block height (sequence). +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct Timeout { + /// block height after which the packet or upgrade times out + #[prost(message, optional, tag="1")] + pub height: ::core::option::Option, + /// block timestamp (in nanoseconds) after which the packet or upgrade times out + #[prost(uint64, tag="2")] + pub timestamp: u64, +} +impl ::prost::Name for Timeout { +const NAME: &'static str = "Timeout"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.Timeout".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.Timeout".into() }} +/// Params defines the set of IBC channel parameters. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct Params { + /// the relative timeout after which channel upgrades will time out. + #[prost(message, optional, tag="1")] + pub upgrade_timeout: ::core::option::Option, +} +impl ::prost::Name for Params { +const NAME: &'static str = "Params"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.Params".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.Params".into() }} +/// State defines if a channel is in one of the following states: +/// CLOSED, INIT, TRYOPEN, OPEN, FLUSHING, FLUSHCOMPLETE or UNINITIALIZED. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum State { + /// Default State + UninitializedUnspecified = 0, + /// A channel has just started the opening handshake. + Init = 1, + /// A channel has acknowledged the handshake step on the counterparty chain. + Tryopen = 2, + /// A channel has completed the handshake. Open channels are + /// ready to send and receive packets. + Open = 3, + /// A channel has been closed and can no longer be used to send or receive + /// packets. + Closed = 4, + /// A channel has just accepted the upgrade handshake attempt and is flushing in-flight packets. + Flushing = 5, + /// A channel has just completed flushing any in-flight packets. + Flushcomplete = 6, +} +impl State { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + State::UninitializedUnspecified => "STATE_UNINITIALIZED_UNSPECIFIED", + State::Init => "STATE_INIT", + State::Tryopen => "STATE_TRYOPEN", + State::Open => "STATE_OPEN", + State::Closed => "STATE_CLOSED", + State::Flushing => "STATE_FLUSHING", + State::Flushcomplete => "STATE_FLUSHCOMPLETE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "STATE_UNINITIALIZED_UNSPECIFIED" => Some(Self::UninitializedUnspecified), + "STATE_INIT" => Some(Self::Init), + "STATE_TRYOPEN" => Some(Self::Tryopen), + "STATE_OPEN" => Some(Self::Open), + "STATE_CLOSED" => Some(Self::Closed), + "STATE_FLUSHING" => Some(Self::Flushing), + "STATE_FLUSHCOMPLETE" => Some(Self::Flushcomplete), + _ => None, + } + } +} +/// Order defines if a channel is ORDERED or UNORDERED +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum Order { + /// zero-value for channel ordering + NoneUnspecified = 0, + /// packets can be delivered in any order, which may differ from the order in + /// which they were sent. + Unordered = 1, + /// packets are delivered exactly in the order which they were sent + Ordered = 2, +} +impl Order { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Order::NoneUnspecified => "ORDER_NONE_UNSPECIFIED", + Order::Unordered => "ORDER_UNORDERED", + Order::Ordered => "ORDER_ORDERED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ORDER_NONE_UNSPECIFIED" => Some(Self::NoneUnspecified), + "ORDER_UNORDERED" => Some(Self::Unordered), + "ORDER_ORDERED" => Some(Self::Ordered), + _ => None, + } + } +} +/// GenesisState defines the ibc channel submodule's genesis state. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GenesisState { + #[prost(message, repeated, tag="1")] + pub channels: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="2")] + pub acknowledgements: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="3")] + pub commitments: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="4")] + pub receipts: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="5")] + pub send_sequences: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="6")] + pub recv_sequences: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="7")] + pub ack_sequences: ::prost::alloc::vec::Vec, + /// the sequence for the next generated channel identifier + #[prost(uint64, tag="8")] + pub next_channel_sequence: u64, + #[prost(message, optional, tag="9")] + pub params: ::core::option::Option, +} +impl ::prost::Name for GenesisState { +const NAME: &'static str = "GenesisState"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.GenesisState".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.GenesisState".into() }} +/// PacketSequence defines the genesis type necessary to retrieve and store +/// next send and receive sequences. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PacketSequence { + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(uint64, tag="3")] + pub sequence: u64, +} +impl ::prost::Name for PacketSequence { +const NAME: &'static str = "PacketSequence"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.PacketSequence".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.PacketSequence".into() }} +/// Upgrade is a verifiable type which contains the relevant information +/// for an attempted upgrade. It provides the proposed changes to the channel +/// end, the timeout for this upgrade attempt and the next packet sequence +/// which allows the counterparty to efficiently know the highest sequence it has received. +/// The next sequence send is used for pruning and upgrading from unordered to ordered channels. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Upgrade { + #[prost(message, optional, tag="1")] + pub fields: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub timeout: ::core::option::Option, + #[prost(uint64, tag="3")] + pub next_sequence_send: u64, +} +impl ::prost::Name for Upgrade { +const NAME: &'static str = "Upgrade"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.Upgrade".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.Upgrade".into() }} +/// UpgradeFields are the fields in a channel end which may be changed +/// during a channel upgrade. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UpgradeFields { + #[prost(enumeration="Order", tag="1")] + pub ordering: i32, + #[prost(string, repeated, tag="2")] + pub connection_hops: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(string, tag="3")] + pub version: ::prost::alloc::string::String, +} +impl ::prost::Name for UpgradeFields { +const NAME: &'static str = "UpgradeFields"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.UpgradeFields".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.UpgradeFields".into() }} +/// ErrorReceipt defines a type which encapsulates the upgrade sequence and error associated with the +/// upgrade handshake failure. When a channel upgrade handshake is aborted both chains are expected to increment to the +/// next sequence. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ErrorReceipt { + /// the channel upgrade sequence + #[prost(uint64, tag="1")] + pub sequence: u64, + /// the error message detailing the cause of failure + #[prost(string, tag="2")] + pub message: ::prost::alloc::string::String, +} +impl ::prost::Name for ErrorReceipt { +const NAME: &'static str = "ErrorReceipt"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.ErrorReceipt".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.ErrorReceipt".into() }} +/// QueryChannelRequest is the request type for the Query/Channel RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryChannelRequest { + /// port unique identifier + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + /// channel unique identifier + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryChannelRequest { +const NAME: &'static str = "QueryChannelRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryChannelRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryChannelRequest".into() }} +/// QueryChannelResponse is the response type for the Query/Channel RPC method. +/// Besides the Channel end, it includes a proof and the height from which the +/// proof was retrieved. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryChannelResponse { + /// channel associated with the request identifiers + #[prost(message, optional, tag="1")] + pub channel: ::core::option::Option, + /// merkle proof of existence + #[prost(bytes="vec", tag="2")] + pub proof: ::prost::alloc::vec::Vec, + /// height at which the proof was retrieved + #[prost(message, optional, tag="3")] + pub proof_height: ::core::option::Option, +} +impl ::prost::Name for QueryChannelResponse { +const NAME: &'static str = "QueryChannelResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryChannelResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryChannelResponse".into() }} +/// QueryChannelsRequest is the request type for the Query/Channels RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryChannelsRequest { + /// pagination request + #[prost(message, optional, tag="1")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageRequest>, +} +impl ::prost::Name for QueryChannelsRequest { +const NAME: &'static str = "QueryChannelsRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryChannelsRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryChannelsRequest".into() }} +/// QueryChannelsResponse is the response type for the Query/Channels RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryChannelsResponse { + /// list of stored channels of the chain. + #[prost(message, repeated, tag="1")] + pub channels: ::prost::alloc::vec::Vec, + /// pagination response + #[prost(message, optional, tag="2")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageResponse>, + /// query block height + #[prost(message, optional, tag="3")] + pub height: ::core::option::Option, +} +impl ::prost::Name for QueryChannelsResponse { +const NAME: &'static str = "QueryChannelsResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryChannelsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryChannelsResponse".into() }} +/// QueryConnectionChannelsRequest is the request type for the +/// Query/QueryConnectionChannels RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryConnectionChannelsRequest { + /// connection unique identifier + #[prost(string, tag="1")] + pub connection: ::prost::alloc::string::String, + /// pagination request + #[prost(message, optional, tag="2")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageRequest>, +} +impl ::prost::Name for QueryConnectionChannelsRequest { +const NAME: &'static str = "QueryConnectionChannelsRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryConnectionChannelsRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryConnectionChannelsRequest".into() }} +/// QueryConnectionChannelsResponse is the Response type for the +/// Query/QueryConnectionChannels RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryConnectionChannelsResponse { + /// list of channels associated with a connection. + #[prost(message, repeated, tag="1")] + pub channels: ::prost::alloc::vec::Vec, + /// pagination response + #[prost(message, optional, tag="2")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageResponse>, + /// query block height + #[prost(message, optional, tag="3")] + pub height: ::core::option::Option, +} +impl ::prost::Name for QueryConnectionChannelsResponse { +const NAME: &'static str = "QueryConnectionChannelsResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryConnectionChannelsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryConnectionChannelsResponse".into() }} +/// QueryChannelClientStateRequest is the request type for the Query/ClientState +/// RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryChannelClientStateRequest { + /// port unique identifier + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + /// channel unique identifier + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryChannelClientStateRequest { +const NAME: &'static str = "QueryChannelClientStateRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryChannelClientStateRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryChannelClientStateRequest".into() }} +/// QueryChannelClientStateResponse is the Response type for the +/// Query/QueryChannelClientState RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryChannelClientStateResponse { + /// client state associated with the channel + #[prost(message, optional, tag="1")] + pub identified_client_state: ::core::option::Option, + /// merkle proof of existence + #[prost(bytes="vec", tag="2")] + pub proof: ::prost::alloc::vec::Vec, + /// height at which the proof was retrieved + #[prost(message, optional, tag="3")] + pub proof_height: ::core::option::Option, +} +impl ::prost::Name for QueryChannelClientStateResponse { +const NAME: &'static str = "QueryChannelClientStateResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryChannelClientStateResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryChannelClientStateResponse".into() }} +/// QueryChannelConsensusStateRequest is the request type for the +/// Query/ConsensusState RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryChannelConsensusStateRequest { + /// port unique identifier + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + /// channel unique identifier + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + /// revision number of the consensus state + #[prost(uint64, tag="3")] + pub revision_number: u64, + /// revision height of the consensus state + #[prost(uint64, tag="4")] + pub revision_height: u64, +} +impl ::prost::Name for QueryChannelConsensusStateRequest { +const NAME: &'static str = "QueryChannelConsensusStateRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryChannelConsensusStateRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryChannelConsensusStateRequest".into() }} +/// QueryChannelClientStateResponse is the Response type for the +/// Query/QueryChannelClientState RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryChannelConsensusStateResponse { + /// consensus state associated with the channel + #[prost(message, optional, tag="1")] + pub consensus_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, + /// client ID associated with the consensus state + #[prost(string, tag="2")] + pub client_id: ::prost::alloc::string::String, + /// merkle proof of existence + #[prost(bytes="vec", tag="3")] + pub proof: ::prost::alloc::vec::Vec, + /// height at which the proof was retrieved + #[prost(message, optional, tag="4")] + pub proof_height: ::core::option::Option, +} +impl ::prost::Name for QueryChannelConsensusStateResponse { +const NAME: &'static str = "QueryChannelConsensusStateResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryChannelConsensusStateResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryChannelConsensusStateResponse".into() }} +/// QueryPacketCommitmentRequest is the request type for the +/// Query/PacketCommitment RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryPacketCommitmentRequest { + /// port unique identifier + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + /// channel unique identifier + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + /// packet sequence + #[prost(uint64, tag="3")] + pub sequence: u64, +} +impl ::prost::Name for QueryPacketCommitmentRequest { +const NAME: &'static str = "QueryPacketCommitmentRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryPacketCommitmentRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryPacketCommitmentRequest".into() }} +/// QueryPacketCommitmentResponse defines the client query response for a packet +/// which also includes a proof and the height from which the proof was +/// retrieved +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryPacketCommitmentResponse { + /// packet associated with the request fields + #[prost(bytes="vec", tag="1")] + pub commitment: ::prost::alloc::vec::Vec, + /// merkle proof of existence + #[prost(bytes="vec", tag="2")] + pub proof: ::prost::alloc::vec::Vec, + /// height at which the proof was retrieved + #[prost(message, optional, tag="3")] + pub proof_height: ::core::option::Option, +} +impl ::prost::Name for QueryPacketCommitmentResponse { +const NAME: &'static str = "QueryPacketCommitmentResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryPacketCommitmentResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryPacketCommitmentResponse".into() }} +/// QueryPacketCommitmentsRequest is the request type for the +/// Query/QueryPacketCommitments RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryPacketCommitmentsRequest { + /// port unique identifier + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + /// channel unique identifier + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + /// pagination request + #[prost(message, optional, tag="3")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageRequest>, +} +impl ::prost::Name for QueryPacketCommitmentsRequest { +const NAME: &'static str = "QueryPacketCommitmentsRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryPacketCommitmentsRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryPacketCommitmentsRequest".into() }} +/// QueryPacketCommitmentsResponse is the request type for the +/// Query/QueryPacketCommitments RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryPacketCommitmentsResponse { + #[prost(message, repeated, tag="1")] + pub commitments: ::prost::alloc::vec::Vec, + /// pagination response + #[prost(message, optional, tag="2")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageResponse>, + /// query block height + #[prost(message, optional, tag="3")] + pub height: ::core::option::Option, +} +impl ::prost::Name for QueryPacketCommitmentsResponse { +const NAME: &'static str = "QueryPacketCommitmentsResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryPacketCommitmentsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryPacketCommitmentsResponse".into() }} +/// QueryPacketReceiptRequest is the request type for the +/// Query/PacketReceipt RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryPacketReceiptRequest { + /// port unique identifier + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + /// channel unique identifier + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + /// packet sequence + #[prost(uint64, tag="3")] + pub sequence: u64, +} +impl ::prost::Name for QueryPacketReceiptRequest { +const NAME: &'static str = "QueryPacketReceiptRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryPacketReceiptRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryPacketReceiptRequest".into() }} +/// QueryPacketReceiptResponse defines the client query response for a packet +/// receipt which also includes a proof, and the height from which the proof was +/// retrieved +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryPacketReceiptResponse { + /// success flag for if receipt exists + #[prost(bool, tag="2")] + pub received: bool, + /// merkle proof of existence + #[prost(bytes="vec", tag="3")] + pub proof: ::prost::alloc::vec::Vec, + /// height at which the proof was retrieved + #[prost(message, optional, tag="4")] + pub proof_height: ::core::option::Option, +} +impl ::prost::Name for QueryPacketReceiptResponse { +const NAME: &'static str = "QueryPacketReceiptResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryPacketReceiptResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryPacketReceiptResponse".into() }} +/// QueryPacketAcknowledgementRequest is the request type for the +/// Query/PacketAcknowledgement RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryPacketAcknowledgementRequest { + /// port unique identifier + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + /// channel unique identifier + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + /// packet sequence + #[prost(uint64, tag="3")] + pub sequence: u64, +} +impl ::prost::Name for QueryPacketAcknowledgementRequest { +const NAME: &'static str = "QueryPacketAcknowledgementRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryPacketAcknowledgementRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryPacketAcknowledgementRequest".into() }} +/// QueryPacketAcknowledgementResponse defines the client query response for a +/// packet which also includes a proof and the height from which the +/// proof was retrieved +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryPacketAcknowledgementResponse { + /// packet associated with the request fields + #[prost(bytes="vec", tag="1")] + pub acknowledgement: ::prost::alloc::vec::Vec, + /// merkle proof of existence + #[prost(bytes="vec", tag="2")] + pub proof: ::prost::alloc::vec::Vec, + /// height at which the proof was retrieved + #[prost(message, optional, tag="3")] + pub proof_height: ::core::option::Option, +} +impl ::prost::Name for QueryPacketAcknowledgementResponse { +const NAME: &'static str = "QueryPacketAcknowledgementResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryPacketAcknowledgementResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryPacketAcknowledgementResponse".into() }} +/// QueryPacketAcknowledgementsRequest is the request type for the +/// Query/QueryPacketCommitments RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryPacketAcknowledgementsRequest { + /// port unique identifier + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + /// channel unique identifier + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + /// pagination request + #[prost(message, optional, tag="3")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageRequest>, + /// list of packet sequences + #[prost(uint64, repeated, tag="4")] + pub packet_commitment_sequences: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for QueryPacketAcknowledgementsRequest { +const NAME: &'static str = "QueryPacketAcknowledgementsRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryPacketAcknowledgementsRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryPacketAcknowledgementsRequest".into() }} +/// QueryPacketAcknowledgemetsResponse is the request type for the +/// Query/QueryPacketAcknowledgements RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryPacketAcknowledgementsResponse { + #[prost(message, repeated, tag="1")] + pub acknowledgements: ::prost::alloc::vec::Vec, + /// pagination response + #[prost(message, optional, tag="2")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageResponse>, + /// query block height + #[prost(message, optional, tag="3")] + pub height: ::core::option::Option, +} +impl ::prost::Name for QueryPacketAcknowledgementsResponse { +const NAME: &'static str = "QueryPacketAcknowledgementsResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryPacketAcknowledgementsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryPacketAcknowledgementsResponse".into() }} +/// QueryUnreceivedPacketsRequest is the request type for the +/// Query/UnreceivedPackets RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryUnreceivedPacketsRequest { + /// port unique identifier + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + /// channel unique identifier + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + /// list of packet sequences + #[prost(uint64, repeated, tag="3")] + pub packet_commitment_sequences: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for QueryUnreceivedPacketsRequest { +const NAME: &'static str = "QueryUnreceivedPacketsRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryUnreceivedPacketsRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryUnreceivedPacketsRequest".into() }} +/// QueryUnreceivedPacketsResponse is the response type for the +/// Query/UnreceivedPacketCommitments RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryUnreceivedPacketsResponse { + /// list of unreceived packet sequences + #[prost(uint64, repeated, tag="1")] + pub sequences: ::prost::alloc::vec::Vec, + /// query block height + #[prost(message, optional, tag="2")] + pub height: ::core::option::Option, +} +impl ::prost::Name for QueryUnreceivedPacketsResponse { +const NAME: &'static str = "QueryUnreceivedPacketsResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryUnreceivedPacketsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryUnreceivedPacketsResponse".into() }} +/// QueryUnreceivedAcks is the request type for the +/// Query/UnreceivedAcks RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryUnreceivedAcksRequest { + /// port unique identifier + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + /// channel unique identifier + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + /// list of acknowledgement sequences + #[prost(uint64, repeated, tag="3")] + pub packet_ack_sequences: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for QueryUnreceivedAcksRequest { +const NAME: &'static str = "QueryUnreceivedAcksRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryUnreceivedAcksRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryUnreceivedAcksRequest".into() }} +/// QueryUnreceivedAcksResponse is the response type for the +/// Query/UnreceivedAcks RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryUnreceivedAcksResponse { + /// list of unreceived acknowledgement sequences + #[prost(uint64, repeated, tag="1")] + pub sequences: ::prost::alloc::vec::Vec, + /// query block height + #[prost(message, optional, tag="2")] + pub height: ::core::option::Option, +} +impl ::prost::Name for QueryUnreceivedAcksResponse { +const NAME: &'static str = "QueryUnreceivedAcksResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryUnreceivedAcksResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryUnreceivedAcksResponse".into() }} +/// QueryNextSequenceReceiveRequest is the request type for the +/// Query/QueryNextSequenceReceiveRequest RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryNextSequenceReceiveRequest { + /// port unique identifier + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + /// channel unique identifier + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryNextSequenceReceiveRequest { +const NAME: &'static str = "QueryNextSequenceReceiveRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryNextSequenceReceiveRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryNextSequenceReceiveRequest".into() }} +/// QuerySequenceResponse is the response type for the +/// Query/QueryNextSequenceReceiveResponse RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryNextSequenceReceiveResponse { + /// next sequence receive number + #[prost(uint64, tag="1")] + pub next_sequence_receive: u64, + /// merkle proof of existence + #[prost(bytes="vec", tag="2")] + pub proof: ::prost::alloc::vec::Vec, + /// height at which the proof was retrieved + #[prost(message, optional, tag="3")] + pub proof_height: ::core::option::Option, +} +impl ::prost::Name for QueryNextSequenceReceiveResponse { +const NAME: &'static str = "QueryNextSequenceReceiveResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryNextSequenceReceiveResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryNextSequenceReceiveResponse".into() }} +/// QueryNextSequenceSendRequest is the request type for the +/// Query/QueryNextSequenceSend RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryNextSequenceSendRequest { + /// port unique identifier + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + /// channel unique identifier + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryNextSequenceSendRequest { +const NAME: &'static str = "QueryNextSequenceSendRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryNextSequenceSendRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryNextSequenceSendRequest".into() }} +/// QueryNextSequenceSendResponse is the request type for the +/// Query/QueryNextSequenceSend RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryNextSequenceSendResponse { + /// next sequence send number + #[prost(uint64, tag="1")] + pub next_sequence_send: u64, + /// merkle proof of existence + #[prost(bytes="vec", tag="2")] + pub proof: ::prost::alloc::vec::Vec, + /// height at which the proof was retrieved + #[prost(message, optional, tag="3")] + pub proof_height: ::core::option::Option, +} +impl ::prost::Name for QueryNextSequenceSendResponse { +const NAME: &'static str = "QueryNextSequenceSendResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryNextSequenceSendResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryNextSequenceSendResponse".into() }} +/// QueryUpgradeErrorRequest is the request type for the Query/QueryUpgradeError RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryUpgradeErrorRequest { + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryUpgradeErrorRequest { +const NAME: &'static str = "QueryUpgradeErrorRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryUpgradeErrorRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryUpgradeErrorRequest".into() }} +/// QueryUpgradeErrorResponse is the response type for the Query/QueryUpgradeError RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryUpgradeErrorResponse { + #[prost(message, optional, tag="1")] + pub error_receipt: ::core::option::Option, + /// merkle proof of existence + #[prost(bytes="vec", tag="2")] + pub proof: ::prost::alloc::vec::Vec, + /// height at which the proof was retrieved + #[prost(message, optional, tag="3")] + pub proof_height: ::core::option::Option, +} +impl ::prost::Name for QueryUpgradeErrorResponse { +const NAME: &'static str = "QueryUpgradeErrorResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryUpgradeErrorResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryUpgradeErrorResponse".into() }} +/// QueryUpgradeRequest is the request type for the QueryUpgradeRequest RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryUpgradeRequest { + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryUpgradeRequest { +const NAME: &'static str = "QueryUpgradeRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryUpgradeRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryUpgradeRequest".into() }} +/// QueryUpgradeResponse is the response type for the QueryUpgradeResponse RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryUpgradeResponse { + #[prost(message, optional, tag="1")] + pub upgrade: ::core::option::Option, + /// merkle proof of existence + #[prost(bytes="vec", tag="2")] + pub proof: ::prost::alloc::vec::Vec, + /// height at which the proof was retrieved + #[prost(message, optional, tag="3")] + pub proof_height: ::core::option::Option, +} +impl ::prost::Name for QueryUpgradeResponse { +const NAME: &'static str = "QueryUpgradeResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryUpgradeResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryUpgradeResponse".into() }} +/// QueryChannelParamsRequest is the request type for the Query/ChannelParams RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct QueryChannelParamsRequest { +} +impl ::prost::Name for QueryChannelParamsRequest { +const NAME: &'static str = "QueryChannelParamsRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryChannelParamsRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryChannelParamsRequest".into() }} +/// QueryChannelParamsResponse is the response type for the Query/ChannelParams RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct QueryChannelParamsResponse { + /// params defines the parameters of the module. + #[prost(message, optional, tag="1")] + pub params: ::core::option::Option, +} +impl ::prost::Name for QueryChannelParamsResponse { +const NAME: &'static str = "QueryChannelParamsResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.QueryChannelParamsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.QueryChannelParamsResponse".into() }} +/// MsgChannelOpenInit defines an sdk.Msg to initialize a channel handshake. It +/// is called by a relayer on Chain A. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelOpenInit { + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + #[prost(message, optional, tag="2")] + pub channel: ::core::option::Option, + #[prost(string, tag="3")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgChannelOpenInit { +const NAME: &'static str = "MsgChannelOpenInit"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelOpenInit".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelOpenInit".into() }} +/// MsgChannelOpenInitResponse defines the Msg/ChannelOpenInit response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelOpenInitResponse { + #[prost(string, tag="1")] + pub channel_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub version: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgChannelOpenInitResponse { +const NAME: &'static str = "MsgChannelOpenInitResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelOpenInitResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelOpenInitResponse".into() }} +/// MsgChannelOpenInit defines a msg sent by a Relayer to try to open a channel +/// on Chain B. The version field within the Channel field has been deprecated. Its +/// value will be ignored by core IBC. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelOpenTry { + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + /// Deprecated: this field is unused. Crossing hello's are no longer supported in core IBC. + #[deprecated] + #[prost(string, tag="2")] + pub previous_channel_id: ::prost::alloc::string::String, + /// NOTE: the version field within the channel has been deprecated. Its value will be ignored by core IBC. + #[prost(message, optional, tag="3")] + pub channel: ::core::option::Option, + #[prost(string, tag="4")] + pub counterparty_version: ::prost::alloc::string::String, + #[prost(bytes="vec", tag="5")] + pub proof_init: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="6")] + pub proof_height: ::core::option::Option, + #[prost(string, tag="7")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgChannelOpenTry { +const NAME: &'static str = "MsgChannelOpenTry"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelOpenTry".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelOpenTry".into() }} +/// MsgChannelOpenTryResponse defines the Msg/ChannelOpenTry response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelOpenTryResponse { + #[prost(string, tag="1")] + pub version: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgChannelOpenTryResponse { +const NAME: &'static str = "MsgChannelOpenTryResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelOpenTryResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelOpenTryResponse".into() }} +/// MsgChannelOpenAck defines a msg sent by a Relayer to Chain A to acknowledge +/// the change of channel state to TRYOPEN on Chain B. +/// WARNING: a channel upgrade MUST NOT initialize an upgrade for this channel +/// in the same block as executing this message otherwise the counterparty will +/// be incapable of opening. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelOpenAck { + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(string, tag="3")] + pub counterparty_channel_id: ::prost::alloc::string::String, + #[prost(string, tag="4")] + pub counterparty_version: ::prost::alloc::string::String, + #[prost(bytes="vec", tag="5")] + pub proof_try: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="6")] + pub proof_height: ::core::option::Option, + #[prost(string, tag="7")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgChannelOpenAck { +const NAME: &'static str = "MsgChannelOpenAck"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelOpenAck".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelOpenAck".into() }} +/// MsgChannelOpenAckResponse defines the Msg/ChannelOpenAck response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgChannelOpenAckResponse { +} +impl ::prost::Name for MsgChannelOpenAckResponse { +const NAME: &'static str = "MsgChannelOpenAckResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelOpenAckResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelOpenAckResponse".into() }} +/// MsgChannelOpenConfirm defines a msg sent by a Relayer to Chain B to +/// acknowledge the change of channel state to OPEN on Chain A. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelOpenConfirm { + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(bytes="vec", tag="3")] + pub proof_ack: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="4")] + pub proof_height: ::core::option::Option, + #[prost(string, tag="5")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgChannelOpenConfirm { +const NAME: &'static str = "MsgChannelOpenConfirm"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelOpenConfirm".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelOpenConfirm".into() }} +/// MsgChannelOpenConfirmResponse defines the Msg/ChannelOpenConfirm response +/// type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgChannelOpenConfirmResponse { +} +impl ::prost::Name for MsgChannelOpenConfirmResponse { +const NAME: &'static str = "MsgChannelOpenConfirmResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelOpenConfirmResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelOpenConfirmResponse".into() }} +/// MsgChannelCloseInit defines a msg sent by a Relayer to Chain A +/// to close a channel with Chain B. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelCloseInit { + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(string, tag="3")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgChannelCloseInit { +const NAME: &'static str = "MsgChannelCloseInit"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelCloseInit".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelCloseInit".into() }} +/// MsgChannelCloseInitResponse defines the Msg/ChannelCloseInit response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgChannelCloseInitResponse { +} +impl ::prost::Name for MsgChannelCloseInitResponse { +const NAME: &'static str = "MsgChannelCloseInitResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelCloseInitResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelCloseInitResponse".into() }} +/// MsgChannelCloseConfirm defines a msg sent by a Relayer to Chain B +/// to acknowledge the change of channel state to CLOSED on Chain A. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelCloseConfirm { + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(bytes="vec", tag="3")] + pub proof_init: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="4")] + pub proof_height: ::core::option::Option, + #[prost(string, tag="5")] + pub signer: ::prost::alloc::string::String, + #[prost(uint64, tag="6")] + pub counterparty_upgrade_sequence: u64, +} +impl ::prost::Name for MsgChannelCloseConfirm { +const NAME: &'static str = "MsgChannelCloseConfirm"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelCloseConfirm".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelCloseConfirm".into() }} +/// MsgChannelCloseConfirmResponse defines the Msg/ChannelCloseConfirm response +/// type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgChannelCloseConfirmResponse { +} +impl ::prost::Name for MsgChannelCloseConfirmResponse { +const NAME: &'static str = "MsgChannelCloseConfirmResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelCloseConfirmResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelCloseConfirmResponse".into() }} +/// MsgRecvPacket receives incoming IBC packet +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgRecvPacket { + #[prost(message, optional, tag="1")] + pub packet: ::core::option::Option, + #[prost(bytes="vec", tag="2")] + pub proof_commitment: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="3")] + pub proof_height: ::core::option::Option, + #[prost(string, tag="4")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgRecvPacket { +const NAME: &'static str = "MsgRecvPacket"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgRecvPacket".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgRecvPacket".into() }} +/// MsgRecvPacketResponse defines the Msg/RecvPacket response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgRecvPacketResponse { + #[prost(enumeration="ResponseResultType", tag="1")] + pub result: i32, +} +impl ::prost::Name for MsgRecvPacketResponse { +const NAME: &'static str = "MsgRecvPacketResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgRecvPacketResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgRecvPacketResponse".into() }} +/// MsgTimeout receives timed-out packet +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgTimeout { + #[prost(message, optional, tag="1")] + pub packet: ::core::option::Option, + #[prost(bytes="vec", tag="2")] + pub proof_unreceived: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="3")] + pub proof_height: ::core::option::Option, + #[prost(uint64, tag="4")] + pub next_sequence_recv: u64, + #[prost(string, tag="5")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgTimeout { +const NAME: &'static str = "MsgTimeout"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgTimeout".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgTimeout".into() }} +/// MsgTimeoutResponse defines the Msg/Timeout response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgTimeoutResponse { + #[prost(enumeration="ResponseResultType", tag="1")] + pub result: i32, +} +impl ::prost::Name for MsgTimeoutResponse { +const NAME: &'static str = "MsgTimeoutResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgTimeoutResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgTimeoutResponse".into() }} +/// MsgTimeoutOnClose timed-out packet upon counterparty channel closure. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgTimeoutOnClose { + #[prost(message, optional, tag="1")] + pub packet: ::core::option::Option, + #[prost(bytes="vec", tag="2")] + pub proof_unreceived: ::prost::alloc::vec::Vec, + #[prost(bytes="vec", tag="3")] + pub proof_close: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="4")] + pub proof_height: ::core::option::Option, + #[prost(uint64, tag="5")] + pub next_sequence_recv: u64, + #[prost(string, tag="6")] + pub signer: ::prost::alloc::string::String, + #[prost(uint64, tag="7")] + pub counterparty_upgrade_sequence: u64, +} +impl ::prost::Name for MsgTimeoutOnClose { +const NAME: &'static str = "MsgTimeoutOnClose"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgTimeoutOnClose".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgTimeoutOnClose".into() }} +/// MsgTimeoutOnCloseResponse defines the Msg/TimeoutOnClose response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgTimeoutOnCloseResponse { + #[prost(enumeration="ResponseResultType", tag="1")] + pub result: i32, +} +impl ::prost::Name for MsgTimeoutOnCloseResponse { +const NAME: &'static str = "MsgTimeoutOnCloseResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgTimeoutOnCloseResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgTimeoutOnCloseResponse".into() }} +/// MsgAcknowledgement receives incoming IBC acknowledgement +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgAcknowledgement { + #[prost(message, optional, tag="1")] + pub packet: ::core::option::Option, + #[prost(bytes="vec", tag="2")] + pub acknowledgement: ::prost::alloc::vec::Vec, + #[prost(bytes="vec", tag="3")] + pub proof_acked: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="4")] + pub proof_height: ::core::option::Option, + #[prost(string, tag="5")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgAcknowledgement { +const NAME: &'static str = "MsgAcknowledgement"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgAcknowledgement".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgAcknowledgement".into() }} +/// MsgAcknowledgementResponse defines the Msg/Acknowledgement response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgAcknowledgementResponse { + #[prost(enumeration="ResponseResultType", tag="1")] + pub result: i32, +} +impl ::prost::Name for MsgAcknowledgementResponse { +const NAME: &'static str = "MsgAcknowledgementResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgAcknowledgementResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgAcknowledgementResponse".into() }} +/// MsgChannelUpgradeInit defines the request type for the ChannelUpgradeInit rpc +/// WARNING: Initializing a channel upgrade in the same block as opening the channel +/// may result in the counterparty being incapable of opening. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeInit { + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(message, optional, tag="3")] + pub fields: ::core::option::Option, + #[prost(string, tag="4")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgChannelUpgradeInit { +const NAME: &'static str = "MsgChannelUpgradeInit"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelUpgradeInit".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelUpgradeInit".into() }} +/// MsgChannelUpgradeInitResponse defines the MsgChannelUpgradeInit response type +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeInitResponse { + #[prost(message, optional, tag="1")] + pub upgrade: ::core::option::Option, + #[prost(uint64, tag="2")] + pub upgrade_sequence: u64, +} +impl ::prost::Name for MsgChannelUpgradeInitResponse { +const NAME: &'static str = "MsgChannelUpgradeInitResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelUpgradeInitResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelUpgradeInitResponse".into() }} +/// MsgChannelUpgradeTry defines the request type for the ChannelUpgradeTry rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeTry { + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(string, repeated, tag="3")] + pub proposed_upgrade_connection_hops: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(message, optional, tag="4")] + pub counterparty_upgrade_fields: ::core::option::Option, + #[prost(uint64, tag="5")] + pub counterparty_upgrade_sequence: u64, + #[prost(bytes="vec", tag="6")] + pub proof_channel: ::prost::alloc::vec::Vec, + #[prost(bytes="vec", tag="7")] + pub proof_upgrade: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="8")] + pub proof_height: ::core::option::Option, + #[prost(string, tag="9")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgChannelUpgradeTry { +const NAME: &'static str = "MsgChannelUpgradeTry"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelUpgradeTry".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelUpgradeTry".into() }} +/// MsgChannelUpgradeTryResponse defines the MsgChannelUpgradeTry response type +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeTryResponse { + #[prost(message, optional, tag="1")] + pub upgrade: ::core::option::Option, + #[prost(uint64, tag="2")] + pub upgrade_sequence: u64, + #[prost(enumeration="ResponseResultType", tag="3")] + pub result: i32, +} +impl ::prost::Name for MsgChannelUpgradeTryResponse { +const NAME: &'static str = "MsgChannelUpgradeTryResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelUpgradeTryResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelUpgradeTryResponse".into() }} +/// MsgChannelUpgradeAck defines the request type for the ChannelUpgradeAck rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeAck { + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(message, optional, tag="3")] + pub counterparty_upgrade: ::core::option::Option, + #[prost(bytes="vec", tag="4")] + pub proof_channel: ::prost::alloc::vec::Vec, + #[prost(bytes="vec", tag="5")] + pub proof_upgrade: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="6")] + pub proof_height: ::core::option::Option, + #[prost(string, tag="7")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgChannelUpgradeAck { +const NAME: &'static str = "MsgChannelUpgradeAck"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelUpgradeAck".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelUpgradeAck".into() }} +/// MsgChannelUpgradeAckResponse defines MsgChannelUpgradeAck response type +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeAckResponse { + #[prost(enumeration="ResponseResultType", tag="1")] + pub result: i32, +} +impl ::prost::Name for MsgChannelUpgradeAckResponse { +const NAME: &'static str = "MsgChannelUpgradeAckResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelUpgradeAckResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelUpgradeAckResponse".into() }} +/// MsgChannelUpgradeConfirm defines the request type for the ChannelUpgradeConfirm rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeConfirm { + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(enumeration="State", tag="3")] + pub counterparty_channel_state: i32, + #[prost(message, optional, tag="4")] + pub counterparty_upgrade: ::core::option::Option, + #[prost(bytes="vec", tag="5")] + pub proof_channel: ::prost::alloc::vec::Vec, + #[prost(bytes="vec", tag="6")] + pub proof_upgrade: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="7")] + pub proof_height: ::core::option::Option, + #[prost(string, tag="8")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgChannelUpgradeConfirm { +const NAME: &'static str = "MsgChannelUpgradeConfirm"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelUpgradeConfirm".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelUpgradeConfirm".into() }} +/// MsgChannelUpgradeConfirmResponse defines MsgChannelUpgradeConfirm response type +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeConfirmResponse { + #[prost(enumeration="ResponseResultType", tag="1")] + pub result: i32, +} +impl ::prost::Name for MsgChannelUpgradeConfirmResponse { +const NAME: &'static str = "MsgChannelUpgradeConfirmResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelUpgradeConfirmResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelUpgradeConfirmResponse".into() }} +/// MsgChannelUpgradeOpen defines the request type for the ChannelUpgradeOpen rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeOpen { + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(enumeration="State", tag="3")] + pub counterparty_channel_state: i32, + #[prost(uint64, tag="4")] + pub counterparty_upgrade_sequence: u64, + #[prost(bytes="vec", tag="5")] + pub proof_channel: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="6")] + pub proof_height: ::core::option::Option, + #[prost(string, tag="7")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgChannelUpgradeOpen { +const NAME: &'static str = "MsgChannelUpgradeOpen"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelUpgradeOpen".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelUpgradeOpen".into() }} +/// MsgChannelUpgradeOpenResponse defines the MsgChannelUpgradeOpen response type +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeOpenResponse { +} +impl ::prost::Name for MsgChannelUpgradeOpenResponse { +const NAME: &'static str = "MsgChannelUpgradeOpenResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelUpgradeOpenResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelUpgradeOpenResponse".into() }} +/// MsgChannelUpgradeTimeout defines the request type for the ChannelUpgradeTimeout rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeTimeout { + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(message, optional, tag="3")] + pub counterparty_channel: ::core::option::Option, + #[prost(bytes="vec", tag="4")] + pub proof_channel: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="5")] + pub proof_height: ::core::option::Option, + #[prost(string, tag="6")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgChannelUpgradeTimeout { +const NAME: &'static str = "MsgChannelUpgradeTimeout"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelUpgradeTimeout".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelUpgradeTimeout".into() }} +/// MsgChannelUpgradeTimeoutResponse defines the MsgChannelUpgradeTimeout response type +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeTimeoutResponse { +} +impl ::prost::Name for MsgChannelUpgradeTimeoutResponse { +const NAME: &'static str = "MsgChannelUpgradeTimeoutResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelUpgradeTimeoutResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelUpgradeTimeoutResponse".into() }} +/// MsgChannelUpgradeCancel defines the request type for the ChannelUpgradeCancel rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeCancel { + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(message, optional, tag="3")] + pub error_receipt: ::core::option::Option, + #[prost(bytes="vec", tag="4")] + pub proof_error_receipt: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="5")] + pub proof_height: ::core::option::Option, + #[prost(string, tag="6")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgChannelUpgradeCancel { +const NAME: &'static str = "MsgChannelUpgradeCancel"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelUpgradeCancel".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelUpgradeCancel".into() }} +/// MsgChannelUpgradeCancelResponse defines the MsgChannelUpgradeCancel response type +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgChannelUpgradeCancelResponse { +} +impl ::prost::Name for MsgChannelUpgradeCancelResponse { +const NAME: &'static str = "MsgChannelUpgradeCancelResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgChannelUpgradeCancelResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgChannelUpgradeCancelResponse".into() }} +/// MsgUpdateParams is the MsgUpdateParams request type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgUpdateParams { + /// authority is the address that controls the module (defaults to x/gov unless overwritten). + #[prost(string, tag="1")] + pub authority: ::prost::alloc::string::String, + /// params defines the channel parameters to update. + /// + /// NOTE: All parameters must be supplied. + #[prost(message, optional, tag="2")] + pub params: ::core::option::Option, +} +impl ::prost::Name for MsgUpdateParams { +const NAME: &'static str = "MsgUpdateParams"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgUpdateParams".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgUpdateParams".into() }} +/// MsgUpdateParamsResponse defines the MsgUpdateParams response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgUpdateParamsResponse { +} +impl ::prost::Name for MsgUpdateParamsResponse { +const NAME: &'static str = "MsgUpdateParamsResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgUpdateParamsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgUpdateParamsResponse".into() }} +/// MsgPruneAcknowledgements defines the request type for the PruneAcknowledgements rpc. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgPruneAcknowledgements { + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + #[prost(uint64, tag="3")] + pub limit: u64, + #[prost(string, tag="4")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgPruneAcknowledgements { +const NAME: &'static str = "MsgPruneAcknowledgements"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgPruneAcknowledgements".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgPruneAcknowledgements".into() }} +/// MsgPruneAcknowledgementsResponse defines the response type for the PruneAcknowledgements rpc. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgPruneAcknowledgementsResponse { + /// Number of sequences pruned (includes both packet acknowledgements and packet receipts where appropriate). + #[prost(uint64, tag="1")] + pub total_pruned_sequences: u64, + /// Number of sequences left after pruning. + #[prost(uint64, tag="2")] + pub total_remaining_sequences: u64, +} +impl ::prost::Name for MsgPruneAcknowledgementsResponse { +const NAME: &'static str = "MsgPruneAcknowledgementsResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v1.MsgPruneAcknowledgementsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v1.MsgPruneAcknowledgementsResponse".into() }} +/// ResponseResultType defines the possible outcomes of the execution of a message +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ResponseResultType { + /// Default zero value enumeration + Unspecified = 0, + /// The message did not call the IBC application callbacks (because, for example, the packet had already been relayed) + Noop = 1, + /// The message was executed successfully + Success = 2, + /// The message was executed unsuccessfully + Failure = 3, +} +impl ResponseResultType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + ResponseResultType::Unspecified => "RESPONSE_RESULT_TYPE_UNSPECIFIED", + ResponseResultType::Noop => "RESPONSE_RESULT_TYPE_NOOP", + ResponseResultType::Success => "RESPONSE_RESULT_TYPE_SUCCESS", + ResponseResultType::Failure => "RESPONSE_RESULT_TYPE_FAILURE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "RESPONSE_RESULT_TYPE_UNSPECIFIED" => Some(Self::Unspecified), + "RESPONSE_RESULT_TYPE_NOOP" => Some(Self::Noop), + "RESPONSE_RESULT_TYPE_SUCCESS" => Some(Self::Success), + "RESPONSE_RESULT_TYPE_FAILURE" => Some(Self::Failure), + _ => None, + } + } +} +// @@protoc_insertion_point(module) diff --git a/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.channel.v2.rs b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.channel.v2.rs new file mode 100644 index 00000000000..6bc2faa755c --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.channel.v2.rs @@ -0,0 +1,675 @@ +// @generated +// This file is @generated by prost-build. +/// Channel defines the channel end on a chain that is implementing the version 2 IBC protocol +/// Each side will maintain its own Channel to create an IBC channel +/// The channel will be referenced by a channelID which will be used to send packets +/// to the counterparty +/// The channel will contain the client identifier that will provide proof verification for the channel +/// and the counterparty channel identifier that the other channel end will be using +/// to send packets to our channel end. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Channel { + /// the client identifier of the light client representing the counterparty chain + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, + /// the counterparty identifier that must be used by packets sent by counterparty + /// to our channel end. + #[prost(string, tag="2")] + pub counterparty_channel_id: ::prost::alloc::string::String, + /// the key path used to store packet flow messages that the counterparty + /// will use to send to us. In backwards compatible cases, we will append the channelID and sequence in order to create + /// the final path. + #[prost(message, optional, tag="3")] + pub merkle_path_prefix: ::core::option::Option, +} +impl ::prost::Name for Channel { +const NAME: &'static str = "Channel"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.Channel".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.Channel".into() }} +/// IdentifiedChannel defines a channel with an additional channel identifier field. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IdentifiedChannel { + /// channel identified. + #[prost(message, optional, tag="1")] + pub channel: ::core::option::Option, + /// channel identifier + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, +} +impl ::prost::Name for IdentifiedChannel { +const NAME: &'static str = "IdentifiedChannel"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.IdentifiedChannel".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.IdentifiedChannel".into() }} +/// GenesisState defines the ibc channel/v2 submodule's genesis state. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GenesisState { + #[prost(message, repeated, tag="1")] + pub channels: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="2")] + pub acknowledgements: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="3")] + pub commitments: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="4")] + pub receipts: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="5")] + pub send_sequences: ::prost::alloc::vec::Vec, + /// the sequence for the next generated channel identifier + #[prost(uint64, tag="6")] + pub next_channel_sequence: u64, +} +impl ::prost::Name for GenesisState { +const NAME: &'static str = "GenesisState"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.GenesisState".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.GenesisState".into() }} +/// PacketState defines the generic type necessary to retrieve and store +/// packet commitments, acknowledgements, and receipts. +/// Caller is responsible for knowing the context necessary to interpret this +/// state as a commitment, acknowledgement, or a receipt. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PacketState { + /// channel unique identifier. + #[prost(string, tag="1")] + pub channel_id: ::prost::alloc::string::String, + /// packet sequence. + #[prost(uint64, tag="2")] + pub sequence: u64, + /// embedded data that represents packet state. + #[prost(bytes="vec", tag="3")] + pub data: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for PacketState { +const NAME: &'static str = "PacketState"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.PacketState".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.PacketState".into() }} +/// PacketSequence defines the genesis type necessary to retrieve and store next send sequences. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PacketSequence { + /// channel unique identifier. + #[prost(string, tag="1")] + pub channel_id: ::prost::alloc::string::String, + /// packet sequence + #[prost(uint64, tag="2")] + pub sequence: u64, +} +impl ::prost::Name for PacketSequence { +const NAME: &'static str = "PacketSequence"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.PacketSequence".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.PacketSequence".into() }} +/// Packet defines a type that carries data across different chains through IBC +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Packet { + /// number corresponds to the order of sends and receives, where a Packet + /// with an earlier sequence number must be sent and received before a Packet + /// with a later sequence number. + #[prost(uint64, tag="1")] + pub sequence: u64, + /// identifies the sending chain. + #[prost(string, tag="2")] + pub source_channel: ::prost::alloc::string::String, + /// identifies the receiving chain. + #[prost(string, tag="3")] + pub destination_channel: ::prost::alloc::string::String, + /// timeout timestamp in seconds after which the packet times out. + #[prost(uint64, tag="4")] + pub timeout_timestamp: u64, + /// a list of payloads, each one for a specific application. + #[prost(message, repeated, tag="5")] + pub payloads: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for Packet { +const NAME: &'static str = "Packet"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.Packet".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.Packet".into() }} +/// Payload contains the source and destination ports and payload for the application (version, encoding, raw bytes) +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Payload { + /// specifies the source port of the packet. + #[prost(string, tag="1")] + pub source_port: ::prost::alloc::string::String, + /// specifies the destination port of the packet. + #[prost(string, tag="2")] + pub destination_port: ::prost::alloc::string::String, + /// version of the specified application. + #[prost(string, tag="3")] + pub version: ::prost::alloc::string::String, + /// the encoding used for the provided value. + #[prost(string, tag="4")] + pub encoding: ::prost::alloc::string::String, + /// the raw bytes for the payload. + #[prost(bytes="vec", tag="5")] + pub value: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for Payload { +const NAME: &'static str = "Payload"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.Payload".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.Payload".into() }} +/// Acknowledgement contains a list of all ack results associated with a single packet. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Acknowledgement { + #[prost(bytes="vec", repeated, tag="1")] + pub app_acknowledgements: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, +} +impl ::prost::Name for Acknowledgement { +const NAME: &'static str = "Acknowledgement"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.Acknowledgement".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.Acknowledgement".into() }} +/// RecvPacketResult speecifies the status of a packet as well as the acknowledgement bytes. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct RecvPacketResult { + /// status of the packet + #[prost(enumeration="PacketStatus", tag="1")] + pub status: i32, + /// acknowledgement of the packet + #[prost(bytes="vec", tag="2")] + pub acknowledgement: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for RecvPacketResult { +const NAME: &'static str = "RecvPacketResult"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.RecvPacketResult".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.RecvPacketResult".into() }} +/// PacketStatus specifies the status of a RecvPacketResult. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum PacketStatus { + /// PACKET_STATUS_UNSPECIFIED indicates an unknown packet status. + Unspecified = 0, + /// PACKET_STATUS_SUCCESS indicates a successful packet receipt. + Success = 1, + /// PACKET_STATUS_FAILURE indicates a failed packet receipt. + Failure = 2, + /// PACKET_STATUS_ASYNC indicates an async packet receipt. + Async = 3, +} +impl PacketStatus { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + PacketStatus::Unspecified => "PACKET_STATUS_UNSPECIFIED", + PacketStatus::Success => "PACKET_STATUS_SUCCESS", + PacketStatus::Failure => "PACKET_STATUS_FAILURE", + PacketStatus::Async => "PACKET_STATUS_ASYNC", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "PACKET_STATUS_UNSPECIFIED" => Some(Self::Unspecified), + "PACKET_STATUS_SUCCESS" => Some(Self::Success), + "PACKET_STATUS_FAILURE" => Some(Self::Failure), + "PACKET_STATUS_ASYNC" => Some(Self::Async), + _ => None, + } + } +} +/// QueryChannelRequest is the request type for the Query/Channel RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryChannelRequest { + #[prost(string, tag="1")] + pub channel_id: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryChannelRequest { +const NAME: &'static str = "QueryChannelRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.QueryChannelRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.QueryChannelRequest".into() }} +/// QueryChannelRequest is the response type for the Query/Channel RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryChannelResponse { + /// the channel associated with the provided channel id + #[prost(message, optional, tag="1")] + pub channel: ::core::option::Option, +} +impl ::prost::Name for QueryChannelResponse { +const NAME: &'static str = "QueryChannelResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.QueryChannelResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.QueryChannelResponse".into() }} +/// QueryNextSequenceSendRequest is the request type for the Query/QueryNextSequenceSend RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryNextSequenceSendRequest { + /// channel unique identifier + #[prost(string, tag="1")] + pub channel_id: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryNextSequenceSendRequest { +const NAME: &'static str = "QueryNextSequenceSendRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.QueryNextSequenceSendRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.QueryNextSequenceSendRequest".into() }} +/// QueryNextSequenceSendResponse is the response type for the Query/QueryNextSequenceSend RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryNextSequenceSendResponse { + /// next sequence send number + #[prost(uint64, tag="1")] + pub next_sequence_send: u64, + /// merkle proof of existence + #[prost(bytes="vec", tag="2")] + pub proof: ::prost::alloc::vec::Vec, + /// height at which the proof was retrieved + #[prost(message, optional, tag="3")] + pub proof_height: ::core::option::Option, +} +impl ::prost::Name for QueryNextSequenceSendResponse { +const NAME: &'static str = "QueryNextSequenceSendResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.QueryNextSequenceSendResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.QueryNextSequenceSendResponse".into() }} +/// QueryPacketCommitmentRequest is the request type for the Query/PacketCommitment RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryPacketCommitmentRequest { + /// channel unique identifier + #[prost(string, tag="1")] + pub channel_id: ::prost::alloc::string::String, + /// packet sequence + #[prost(uint64, tag="2")] + pub sequence: u64, +} +impl ::prost::Name for QueryPacketCommitmentRequest { +const NAME: &'static str = "QueryPacketCommitmentRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.QueryPacketCommitmentRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.QueryPacketCommitmentRequest".into() }} +/// QueryPacketCommitmentResponse is the response type for the Query/PacketCommitment RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryPacketCommitmentResponse { + /// packet associated with the request fields + #[prost(bytes="vec", tag="1")] + pub commitment: ::prost::alloc::vec::Vec, + /// merkle proof of existence + #[prost(bytes="vec", tag="2")] + pub proof: ::prost::alloc::vec::Vec, + /// height at which the proof was retrieved + #[prost(message, optional, tag="3")] + pub proof_height: ::core::option::Option, +} +impl ::prost::Name for QueryPacketCommitmentResponse { +const NAME: &'static str = "QueryPacketCommitmentResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.QueryPacketCommitmentResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.QueryPacketCommitmentResponse".into() }} +/// QueryPacketCommitmentsRequest is the request type for the Query/PacketCommitments RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryPacketCommitmentsRequest { + /// channel unique identifier + #[prost(string, tag="1")] + pub channel_id: ::prost::alloc::string::String, + /// pagination request + #[prost(message, optional, tag="2")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageRequest>, +} +impl ::prost::Name for QueryPacketCommitmentsRequest { +const NAME: &'static str = "QueryPacketCommitmentsRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.QueryPacketCommitmentsRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.QueryPacketCommitmentsRequest".into() }} +/// QueryPacketCommitmentResponse is the response type for the Query/PacketCommitment RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryPacketCommitmentsResponse { + /// collection of packet commitments for the requested channel identifier. + #[prost(message, repeated, tag="1")] + pub commitments: ::prost::alloc::vec::Vec, + /// pagination response. + #[prost(message, optional, tag="2")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageResponse>, + /// query block height. + #[prost(message, optional, tag="3")] + pub height: ::core::option::Option, +} +impl ::prost::Name for QueryPacketCommitmentsResponse { +const NAME: &'static str = "QueryPacketCommitmentsResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.QueryPacketCommitmentsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.QueryPacketCommitmentsResponse".into() }} +/// QueryPacketAcknowledgementRequest is the request type for the Query/PacketAcknowledgement RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryPacketAcknowledgementRequest { + /// channel unique identifier + #[prost(string, tag="1")] + pub channel_id: ::prost::alloc::string::String, + /// packet sequence + #[prost(uint64, tag="2")] + pub sequence: u64, +} +impl ::prost::Name for QueryPacketAcknowledgementRequest { +const NAME: &'static str = "QueryPacketAcknowledgementRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.QueryPacketAcknowledgementRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.QueryPacketAcknowledgementRequest".into() }} +/// QueryPacketAcknowledgementResponse is the response type for the Query/PacketAcknowledgement RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryPacketAcknowledgementResponse { + /// acknowledgement associated with the request fields + #[prost(bytes="vec", tag="1")] + pub acknowledgement: ::prost::alloc::vec::Vec, + /// merkle proof of existence + #[prost(bytes="vec", tag="2")] + pub proof: ::prost::alloc::vec::Vec, + /// height at which the proof was retrieved + #[prost(message, optional, tag="3")] + pub proof_height: ::core::option::Option, +} +impl ::prost::Name for QueryPacketAcknowledgementResponse { +const NAME: &'static str = "QueryPacketAcknowledgementResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.QueryPacketAcknowledgementResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.QueryPacketAcknowledgementResponse".into() }} +/// QueryPacketReceiptRequest is the request type for the Query/PacketReceipt RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryPacketReceiptRequest { + /// port unique identifier + #[prost(string, tag="1")] + pub port_id: ::prost::alloc::string::String, + /// channel unique identifier + #[prost(string, tag="2")] + pub channel_id: ::prost::alloc::string::String, + /// packet sequence + #[prost(uint64, tag="3")] + pub sequence: u64, +} +impl ::prost::Name for QueryPacketReceiptRequest { +const NAME: &'static str = "QueryPacketReceiptRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.QueryPacketReceiptRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.QueryPacketReceiptRequest".into() }} +/// QueryPacketReceiptResponse is the response type for the Query/PacketReceipt RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryPacketReceiptResponse { + /// success flag for if receipt exists + #[prost(bool, tag="2")] + pub received: bool, + /// merkle proof of existence or absence + #[prost(bytes="vec", tag="3")] + pub proof: ::prost::alloc::vec::Vec, + /// height at which the proof was retrieved + #[prost(message, optional, tag="4")] + pub proof_height: ::core::option::Option, +} +impl ::prost::Name for QueryPacketReceiptResponse { +const NAME: &'static str = "QueryPacketReceiptResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.QueryPacketReceiptResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.QueryPacketReceiptResponse".into() }} +/// QueryUnreceivedPacketsRequest is the request type for the Query/UnreceivedPackets RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryUnreceivedPacketsRequest { + /// channel unique identifier + #[prost(string, tag="1")] + pub channel_id: ::prost::alloc::string::String, + /// list of packet sequences + #[prost(uint64, repeated, tag="2")] + pub sequences: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for QueryUnreceivedPacketsRequest { +const NAME: &'static str = "QueryUnreceivedPacketsRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.QueryUnreceivedPacketsRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.QueryUnreceivedPacketsRequest".into() }} +/// QueryUnreceivedPacketsResponse is the response type for the Query/UnreceivedPacketCommitments RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryUnreceivedPacketsResponse { + /// list of unreceived packet sequences + #[prost(uint64, repeated, tag="1")] + pub sequences: ::prost::alloc::vec::Vec, + /// query block height + #[prost(message, optional, tag="2")] + pub height: ::core::option::Option, +} +impl ::prost::Name for QueryUnreceivedPacketsResponse { +const NAME: &'static str = "QueryUnreceivedPacketsResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.QueryUnreceivedPacketsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.QueryUnreceivedPacketsResponse".into() }} +/// QueryUnreceivedAcks is the request type for the +/// Query/UnreceivedAcks RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryUnreceivedAcksRequest { + /// channel unique identifier + #[prost(string, tag="1")] + pub channel_id: ::prost::alloc::string::String, + /// list of acknowledgement sequences + #[prost(uint64, repeated, tag="2")] + pub packet_ack_sequences: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for QueryUnreceivedAcksRequest { +const NAME: &'static str = "QueryUnreceivedAcksRequest"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.QueryUnreceivedAcksRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.QueryUnreceivedAcksRequest".into() }} +/// QueryUnreceivedAcksResponse is the response type for the +/// Query/UnreceivedAcks RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryUnreceivedAcksResponse { + /// list of unreceived acknowledgement sequences + #[prost(uint64, repeated, tag="1")] + pub sequences: ::prost::alloc::vec::Vec, + /// query block height + #[prost(message, optional, tag="2")] + pub height: ::core::option::Option, +} +impl ::prost::Name for QueryUnreceivedAcksResponse { +const NAME: &'static str = "QueryUnreceivedAcksResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.QueryUnreceivedAcksResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.QueryUnreceivedAcksResponse".into() }} +/// MsgCreateChannel defines the message used to create a v2 Channel. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgCreateChannel { + /// the client identifier of the light client representing the counterparty chain + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, + /// the key path used to store packet flow messages that the counterparty + /// will use to send to us. + #[prost(message, optional, tag="2")] + pub merkle_path_prefix: ::core::option::Option, + /// signer address + #[prost(string, tag="3")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgCreateChannel { +const NAME: &'static str = "MsgCreateChannel"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.MsgCreateChannel".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.MsgCreateChannel".into() }} +/// MsgCreateChannelResponse defines the Msg/CreateChannel response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgCreateChannelResponse { + #[prost(string, tag="1")] + pub channel_id: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgCreateChannelResponse { +const NAME: &'static str = "MsgCreateChannelResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.MsgCreateChannelResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.MsgCreateChannelResponse".into() }} +/// MsgRegisterCounterparty defines the message used to provide the counterparty channel +/// identifier. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgRegisterCounterparty { + /// unique identifier we will use to write all packet messages sent to counterparty + #[prost(string, tag="1")] + pub channel_id: ::prost::alloc::string::String, + /// counterparty channel identifier + #[prost(string, tag="2")] + pub counterparty_channel_id: ::prost::alloc::string::String, + /// signer address + #[prost(string, tag="3")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgRegisterCounterparty { +const NAME: &'static str = "MsgRegisterCounterparty"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.MsgRegisterCounterparty".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.MsgRegisterCounterparty".into() }} +/// MsgRegisterCounterpartyResponse defines the Msg/RegisterCounterparty response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgRegisterCounterpartyResponse { +} +impl ::prost::Name for MsgRegisterCounterpartyResponse { +const NAME: &'static str = "MsgRegisterCounterpartyResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.MsgRegisterCounterpartyResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.MsgRegisterCounterpartyResponse".into() }} +/// MsgSendPacket sends an outgoing IBC packet. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgSendPacket { + #[prost(string, tag="1")] + pub source_channel: ::prost::alloc::string::String, + #[prost(uint64, tag="2")] + pub timeout_timestamp: u64, + #[prost(message, repeated, tag="3")] + pub payloads: ::prost::alloc::vec::Vec, + #[prost(string, tag="4")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgSendPacket { +const NAME: &'static str = "MsgSendPacket"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.MsgSendPacket".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.MsgSendPacket".into() }} +/// MsgSendPacketResponse defines the Msg/SendPacket response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgSendPacketResponse { + #[prost(uint64, tag="1")] + pub sequence: u64, +} +impl ::prost::Name for MsgSendPacketResponse { +const NAME: &'static str = "MsgSendPacketResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.MsgSendPacketResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.MsgSendPacketResponse".into() }} +/// MsgRecvPacket receives an incoming IBC packet. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgRecvPacket { + #[prost(message, optional, tag="1")] + pub packet: ::core::option::Option, + #[prost(bytes="vec", tag="2")] + pub proof_commitment: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="3")] + pub proof_height: ::core::option::Option, + #[prost(string, tag="4")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgRecvPacket { +const NAME: &'static str = "MsgRecvPacket"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.MsgRecvPacket".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.MsgRecvPacket".into() }} +/// MsgRecvPacketResponse defines the Msg/RecvPacket response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgRecvPacketResponse { + #[prost(enumeration="ResponseResultType", tag="1")] + pub result: i32, +} +impl ::prost::Name for MsgRecvPacketResponse { +const NAME: &'static str = "MsgRecvPacketResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.MsgRecvPacketResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.MsgRecvPacketResponse".into() }} +/// MsgTimeout receives timed-out packet +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgTimeout { + #[prost(message, optional, tag="1")] + pub packet: ::core::option::Option, + #[prost(bytes="vec", tag="2")] + pub proof_unreceived: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="3")] + pub proof_height: ::core::option::Option, + #[prost(string, tag="5")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgTimeout { +const NAME: &'static str = "MsgTimeout"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.MsgTimeout".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.MsgTimeout".into() }} +/// MsgTimeoutResponse defines the Msg/Timeout response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgTimeoutResponse { + #[prost(enumeration="ResponseResultType", tag="1")] + pub result: i32, +} +impl ::prost::Name for MsgTimeoutResponse { +const NAME: &'static str = "MsgTimeoutResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.MsgTimeoutResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.MsgTimeoutResponse".into() }} +/// MsgAcknowledgement receives incoming IBC acknowledgement. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgAcknowledgement { + #[prost(message, optional, tag="1")] + pub packet: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub acknowledgement: ::core::option::Option, + #[prost(bytes="vec", tag="3")] + pub proof_acked: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="4")] + pub proof_height: ::core::option::Option, + #[prost(string, tag="5")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgAcknowledgement { +const NAME: &'static str = "MsgAcknowledgement"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.MsgAcknowledgement".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.MsgAcknowledgement".into() }} +/// MsgAcknowledgementResponse defines the Msg/Acknowledgement response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgAcknowledgementResponse { + #[prost(enumeration="ResponseResultType", tag="1")] + pub result: i32, +} +impl ::prost::Name for MsgAcknowledgementResponse { +const NAME: &'static str = "MsgAcknowledgementResponse"; +const PACKAGE: &'static str = "ibc.core.channel.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.channel.v2.MsgAcknowledgementResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.channel.v2.MsgAcknowledgementResponse".into() }} +/// ResponseResultType defines the possible outcomes of the execution of a message +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ResponseResultType { + /// Default zero value enumeration + Unspecified = 0, + /// The message did not call the IBC application callbacks (because, for example, the packet had already been relayed) + Noop = 1, + /// The message was executed successfully + Success = 2, + /// The message was executed unsuccessfully + Failure = 3, +} +impl ResponseResultType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + ResponseResultType::Unspecified => "RESPONSE_RESULT_TYPE_UNSPECIFIED", + ResponseResultType::Noop => "RESPONSE_RESULT_TYPE_NOOP", + ResponseResultType::Success => "RESPONSE_RESULT_TYPE_SUCCESS", + ResponseResultType::Failure => "RESPONSE_RESULT_TYPE_FAILURE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "RESPONSE_RESULT_TYPE_UNSPECIFIED" => Some(Self::Unspecified), + "RESPONSE_RESULT_TYPE_NOOP" => Some(Self::Noop), + "RESPONSE_RESULT_TYPE_SUCCESS" => Some(Self::Success), + "RESPONSE_RESULT_TYPE_FAILURE" => Some(Self::Failure), + _ => None, + } + } +} +// @@protoc_insertion_point(module) diff --git a/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.client.v1.rs b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.client.v1.rs new file mode 100644 index 00000000000..40007618d89 --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.client.v1.rs @@ -0,0 +1,668 @@ +// @generated +// This file is @generated by prost-build. +/// IdentifiedClientState defines a client state with an additional client +/// identifier field. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IdentifiedClientState { + /// client identifier + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, + /// client state + #[prost(message, optional, tag="2")] + pub client_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, +} +impl ::prost::Name for IdentifiedClientState { +const NAME: &'static str = "IdentifiedClientState"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.IdentifiedClientState".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.IdentifiedClientState".into() }} +/// ConsensusStateWithHeight defines a consensus state with an additional height +/// field. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ConsensusStateWithHeight { + /// consensus state height + #[prost(message, optional, tag="1")] + pub height: ::core::option::Option, + /// consensus state + #[prost(message, optional, tag="2")] + pub consensus_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, +} +impl ::prost::Name for ConsensusStateWithHeight { +const NAME: &'static str = "ConsensusStateWithHeight"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.ConsensusStateWithHeight".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.ConsensusStateWithHeight".into() }} +/// ClientConsensusStates defines all the stored consensus states for a given +/// client. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ClientConsensusStates { + /// client identifier + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, + /// consensus states and their heights associated with the client + #[prost(message, repeated, tag="2")] + pub consensus_states: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for ClientConsensusStates { +const NAME: &'static str = "ClientConsensusStates"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.ClientConsensusStates".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.ClientConsensusStates".into() }} +/// Height is a monotonically increasing data type +/// that can be compared against another Height for the purposes of updating and +/// freezing clients +/// +/// Normally the RevisionHeight is incremented at each height while keeping +/// RevisionNumber the same. However some consensus algorithms may choose to +/// reset the height in certain conditions e.g. hard forks, state-machine +/// breaking changes In these cases, the RevisionNumber is incremented so that +/// height continues to be monitonically increasing even as the RevisionHeight +/// gets reset +/// +/// Please note that json tags for generated Go code are overridden to explicitly exclude the omitempty jsontag. +/// This enforces the Go json marshaller to always emit zero values for both revision_number and revision_height. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct Height { + /// the revision that the client is currently on + #[prost(uint64, tag="1")] + pub revision_number: u64, + /// the height within the given revision + #[prost(uint64, tag="2")] + pub revision_height: u64, +} +impl ::prost::Name for Height { +const NAME: &'static str = "Height"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.Height".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.Height".into() }} +/// Params defines the set of IBC light client parameters. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Params { + /// allowed_clients defines the list of allowed client state types which can be created + /// and interacted with. If a client type is removed from the allowed clients list, usage + /// of this client will be disabled until it is added again to the list. + #[prost(string, repeated, tag="1")] + pub allowed_clients: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +impl ::prost::Name for Params { +const NAME: &'static str = "Params"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.Params".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.Params".into() }} +/// GenesisState defines the ibc client submodule's genesis state. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GenesisState { + /// client states with their corresponding identifiers + #[prost(message, repeated, tag="1")] + pub clients: ::prost::alloc::vec::Vec, + /// consensus states from each client + #[prost(message, repeated, tag="2")] + pub clients_consensus: ::prost::alloc::vec::Vec, + /// metadata from each client + #[prost(message, repeated, tag="3")] + pub clients_metadata: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="4")] + pub params: ::core::option::Option, + /// Deprecated: create_localhost has been deprecated. + /// The localhost client is automatically created at genesis. + #[deprecated] + #[prost(bool, tag="5")] + pub create_localhost: bool, + /// the sequence for the next generated client identifier + #[prost(uint64, tag="6")] + pub next_client_sequence: u64, +} +impl ::prost::Name for GenesisState { +const NAME: &'static str = "GenesisState"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.GenesisState".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.GenesisState".into() }} +/// GenesisMetadata defines the genesis type for metadata that will be used +/// to export all client store keys that are not client or consensus states. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GenesisMetadata { + /// store key of metadata without clientID-prefix + #[prost(bytes="vec", tag="1")] + pub key: ::prost::alloc::vec::Vec, + /// metadata value + #[prost(bytes="vec", tag="2")] + pub value: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for GenesisMetadata { +const NAME: &'static str = "GenesisMetadata"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.GenesisMetadata".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.GenesisMetadata".into() }} +/// IdentifiedGenesisMetadata has the client metadata with the corresponding +/// client id. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IdentifiedGenesisMetadata { + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, + #[prost(message, repeated, tag="2")] + pub client_metadata: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for IdentifiedGenesisMetadata { +const NAME: &'static str = "IdentifiedGenesisMetadata"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.IdentifiedGenesisMetadata".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.IdentifiedGenesisMetadata".into() }} +/// QueryClientStateRequest is the request type for the Query/ClientState RPC +/// method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryClientStateRequest { + /// client state unique identifier + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryClientStateRequest { +const NAME: &'static str = "QueryClientStateRequest"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.QueryClientStateRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.QueryClientStateRequest".into() }} +/// QueryClientStateResponse is the response type for the Query/ClientState RPC +/// method. Besides the client state, it includes a proof and the height from +/// which the proof was retrieved. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryClientStateResponse { + /// client state associated with the request identifier + #[prost(message, optional, tag="1")] + pub client_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, + /// merkle proof of existence + #[prost(bytes="vec", tag="2")] + pub proof: ::prost::alloc::vec::Vec, + /// height at which the proof was retrieved + #[prost(message, optional, tag="3")] + pub proof_height: ::core::option::Option, +} +impl ::prost::Name for QueryClientStateResponse { +const NAME: &'static str = "QueryClientStateResponse"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.QueryClientStateResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.QueryClientStateResponse".into() }} +/// QueryClientStatesRequest is the request type for the Query/ClientStates RPC +/// method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryClientStatesRequest { + /// pagination request + #[prost(message, optional, tag="1")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageRequest>, +} +impl ::prost::Name for QueryClientStatesRequest { +const NAME: &'static str = "QueryClientStatesRequest"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.QueryClientStatesRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.QueryClientStatesRequest".into() }} +/// QueryClientStatesResponse is the response type for the Query/ClientStates RPC +/// method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryClientStatesResponse { + /// list of stored ClientStates of the chain. + #[prost(message, repeated, tag="1")] + pub client_states: ::prost::alloc::vec::Vec, + /// pagination response + #[prost(message, optional, tag="2")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageResponse>, +} +impl ::prost::Name for QueryClientStatesResponse { +const NAME: &'static str = "QueryClientStatesResponse"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.QueryClientStatesResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.QueryClientStatesResponse".into() }} +/// QueryConsensusStateRequest is the request type for the Query/ConsensusState +/// RPC method. Besides the consensus state, it includes a proof and the height +/// from which the proof was retrieved. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryConsensusStateRequest { + /// client identifier + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, + /// consensus state revision number + #[prost(uint64, tag="2")] + pub revision_number: u64, + /// consensus state revision height + #[prost(uint64, tag="3")] + pub revision_height: u64, + /// latest_height overrides the height field and queries the latest stored + /// ConsensusState + #[prost(bool, tag="4")] + pub latest_height: bool, +} +impl ::prost::Name for QueryConsensusStateRequest { +const NAME: &'static str = "QueryConsensusStateRequest"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.QueryConsensusStateRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.QueryConsensusStateRequest".into() }} +/// QueryConsensusStateResponse is the response type for the Query/ConsensusState +/// RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryConsensusStateResponse { + /// consensus state associated with the client identifier at the given height + #[prost(message, optional, tag="1")] + pub consensus_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, + /// merkle proof of existence + #[prost(bytes="vec", tag="2")] + pub proof: ::prost::alloc::vec::Vec, + /// height at which the proof was retrieved + #[prost(message, optional, tag="3")] + pub proof_height: ::core::option::Option, +} +impl ::prost::Name for QueryConsensusStateResponse { +const NAME: &'static str = "QueryConsensusStateResponse"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.QueryConsensusStateResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.QueryConsensusStateResponse".into() }} +/// QueryConsensusStatesRequest is the request type for the Query/ConsensusStates +/// RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryConsensusStatesRequest { + /// client identifier + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, + /// pagination request + #[prost(message, optional, tag="2")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageRequest>, +} +impl ::prost::Name for QueryConsensusStatesRequest { +const NAME: &'static str = "QueryConsensusStatesRequest"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.QueryConsensusStatesRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.QueryConsensusStatesRequest".into() }} +/// QueryConsensusStatesResponse is the response type for the +/// Query/ConsensusStates RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryConsensusStatesResponse { + /// consensus states associated with the identifier + #[prost(message, repeated, tag="1")] + pub consensus_states: ::prost::alloc::vec::Vec, + /// pagination response + #[prost(message, optional, tag="2")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageResponse>, +} +impl ::prost::Name for QueryConsensusStatesResponse { +const NAME: &'static str = "QueryConsensusStatesResponse"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.QueryConsensusStatesResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.QueryConsensusStatesResponse".into() }} +/// QueryConsensusStateHeightsRequest is the request type for Query/ConsensusStateHeights +/// RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryConsensusStateHeightsRequest { + /// client identifier + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, + /// pagination request + #[prost(message, optional, tag="2")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageRequest>, +} +impl ::prost::Name for QueryConsensusStateHeightsRequest { +const NAME: &'static str = "QueryConsensusStateHeightsRequest"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.QueryConsensusStateHeightsRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.QueryConsensusStateHeightsRequest".into() }} +/// QueryConsensusStateHeightsResponse is the response type for the +/// Query/ConsensusStateHeights RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryConsensusStateHeightsResponse { + /// consensus state heights + #[prost(message, repeated, tag="1")] + pub consensus_state_heights: ::prost::alloc::vec::Vec, + /// pagination response + #[prost(message, optional, tag="2")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageResponse>, +} +impl ::prost::Name for QueryConsensusStateHeightsResponse { +const NAME: &'static str = "QueryConsensusStateHeightsResponse"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.QueryConsensusStateHeightsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.QueryConsensusStateHeightsResponse".into() }} +/// QueryClientStatusRequest is the request type for the Query/ClientStatus RPC +/// method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryClientStatusRequest { + /// client unique identifier + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryClientStatusRequest { +const NAME: &'static str = "QueryClientStatusRequest"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.QueryClientStatusRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.QueryClientStatusRequest".into() }} +/// QueryClientStatusResponse is the response type for the Query/ClientStatus RPC +/// method. It returns the current status of the IBC client. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryClientStatusResponse { + #[prost(string, tag="1")] + pub status: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryClientStatusResponse { +const NAME: &'static str = "QueryClientStatusResponse"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.QueryClientStatusResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.QueryClientStatusResponse".into() }} +/// QueryClientParamsRequest is the request type for the Query/ClientParams RPC +/// method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct QueryClientParamsRequest { +} +impl ::prost::Name for QueryClientParamsRequest { +const NAME: &'static str = "QueryClientParamsRequest"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.QueryClientParamsRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.QueryClientParamsRequest".into() }} +/// QueryClientParamsResponse is the response type for the Query/ClientParams RPC +/// method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryClientParamsResponse { + /// params defines the parameters of the module. + #[prost(message, optional, tag="1")] + pub params: ::core::option::Option, +} +impl ::prost::Name for QueryClientParamsResponse { +const NAME: &'static str = "QueryClientParamsResponse"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.QueryClientParamsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.QueryClientParamsResponse".into() }} +/// QueryUpgradedClientStateRequest is the request type for the +/// Query/UpgradedClientState RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct QueryUpgradedClientStateRequest { +} +impl ::prost::Name for QueryUpgradedClientStateRequest { +const NAME: &'static str = "QueryUpgradedClientStateRequest"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.QueryUpgradedClientStateRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.QueryUpgradedClientStateRequest".into() }} +/// QueryUpgradedClientStateResponse is the response type for the +/// Query/UpgradedClientState RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryUpgradedClientStateResponse { + /// client state associated with the request identifier + #[prost(message, optional, tag="1")] + pub upgraded_client_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, +} +impl ::prost::Name for QueryUpgradedClientStateResponse { +const NAME: &'static str = "QueryUpgradedClientStateResponse"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.QueryUpgradedClientStateResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.QueryUpgradedClientStateResponse".into() }} +/// QueryUpgradedConsensusStateRequest is the request type for the +/// Query/UpgradedConsensusState RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct QueryUpgradedConsensusStateRequest { +} +impl ::prost::Name for QueryUpgradedConsensusStateRequest { +const NAME: &'static str = "QueryUpgradedConsensusStateRequest"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.QueryUpgradedConsensusStateRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.QueryUpgradedConsensusStateRequest".into() }} +/// QueryUpgradedConsensusStateResponse is the response type for the +/// Query/UpgradedConsensusState RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryUpgradedConsensusStateResponse { + /// Consensus state associated with the request identifier + #[prost(message, optional, tag="1")] + pub upgraded_consensus_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, +} +impl ::prost::Name for QueryUpgradedConsensusStateResponse { +const NAME: &'static str = "QueryUpgradedConsensusStateResponse"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.QueryUpgradedConsensusStateResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.QueryUpgradedConsensusStateResponse".into() }} +/// QueryVerifyMembershipRequest is the request type for the Query/VerifyMembership RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryVerifyMembershipRequest { + /// client unique identifier. + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, + /// the proof to be verified by the client. + #[prost(bytes="vec", tag="2")] + pub proof: ::prost::alloc::vec::Vec, + /// the height of the commitment root at which the proof is verified. + #[prost(message, optional, tag="3")] + pub proof_height: ::core::option::Option, + /// the value which is proven. + #[prost(bytes="vec", tag="5")] + pub value: ::prost::alloc::vec::Vec, + /// optional time delay + #[prost(uint64, tag="6")] + pub time_delay: u64, + /// optional block delay + #[prost(uint64, tag="7")] + pub block_delay: u64, + /// the commitment key path. + #[prost(message, optional, tag="8")] + pub merkle_path: ::core::option::Option, +} +impl ::prost::Name for QueryVerifyMembershipRequest { +const NAME: &'static str = "QueryVerifyMembershipRequest"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.QueryVerifyMembershipRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.QueryVerifyMembershipRequest".into() }} +/// QueryVerifyMembershipResponse is the response type for the Query/VerifyMembership RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct QueryVerifyMembershipResponse { + /// boolean indicating success or failure of proof verification. + #[prost(bool, tag="1")] + pub success: bool, +} +impl ::prost::Name for QueryVerifyMembershipResponse { +const NAME: &'static str = "QueryVerifyMembershipResponse"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.QueryVerifyMembershipResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.QueryVerifyMembershipResponse".into() }} +/// MsgCreateClient defines a message to create an IBC client +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgCreateClient { + /// light client state + #[prost(message, optional, tag="1")] + pub client_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, + /// consensus state associated with the client that corresponds to a given + /// height. + #[prost(message, optional, tag="2")] + pub consensus_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, + /// signer address + #[prost(string, tag="3")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgCreateClient { +const NAME: &'static str = "MsgCreateClient"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.MsgCreateClient".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.MsgCreateClient".into() }} +/// MsgCreateClientResponse defines the Msg/CreateClient response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgCreateClientResponse { + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgCreateClientResponse { +const NAME: &'static str = "MsgCreateClientResponse"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.MsgCreateClientResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.MsgCreateClientResponse".into() }} +/// MsgUpdateClient defines an sdk.Msg to update a IBC client state using +/// the given client message. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgUpdateClient { + /// client unique identifier + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, + /// client message to update the light client + #[prost(message, optional, tag="2")] + pub client_message: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, + /// signer address + #[prost(string, tag="3")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgUpdateClient { +const NAME: &'static str = "MsgUpdateClient"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.MsgUpdateClient".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.MsgUpdateClient".into() }} +/// MsgUpdateClientResponse defines the Msg/UpdateClient response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgUpdateClientResponse { +} +impl ::prost::Name for MsgUpdateClientResponse { +const NAME: &'static str = "MsgUpdateClientResponse"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.MsgUpdateClientResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.MsgUpdateClientResponse".into() }} +/// MsgUpgradeClient defines an sdk.Msg to upgrade an IBC client to a new client +/// state +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgUpgradeClient { + /// client unique identifier + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, + /// upgraded client state + #[prost(message, optional, tag="2")] + pub client_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, + /// upgraded consensus state, only contains enough information to serve as a + /// basis of trust in update logic + #[prost(message, optional, tag="3")] + pub consensus_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, + /// proof that old chain committed to new client + #[prost(bytes="vec", tag="4")] + pub proof_upgrade_client: ::prost::alloc::vec::Vec, + /// proof that old chain committed to new consensus state + #[prost(bytes="vec", tag="5")] + pub proof_upgrade_consensus_state: ::prost::alloc::vec::Vec, + /// signer address + #[prost(string, tag="6")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgUpgradeClient { +const NAME: &'static str = "MsgUpgradeClient"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.MsgUpgradeClient".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.MsgUpgradeClient".into() }} +/// MsgUpgradeClientResponse defines the Msg/UpgradeClient response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgUpgradeClientResponse { +} +impl ::prost::Name for MsgUpgradeClientResponse { +const NAME: &'static str = "MsgUpgradeClientResponse"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.MsgUpgradeClientResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.MsgUpgradeClientResponse".into() }} +/// MsgSubmitMisbehaviour defines an sdk.Msg type that submits Evidence for +/// light client misbehaviour. +/// This message has been deprecated. Use MsgUpdateClient instead. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgSubmitMisbehaviour { + /// client unique identifier + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, + /// misbehaviour used for freezing the light client + #[prost(message, optional, tag="2")] + pub misbehaviour: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, + /// signer address + #[prost(string, tag="3")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgSubmitMisbehaviour { +const NAME: &'static str = "MsgSubmitMisbehaviour"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.MsgSubmitMisbehaviour".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.MsgSubmitMisbehaviour".into() }} +/// MsgSubmitMisbehaviourResponse defines the Msg/SubmitMisbehaviour response +/// type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgSubmitMisbehaviourResponse { +} +impl ::prost::Name for MsgSubmitMisbehaviourResponse { +const NAME: &'static str = "MsgSubmitMisbehaviourResponse"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.MsgSubmitMisbehaviourResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.MsgSubmitMisbehaviourResponse".into() }} +/// MsgRecoverClient defines the message used to recover a frozen or expired client. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgRecoverClient { + /// the client identifier for the client to be updated if the proposal passes + #[prost(string, tag="1")] + pub subject_client_id: ::prost::alloc::string::String, + /// the substitute client identifier for the client which will replace the subject + /// client + #[prost(string, tag="2")] + pub substitute_client_id: ::prost::alloc::string::String, + /// signer address + #[prost(string, tag="3")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgRecoverClient { +const NAME: &'static str = "MsgRecoverClient"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.MsgRecoverClient".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.MsgRecoverClient".into() }} +/// MsgRecoverClientResponse defines the Msg/RecoverClient response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgRecoverClientResponse { +} +impl ::prost::Name for MsgRecoverClientResponse { +const NAME: &'static str = "MsgRecoverClientResponse"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.MsgRecoverClientResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.MsgRecoverClientResponse".into() }} +/// MsgIBCSoftwareUpgrade defines the message used to schedule an upgrade of an IBC client using a v1 governance proposal +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgIbcSoftwareUpgrade { + #[prost(message, optional, tag="1")] + pub plan: ::core::option::Option<::cosmos_sdk_proto::cosmos::upgrade::v1beta1::Plan>, + /// An UpgradedClientState must be provided to perform an IBC breaking upgrade. + /// This will make the chain commit to the correct upgraded (self) client state + /// before the upgrade occurs, so that connecting chains can verify that the + /// new upgraded client is valid by verifying a proof on the previous version + /// of the chain. This will allow IBC connections to persist smoothly across + /// planned chain upgrades. Correspondingly, the UpgradedClientState field has been + /// deprecated in the Cosmos SDK to allow for this logic to exist solely in + /// the 02-client module. + #[prost(message, optional, tag="2")] + pub upgraded_client_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, + /// signer address + #[prost(string, tag="3")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgIbcSoftwareUpgrade { +const NAME: &'static str = "MsgIBCSoftwareUpgrade"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.MsgIBCSoftwareUpgrade".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.MsgIBCSoftwareUpgrade".into() }} +/// MsgIBCSoftwareUpgradeResponse defines the Msg/IBCSoftwareUpgrade response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgIbcSoftwareUpgradeResponse { +} +impl ::prost::Name for MsgIbcSoftwareUpgradeResponse { +const NAME: &'static str = "MsgIBCSoftwareUpgradeResponse"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.MsgIBCSoftwareUpgradeResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.MsgIBCSoftwareUpgradeResponse".into() }} +/// MsgUpdateParams defines the sdk.Msg type to update the client parameters. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgUpdateParams { + /// signer address + #[prost(string, tag="1")] + pub signer: ::prost::alloc::string::String, + /// params defines the client parameters to update. + /// + /// NOTE: All parameters must be supplied. + #[prost(message, optional, tag="2")] + pub params: ::core::option::Option, +} +impl ::prost::Name for MsgUpdateParams { +const NAME: &'static str = "MsgUpdateParams"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.MsgUpdateParams".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.MsgUpdateParams".into() }} +/// MsgUpdateParamsResponse defines the MsgUpdateParams response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgUpdateParamsResponse { +} +impl ::prost::Name for MsgUpdateParamsResponse { +const NAME: &'static str = "MsgUpdateParamsResponse"; +const PACKAGE: &'static str = "ibc.core.client.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.client.v1.MsgUpdateParamsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.client.v1.MsgUpdateParamsResponse".into() }} +// @@protoc_insertion_point(module) diff --git a/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.commitment.v1.rs b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.commitment.v1.rs new file mode 100644 index 00000000000..b719947ed32 --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.commitment.v1.rs @@ -0,0 +1,43 @@ +// @generated +// This file is @generated by prost-build. +/// MerkleRoot defines a merkle root hash. +/// In the Cosmos SDK, the AppHash of a block header becomes the root. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MerkleRoot { + #[prost(bytes="vec", tag="1")] + pub hash: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for MerkleRoot { +const NAME: &'static str = "MerkleRoot"; +const PACKAGE: &'static str = "ibc.core.commitment.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.commitment.v1.MerkleRoot".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.commitment.v1.MerkleRoot".into() }} +/// MerklePrefix is merkle path prefixed to the key. +/// The constructed key from the Path and the key will be append(Path.KeyPath, +/// append(Path.KeyPrefix, key...)) +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MerklePrefix { + #[prost(bytes="vec", tag="1")] + pub key_prefix: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for MerklePrefix { +const NAME: &'static str = "MerklePrefix"; +const PACKAGE: &'static str = "ibc.core.commitment.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.commitment.v1.MerklePrefix".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.commitment.v1.MerklePrefix".into() }} +/// MerkleProof is a wrapper type over a chain of CommitmentProofs. +/// It demonstrates membership or non-membership for an element or set of +/// elements, verifiable in conjunction with a known commitment root. Proofs +/// should be succinct. +/// MerkleProofs are ordered from leaf-to-root +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MerkleProof { + #[prost(message, repeated, tag="1")] + pub proofs: ::prost::alloc::vec::Vec<::ics23::CommitmentProof>, +} +impl ::prost::Name for MerkleProof { +const NAME: &'static str = "MerkleProof"; +const PACKAGE: &'static str = "ibc.core.commitment.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.commitment.v1.MerkleProof".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.commitment.v1.MerkleProof".into() }} +// @@protoc_insertion_point(module) diff --git a/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.commitment.v2.rs b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.commitment.v2.rs new file mode 100644 index 00000000000..ecc768c51c6 --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.commitment.v2.rs @@ -0,0 +1,16 @@ +// @generated +// This file is @generated by prost-build. +/// MerklePath is the path used to verify commitment proofs, which can be an +/// arbitrary structured object (defined by a commitment type). +/// MerklePath is represented from root-to-leaf +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MerklePath { + #[prost(bytes="vec", repeated, tag="1")] + pub key_path: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, +} +impl ::prost::Name for MerklePath { +const NAME: &'static str = "MerklePath"; +const PACKAGE: &'static str = "ibc.core.commitment.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.commitment.v2.MerklePath".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.commitment.v2.MerklePath".into() }} +// @@protoc_insertion_point(module) diff --git a/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.connection.v1.rs b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.connection.v1.rs new file mode 100644 index 00000000000..238fe76fb6d --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.connection.v1.rs @@ -0,0 +1,584 @@ +// @generated +// This file is @generated by prost-build. +// ICS03 - Connection Data Structures as defined in +// + +/// ConnectionEnd defines a stateful object on a chain connected to another +/// separate one. +/// NOTE: there must only be 2 defined ConnectionEnds to establish +/// a connection between two chains. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ConnectionEnd { + /// client associated with this connection. + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, + /// IBC version which can be utilised to determine encodings or protocols for + /// channels or packets utilising this connection. + #[prost(message, repeated, tag="2")] + pub versions: ::prost::alloc::vec::Vec, + /// current state of the connection end. + #[prost(enumeration="State", tag="3")] + pub state: i32, + /// counterparty chain associated with this connection. + #[prost(message, optional, tag="4")] + pub counterparty: ::core::option::Option, + /// delay period that must pass before a consensus state can be used for + /// packet-verification NOTE: delay period logic is only implemented by some + /// clients. + #[prost(uint64, tag="5")] + pub delay_period: u64, +} +impl ::prost::Name for ConnectionEnd { +const NAME: &'static str = "ConnectionEnd"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.ConnectionEnd".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.ConnectionEnd".into() }} +/// IdentifiedConnection defines a connection with additional connection +/// identifier field. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IdentifiedConnection { + /// connection identifier. + #[prost(string, tag="1")] + pub id: ::prost::alloc::string::String, + /// client associated with this connection. + #[prost(string, tag="2")] + pub client_id: ::prost::alloc::string::String, + /// IBC version which can be utilised to determine encodings or protocols for + /// channels or packets utilising this connection + #[prost(message, repeated, tag="3")] + pub versions: ::prost::alloc::vec::Vec, + /// current state of the connection end. + #[prost(enumeration="State", tag="4")] + pub state: i32, + /// counterparty chain associated with this connection. + #[prost(message, optional, tag="5")] + pub counterparty: ::core::option::Option, + /// delay period associated with this connection. + #[prost(uint64, tag="6")] + pub delay_period: u64, +} +impl ::prost::Name for IdentifiedConnection { +const NAME: &'static str = "IdentifiedConnection"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.IdentifiedConnection".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.IdentifiedConnection".into() }} +/// Counterparty defines the counterparty chain associated with a connection end. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Counterparty { + /// identifies the client on the counterparty chain associated with a given + /// connection. + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, + /// identifies the connection end on the counterparty chain associated with a + /// given connection. + #[prost(string, tag="2")] + pub connection_id: ::prost::alloc::string::String, + /// commitment merkle prefix of the counterparty chain. + #[prost(message, optional, tag="3")] + pub prefix: ::core::option::Option, +} +impl ::prost::Name for Counterparty { +const NAME: &'static str = "Counterparty"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.Counterparty".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.Counterparty".into() }} +/// ClientPaths define all the connection paths for a client state. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ClientPaths { + /// list of connection paths + #[prost(string, repeated, tag="1")] + pub paths: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +impl ::prost::Name for ClientPaths { +const NAME: &'static str = "ClientPaths"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.ClientPaths".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.ClientPaths".into() }} +/// ConnectionPaths define all the connection paths for a given client state. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ConnectionPaths { + /// client state unique identifier + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, + /// list of connection paths + #[prost(string, repeated, tag="2")] + pub paths: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +impl ::prost::Name for ConnectionPaths { +const NAME: &'static str = "ConnectionPaths"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.ConnectionPaths".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.ConnectionPaths".into() }} +/// Version defines the versioning scheme used to negotiate the IBC version in +/// the connection handshake. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Version { + /// unique version identifier + #[prost(string, tag="1")] + pub identifier: ::prost::alloc::string::String, + /// list of features compatible with the specified identifier + #[prost(string, repeated, tag="2")] + pub features: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +impl ::prost::Name for Version { +const NAME: &'static str = "Version"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.Version".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.Version".into() }} +/// Params defines the set of Connection parameters. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct Params { + /// maximum expected time per block (in nanoseconds), used to enforce block delay. This parameter should reflect the + /// largest amount of time that the chain might reasonably take to produce the next block under normal operating + /// conditions. A safe choice is 3-5x the expected time per block. + #[prost(uint64, tag="1")] + pub max_expected_time_per_block: u64, +} +impl ::prost::Name for Params { +const NAME: &'static str = "Params"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.Params".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.Params".into() }} +/// State defines if a connection is in one of the following states: +/// INIT, TRYOPEN, OPEN or UNINITIALIZED. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum State { + /// Default State + UninitializedUnspecified = 0, + /// A connection end has just started the opening handshake. + Init = 1, + /// A connection end has acknowledged the handshake step on the counterparty + /// chain. + Tryopen = 2, + /// A connection end has completed the handshake. + Open = 3, +} +impl State { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + State::UninitializedUnspecified => "STATE_UNINITIALIZED_UNSPECIFIED", + State::Init => "STATE_INIT", + State::Tryopen => "STATE_TRYOPEN", + State::Open => "STATE_OPEN", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "STATE_UNINITIALIZED_UNSPECIFIED" => Some(Self::UninitializedUnspecified), + "STATE_INIT" => Some(Self::Init), + "STATE_TRYOPEN" => Some(Self::Tryopen), + "STATE_OPEN" => Some(Self::Open), + _ => None, + } + } +} +/// GenesisState defines the ibc connection submodule's genesis state. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GenesisState { + #[prost(message, repeated, tag="1")] + pub connections: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag="2")] + pub client_connection_paths: ::prost::alloc::vec::Vec, + /// the sequence for the next generated connection identifier + #[prost(uint64, tag="3")] + pub next_connection_sequence: u64, + #[prost(message, optional, tag="4")] + pub params: ::core::option::Option, +} +impl ::prost::Name for GenesisState { +const NAME: &'static str = "GenesisState"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.GenesisState".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.GenesisState".into() }} +/// QueryConnectionRequest is the request type for the Query/Connection RPC +/// method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryConnectionRequest { + /// connection unique identifier + #[prost(string, tag="1")] + pub connection_id: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryConnectionRequest { +const NAME: &'static str = "QueryConnectionRequest"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.QueryConnectionRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.QueryConnectionRequest".into() }} +/// QueryConnectionResponse is the response type for the Query/Connection RPC +/// method. Besides the connection end, it includes a proof and the height from +/// which the proof was retrieved. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryConnectionResponse { + /// connection associated with the request identifier + #[prost(message, optional, tag="1")] + pub connection: ::core::option::Option, + /// merkle proof of existence + #[prost(bytes="vec", tag="2")] + pub proof: ::prost::alloc::vec::Vec, + /// height at which the proof was retrieved + #[prost(message, optional, tag="3")] + pub proof_height: ::core::option::Option, +} +impl ::prost::Name for QueryConnectionResponse { +const NAME: &'static str = "QueryConnectionResponse"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.QueryConnectionResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.QueryConnectionResponse".into() }} +/// QueryConnectionsRequest is the request type for the Query/Connections RPC +/// method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryConnectionsRequest { + #[prost(message, optional, tag="1")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageRequest>, +} +impl ::prost::Name for QueryConnectionsRequest { +const NAME: &'static str = "QueryConnectionsRequest"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.QueryConnectionsRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.QueryConnectionsRequest".into() }} +/// QueryConnectionsResponse is the response type for the Query/Connections RPC +/// method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryConnectionsResponse { + /// list of stored connections of the chain. + #[prost(message, repeated, tag="1")] + pub connections: ::prost::alloc::vec::Vec, + /// pagination response + #[prost(message, optional, tag="2")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageResponse>, + /// query block height + #[prost(message, optional, tag="3")] + pub height: ::core::option::Option, +} +impl ::prost::Name for QueryConnectionsResponse { +const NAME: &'static str = "QueryConnectionsResponse"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.QueryConnectionsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.QueryConnectionsResponse".into() }} +/// QueryClientConnectionsRequest is the request type for the +/// Query/ClientConnections RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryClientConnectionsRequest { + /// client identifier associated with a connection + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryClientConnectionsRequest { +const NAME: &'static str = "QueryClientConnectionsRequest"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.QueryClientConnectionsRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.QueryClientConnectionsRequest".into() }} +/// QueryClientConnectionsResponse is the response type for the +/// Query/ClientConnections RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryClientConnectionsResponse { + /// slice of all the connection paths associated with a client. + #[prost(string, repeated, tag="1")] + pub connection_paths: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// merkle proof of existence + #[prost(bytes="vec", tag="2")] + pub proof: ::prost::alloc::vec::Vec, + /// height at which the proof was generated + #[prost(message, optional, tag="3")] + pub proof_height: ::core::option::Option, +} +impl ::prost::Name for QueryClientConnectionsResponse { +const NAME: &'static str = "QueryClientConnectionsResponse"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.QueryClientConnectionsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.QueryClientConnectionsResponse".into() }} +/// QueryConnectionClientStateRequest is the request type for the +/// Query/ConnectionClientState RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryConnectionClientStateRequest { + /// connection identifier + #[prost(string, tag="1")] + pub connection_id: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryConnectionClientStateRequest { +const NAME: &'static str = "QueryConnectionClientStateRequest"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.QueryConnectionClientStateRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.QueryConnectionClientStateRequest".into() }} +/// QueryConnectionClientStateResponse is the response type for the +/// Query/ConnectionClientState RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryConnectionClientStateResponse { + /// client state associated with the channel + #[prost(message, optional, tag="1")] + pub identified_client_state: ::core::option::Option, + /// merkle proof of existence + #[prost(bytes="vec", tag="2")] + pub proof: ::prost::alloc::vec::Vec, + /// height at which the proof was retrieved + #[prost(message, optional, tag="3")] + pub proof_height: ::core::option::Option, +} +impl ::prost::Name for QueryConnectionClientStateResponse { +const NAME: &'static str = "QueryConnectionClientStateResponse"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.QueryConnectionClientStateResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.QueryConnectionClientStateResponse".into() }} +/// QueryConnectionConsensusStateRequest is the request type for the +/// Query/ConnectionConsensusState RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryConnectionConsensusStateRequest { + /// connection identifier + #[prost(string, tag="1")] + pub connection_id: ::prost::alloc::string::String, + #[prost(uint64, tag="2")] + pub revision_number: u64, + #[prost(uint64, tag="3")] + pub revision_height: u64, +} +impl ::prost::Name for QueryConnectionConsensusStateRequest { +const NAME: &'static str = "QueryConnectionConsensusStateRequest"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.QueryConnectionConsensusStateRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.QueryConnectionConsensusStateRequest".into() }} +/// QueryConnectionConsensusStateResponse is the response type for the +/// Query/ConnectionConsensusState RPC method +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryConnectionConsensusStateResponse { + /// consensus state associated with the channel + #[prost(message, optional, tag="1")] + pub consensus_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, + /// client ID associated with the consensus state + #[prost(string, tag="2")] + pub client_id: ::prost::alloc::string::String, + /// merkle proof of existence + #[prost(bytes="vec", tag="3")] + pub proof: ::prost::alloc::vec::Vec, + /// height at which the proof was retrieved + #[prost(message, optional, tag="4")] + pub proof_height: ::core::option::Option, +} +impl ::prost::Name for QueryConnectionConsensusStateResponse { +const NAME: &'static str = "QueryConnectionConsensusStateResponse"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.QueryConnectionConsensusStateResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.QueryConnectionConsensusStateResponse".into() }} +/// QueryConnectionParamsRequest is the request type for the Query/ConnectionParams RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct QueryConnectionParamsRequest { +} +impl ::prost::Name for QueryConnectionParamsRequest { +const NAME: &'static str = "QueryConnectionParamsRequest"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.QueryConnectionParamsRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.QueryConnectionParamsRequest".into() }} +/// QueryConnectionParamsResponse is the response type for the Query/ConnectionParams RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct QueryConnectionParamsResponse { + /// params defines the parameters of the module. + #[prost(message, optional, tag="1")] + pub params: ::core::option::Option, +} +impl ::prost::Name for QueryConnectionParamsResponse { +const NAME: &'static str = "QueryConnectionParamsResponse"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.QueryConnectionParamsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.QueryConnectionParamsResponse".into() }} +/// MsgConnectionOpenInit defines the msg sent by an account on Chain A to +/// initialize a connection with Chain B. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgConnectionOpenInit { + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, + #[prost(message, optional, tag="2")] + pub counterparty: ::core::option::Option, + #[prost(message, optional, tag="3")] + pub version: ::core::option::Option, + #[prost(uint64, tag="4")] + pub delay_period: u64, + #[prost(string, tag="5")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgConnectionOpenInit { +const NAME: &'static str = "MsgConnectionOpenInit"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.MsgConnectionOpenInit".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.MsgConnectionOpenInit".into() }} +/// MsgConnectionOpenInitResponse defines the Msg/ConnectionOpenInit response +/// type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgConnectionOpenInitResponse { +} +impl ::prost::Name for MsgConnectionOpenInitResponse { +const NAME: &'static str = "MsgConnectionOpenInitResponse"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.MsgConnectionOpenInitResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.MsgConnectionOpenInitResponse".into() }} +/// MsgConnectionOpenTry defines a msg sent by a Relayer to try to open a +/// connection on Chain B. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgConnectionOpenTry { + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, + /// Deprecated: this field is unused. Crossing hellos are no longer supported in core IBC. + #[deprecated] + #[prost(string, tag="2")] + pub previous_connection_id: ::prost::alloc::string::String, + /// Deprecated: this field is unused. + #[deprecated] + #[prost(message, optional, tag="3")] + pub client_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, + #[prost(message, optional, tag="4")] + pub counterparty: ::core::option::Option, + #[prost(uint64, tag="5")] + pub delay_period: u64, + #[prost(message, repeated, tag="6")] + pub counterparty_versions: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="7")] + pub proof_height: ::core::option::Option, + /// proof of the initialization the connection on Chain A: `UNINITIALIZED -> + /// INIT` + #[prost(bytes="vec", tag="8")] + pub proof_init: ::prost::alloc::vec::Vec, + /// Deprecated: this field is unused. + #[deprecated] + #[prost(bytes="vec", tag="9")] + pub proof_client: ::prost::alloc::vec::Vec, + /// Deprecated: this field is unused. + #[deprecated] + #[prost(bytes="vec", tag="10")] + pub proof_consensus: ::prost::alloc::vec::Vec, + /// Deprecated: this field is unused. + #[deprecated] + #[prost(message, optional, tag="11")] + pub consensus_height: ::core::option::Option, + #[prost(string, tag="12")] + pub signer: ::prost::alloc::string::String, + /// Deprecated: this field is unused. + #[deprecated] + #[prost(bytes="vec", tag="13")] + pub host_consensus_state_proof: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for MsgConnectionOpenTry { +const NAME: &'static str = "MsgConnectionOpenTry"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.MsgConnectionOpenTry".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.MsgConnectionOpenTry".into() }} +/// MsgConnectionOpenTryResponse defines the Msg/ConnectionOpenTry response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgConnectionOpenTryResponse { +} +impl ::prost::Name for MsgConnectionOpenTryResponse { +const NAME: &'static str = "MsgConnectionOpenTryResponse"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.MsgConnectionOpenTryResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.MsgConnectionOpenTryResponse".into() }} +/// MsgConnectionOpenAck defines a msg sent by a Relayer to Chain A to +/// acknowledge the change of connection state to TRYOPEN on Chain B. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgConnectionOpenAck { + #[prost(string, tag="1")] + pub connection_id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub counterparty_connection_id: ::prost::alloc::string::String, + #[prost(message, optional, tag="3")] + pub version: ::core::option::Option, + /// Deprecated: this field is unused. + #[deprecated] + #[prost(message, optional, tag="4")] + pub client_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, + #[prost(message, optional, tag="5")] + pub proof_height: ::core::option::Option, + /// proof of the initialization the connection on Chain B: `UNINITIALIZED -> + /// TRYOPEN` + #[prost(bytes="vec", tag="6")] + pub proof_try: ::prost::alloc::vec::Vec, + /// Deprecated: this field is unused. + #[deprecated] + #[prost(bytes="vec", tag="7")] + pub proof_client: ::prost::alloc::vec::Vec, + /// Deprecated: this field is unused. + #[deprecated] + #[prost(bytes="vec", tag="8")] + pub proof_consensus: ::prost::alloc::vec::Vec, + /// Deprecated: this field is unused. + #[deprecated] + #[prost(message, optional, tag="9")] + pub consensus_height: ::core::option::Option, + #[prost(string, tag="10")] + pub signer: ::prost::alloc::string::String, + /// Deprecated: this field is unused. + #[deprecated] + #[prost(bytes="vec", tag="11")] + pub host_consensus_state_proof: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for MsgConnectionOpenAck { +const NAME: &'static str = "MsgConnectionOpenAck"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.MsgConnectionOpenAck".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.MsgConnectionOpenAck".into() }} +/// MsgConnectionOpenAckResponse defines the Msg/ConnectionOpenAck response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgConnectionOpenAckResponse { +} +impl ::prost::Name for MsgConnectionOpenAckResponse { +const NAME: &'static str = "MsgConnectionOpenAckResponse"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.MsgConnectionOpenAckResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.MsgConnectionOpenAckResponse".into() }} +/// MsgConnectionOpenConfirm defines a msg sent by a Relayer to Chain B to +/// acknowledge the change of connection state to OPEN on Chain A. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgConnectionOpenConfirm { + #[prost(string, tag="1")] + pub connection_id: ::prost::alloc::string::String, + /// proof for the change of the connection state on Chain A: `INIT -> OPEN` + #[prost(bytes="vec", tag="2")] + pub proof_ack: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="3")] + pub proof_height: ::core::option::Option, + #[prost(string, tag="4")] + pub signer: ::prost::alloc::string::String, +} +impl ::prost::Name for MsgConnectionOpenConfirm { +const NAME: &'static str = "MsgConnectionOpenConfirm"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.MsgConnectionOpenConfirm".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.MsgConnectionOpenConfirm".into() }} +/// MsgConnectionOpenConfirmResponse defines the Msg/ConnectionOpenConfirm +/// response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgConnectionOpenConfirmResponse { +} +impl ::prost::Name for MsgConnectionOpenConfirmResponse { +const NAME: &'static str = "MsgConnectionOpenConfirmResponse"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.MsgConnectionOpenConfirmResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.MsgConnectionOpenConfirmResponse".into() }} +/// MsgUpdateParams defines the sdk.Msg type to update the connection parameters. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgUpdateParams { + /// signer address + #[prost(string, tag="1")] + pub signer: ::prost::alloc::string::String, + /// params defines the connection parameters to update. + /// + /// NOTE: All parameters must be supplied. + #[prost(message, optional, tag="2")] + pub params: ::core::option::Option, +} +impl ::prost::Name for MsgUpdateParams { +const NAME: &'static str = "MsgUpdateParams"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.MsgUpdateParams".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.MsgUpdateParams".into() }} +/// MsgUpdateParamsResponse defines the MsgUpdateParams response type. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgUpdateParamsResponse { +} +impl ::prost::Name for MsgUpdateParamsResponse { +const NAME: &'static str = "MsgUpdateParamsResponse"; +const PACKAGE: &'static str = "ibc.core.connection.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.connection.v1.MsgUpdateParamsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.connection.v1.MsgUpdateParamsResponse".into() }} +// @@protoc_insertion_point(module) diff --git a/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.types.v1.rs b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.types.v1.rs new file mode 100644 index 00000000000..7bd82cbca84 --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.core.types.v1.rs @@ -0,0 +1,21 @@ +// @generated +// This file is @generated by prost-build. +/// GenesisState defines the ibc module's genesis state. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GenesisState { + /// ICS002 - Clients genesis state + #[prost(message, optional, tag="1")] + pub client_genesis: ::core::option::Option, + /// ICS003 - Connections genesis state + #[prost(message, optional, tag="2")] + pub connection_genesis: ::core::option::Option, + /// ICS004 - Channel genesis state + #[prost(message, optional, tag="3")] + pub channel_genesis: ::core::option::Option, +} +impl ::prost::Name for GenesisState { +const NAME: &'static str = "GenesisState"; +const PACKAGE: &'static str = "ibc.core.types.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.core.types.v1.GenesisState".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.core.types.v1.GenesisState".into() }} +// @@protoc_insertion_point(module) diff --git a/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.lightclients.solomachine.v2.rs b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.lightclients.solomachine.v2.rs new file mode 100644 index 00000000000..6ac5f028dd7 --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.lightclients.solomachine.v2.rs @@ -0,0 +1,323 @@ +// @generated +// This file is @generated by prost-build. +/// ClientState defines a solo machine client that tracks the current consensus +/// state and if the client is frozen. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ClientState { + /// latest sequence of the client state + #[prost(uint64, tag="1")] + pub sequence: u64, + /// frozen sequence of the solo machine + #[prost(bool, tag="2")] + pub is_frozen: bool, + #[prost(message, optional, tag="3")] + pub consensus_state: ::core::option::Option, + /// when set to true, will allow governance to update a solo machine client. + /// The client will be unfrozen if it is frozen. + #[prost(bool, tag="4")] + pub allow_update_after_proposal: bool, +} +impl ::prost::Name for ClientState { +const NAME: &'static str = "ClientState"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v2.ClientState".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v2.ClientState".into() }} +/// ConsensusState defines a solo machine consensus state. The sequence of a +/// consensus state is contained in the "height" key used in storing the +/// consensus state. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ConsensusState { + /// public key of the solo machine + #[prost(message, optional, tag="1")] + pub public_key: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, + /// diversifier allows the same public key to be re-used across different solo + /// machine clients (potentially on different chains) without being considered + /// misbehaviour. + #[prost(string, tag="2")] + pub diversifier: ::prost::alloc::string::String, + #[prost(uint64, tag="3")] + pub timestamp: u64, +} +impl ::prost::Name for ConsensusState { +const NAME: &'static str = "ConsensusState"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v2.ConsensusState".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v2.ConsensusState".into() }} +/// Header defines a solo machine consensus header +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Header { + /// sequence to update solo machine public key at + #[prost(uint64, tag="1")] + pub sequence: u64, + #[prost(uint64, tag="2")] + pub timestamp: u64, + #[prost(bytes="vec", tag="3")] + pub signature: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="4")] + pub new_public_key: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, + #[prost(string, tag="5")] + pub new_diversifier: ::prost::alloc::string::String, +} +impl ::prost::Name for Header { +const NAME: &'static str = "Header"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v2.Header".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v2.Header".into() }} +/// Misbehaviour defines misbehaviour for a solo machine which consists +/// of a sequence and two signatures over different messages at that sequence. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Misbehaviour { + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, + #[prost(uint64, tag="2")] + pub sequence: u64, + #[prost(message, optional, tag="3")] + pub signature_one: ::core::option::Option, + #[prost(message, optional, tag="4")] + pub signature_two: ::core::option::Option, +} +impl ::prost::Name for Misbehaviour { +const NAME: &'static str = "Misbehaviour"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v2.Misbehaviour".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v2.Misbehaviour".into() }} +/// SignatureAndData contains a signature and the data signed over to create that +/// signature. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SignatureAndData { + #[prost(bytes="vec", tag="1")] + pub signature: ::prost::alloc::vec::Vec, + #[prost(enumeration="DataType", tag="2")] + pub data_type: i32, + #[prost(bytes="vec", tag="3")] + pub data: ::prost::alloc::vec::Vec, + #[prost(uint64, tag="4")] + pub timestamp: u64, +} +impl ::prost::Name for SignatureAndData { +const NAME: &'static str = "SignatureAndData"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v2.SignatureAndData".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v2.SignatureAndData".into() }} +/// TimestampedSignatureData contains the signature data and the timestamp of the +/// signature. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TimestampedSignatureData { + #[prost(bytes="vec", tag="1")] + pub signature_data: ::prost::alloc::vec::Vec, + #[prost(uint64, tag="2")] + pub timestamp: u64, +} +impl ::prost::Name for TimestampedSignatureData { +const NAME: &'static str = "TimestampedSignatureData"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v2.TimestampedSignatureData".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v2.TimestampedSignatureData".into() }} +/// SignBytes defines the signed bytes used for signature verification. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SignBytes { + #[prost(uint64, tag="1")] + pub sequence: u64, + #[prost(uint64, tag="2")] + pub timestamp: u64, + #[prost(string, tag="3")] + pub diversifier: ::prost::alloc::string::String, + /// type of the data used + #[prost(enumeration="DataType", tag="4")] + pub data_type: i32, + /// marshaled data + #[prost(bytes="vec", tag="5")] + pub data: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for SignBytes { +const NAME: &'static str = "SignBytes"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v2.SignBytes".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v2.SignBytes".into() }} +/// HeaderData returns the SignBytes data for update verification. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct HeaderData { + /// header public key + #[prost(message, optional, tag="1")] + pub new_pub_key: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, + /// header diversifier + #[prost(string, tag="2")] + pub new_diversifier: ::prost::alloc::string::String, +} +impl ::prost::Name for HeaderData { +const NAME: &'static str = "HeaderData"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v2.HeaderData".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v2.HeaderData".into() }} +/// ClientStateData returns the SignBytes data for client state verification. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ClientStateData { + #[prost(bytes="vec", tag="1")] + pub path: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="2")] + pub client_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, +} +impl ::prost::Name for ClientStateData { +const NAME: &'static str = "ClientStateData"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v2.ClientStateData".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v2.ClientStateData".into() }} +/// ConsensusStateData returns the SignBytes data for consensus state +/// verification. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ConsensusStateData { + #[prost(bytes="vec", tag="1")] + pub path: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="2")] + pub consensus_state: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, +} +impl ::prost::Name for ConsensusStateData { +const NAME: &'static str = "ConsensusStateData"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v2.ConsensusStateData".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v2.ConsensusStateData".into() }} +/// ConnectionStateData returns the SignBytes data for connection state +/// verification. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ConnectionStateData { + #[prost(bytes="vec", tag="1")] + pub path: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="2")] + pub connection: ::core::option::Option, +} +impl ::prost::Name for ConnectionStateData { +const NAME: &'static str = "ConnectionStateData"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v2.ConnectionStateData".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v2.ConnectionStateData".into() }} +/// ChannelStateData returns the SignBytes data for channel state +/// verification. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ChannelStateData { + #[prost(bytes="vec", tag="1")] + pub path: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="2")] + pub channel: ::core::option::Option, +} +impl ::prost::Name for ChannelStateData { +const NAME: &'static str = "ChannelStateData"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v2.ChannelStateData".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v2.ChannelStateData".into() }} +/// PacketCommitmentData returns the SignBytes data for packet commitment +/// verification. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PacketCommitmentData { + #[prost(bytes="vec", tag="1")] + pub path: ::prost::alloc::vec::Vec, + #[prost(bytes="vec", tag="2")] + pub commitment: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for PacketCommitmentData { +const NAME: &'static str = "PacketCommitmentData"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v2.PacketCommitmentData".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v2.PacketCommitmentData".into() }} +/// PacketAcknowledgementData returns the SignBytes data for acknowledgement +/// verification. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PacketAcknowledgementData { + #[prost(bytes="vec", tag="1")] + pub path: ::prost::alloc::vec::Vec, + #[prost(bytes="vec", tag="2")] + pub acknowledgement: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for PacketAcknowledgementData { +const NAME: &'static str = "PacketAcknowledgementData"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v2.PacketAcknowledgementData".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v2.PacketAcknowledgementData".into() }} +/// PacketReceiptAbsenceData returns the SignBytes data for +/// packet receipt absence verification. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PacketReceiptAbsenceData { + #[prost(bytes="vec", tag="1")] + pub path: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for PacketReceiptAbsenceData { +const NAME: &'static str = "PacketReceiptAbsenceData"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v2.PacketReceiptAbsenceData".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v2.PacketReceiptAbsenceData".into() }} +/// NextSequenceRecvData returns the SignBytes data for verification of the next +/// sequence to be received. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct NextSequenceRecvData { + #[prost(bytes="vec", tag="1")] + pub path: ::prost::alloc::vec::Vec, + #[prost(uint64, tag="2")] + pub next_seq_recv: u64, +} +impl ::prost::Name for NextSequenceRecvData { +const NAME: &'static str = "NextSequenceRecvData"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v2"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v2.NextSequenceRecvData".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v2.NextSequenceRecvData".into() }} +/// DataType defines the type of solo machine proof being created. This is done +/// to preserve uniqueness of different data sign byte encodings. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum DataType { + /// Default State + UninitializedUnspecified = 0, + /// Data type for client state verification + ClientState = 1, + /// Data type for consensus state verification + ConsensusState = 2, + /// Data type for connection state verification + ConnectionState = 3, + /// Data type for channel state verification + ChannelState = 4, + /// Data type for packet commitment verification + PacketCommitment = 5, + /// Data type for packet acknowledgement verification + PacketAcknowledgement = 6, + /// Data type for packet receipt absence verification + PacketReceiptAbsence = 7, + /// Data type for next sequence recv verification + NextSequenceRecv = 8, + /// Data type for header verification + Header = 9, +} +impl DataType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + DataType::UninitializedUnspecified => "DATA_TYPE_UNINITIALIZED_UNSPECIFIED", + DataType::ClientState => "DATA_TYPE_CLIENT_STATE", + DataType::ConsensusState => "DATA_TYPE_CONSENSUS_STATE", + DataType::ConnectionState => "DATA_TYPE_CONNECTION_STATE", + DataType::ChannelState => "DATA_TYPE_CHANNEL_STATE", + DataType::PacketCommitment => "DATA_TYPE_PACKET_COMMITMENT", + DataType::PacketAcknowledgement => "DATA_TYPE_PACKET_ACKNOWLEDGEMENT", + DataType::PacketReceiptAbsence => "DATA_TYPE_PACKET_RECEIPT_ABSENCE", + DataType::NextSequenceRecv => "DATA_TYPE_NEXT_SEQUENCE_RECV", + DataType::Header => "DATA_TYPE_HEADER", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "DATA_TYPE_UNINITIALIZED_UNSPECIFIED" => Some(Self::UninitializedUnspecified), + "DATA_TYPE_CLIENT_STATE" => Some(Self::ClientState), + "DATA_TYPE_CONSENSUS_STATE" => Some(Self::ConsensusState), + "DATA_TYPE_CONNECTION_STATE" => Some(Self::ConnectionState), + "DATA_TYPE_CHANNEL_STATE" => Some(Self::ChannelState), + "DATA_TYPE_PACKET_COMMITMENT" => Some(Self::PacketCommitment), + "DATA_TYPE_PACKET_ACKNOWLEDGEMENT" => Some(Self::PacketAcknowledgement), + "DATA_TYPE_PACKET_RECEIPT_ABSENCE" => Some(Self::PacketReceiptAbsence), + "DATA_TYPE_NEXT_SEQUENCE_RECV" => Some(Self::NextSequenceRecv), + "DATA_TYPE_HEADER" => Some(Self::Header), + _ => None, + } + } +} +// @@protoc_insertion_point(module) diff --git a/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.lightclients.solomachine.v3.rs b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.lightclients.solomachine.v3.rs new file mode 100644 index 00000000000..02df9673b4a --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.lightclients.solomachine.v3.rs @@ -0,0 +1,146 @@ +// @generated +// This file is @generated by prost-build. +/// ClientState defines a solo machine client that tracks the current consensus +/// state and if the client is frozen. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ClientState { + /// latest sequence of the client state + #[prost(uint64, tag="1")] + pub sequence: u64, + /// frozen sequence of the solo machine + #[prost(bool, tag="2")] + pub is_frozen: bool, + #[prost(message, optional, tag="3")] + pub consensus_state: ::core::option::Option, +} +impl ::prost::Name for ClientState { +const NAME: &'static str = "ClientState"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v3"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v3.ClientState".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v3.ClientState".into() }} +/// ConsensusState defines a solo machine consensus state. The sequence of a +/// consensus state is contained in the "height" key used in storing the +/// consensus state. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ConsensusState { + /// public key of the solo machine + #[prost(message, optional, tag="1")] + pub public_key: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, + /// diversifier allows the same public key to be re-used across different solo + /// machine clients (potentially on different chains) without being considered + /// misbehaviour. + #[prost(string, tag="2")] + pub diversifier: ::prost::alloc::string::String, + #[prost(uint64, tag="3")] + pub timestamp: u64, +} +impl ::prost::Name for ConsensusState { +const NAME: &'static str = "ConsensusState"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v3"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v3.ConsensusState".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v3.ConsensusState".into() }} +/// Header defines a solo machine consensus header +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Header { + #[prost(uint64, tag="1")] + pub timestamp: u64, + #[prost(bytes="vec", tag="2")] + pub signature: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="3")] + pub new_public_key: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, + #[prost(string, tag="4")] + pub new_diversifier: ::prost::alloc::string::String, +} +impl ::prost::Name for Header { +const NAME: &'static str = "Header"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v3"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v3.Header".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v3.Header".into() }} +/// Misbehaviour defines misbehaviour for a solo machine which consists +/// of a sequence and two signatures over different messages at that sequence. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Misbehaviour { + #[prost(uint64, tag="1")] + pub sequence: u64, + #[prost(message, optional, tag="2")] + pub signature_one: ::core::option::Option, + #[prost(message, optional, tag="3")] + pub signature_two: ::core::option::Option, +} +impl ::prost::Name for Misbehaviour { +const NAME: &'static str = "Misbehaviour"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v3"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v3.Misbehaviour".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v3.Misbehaviour".into() }} +/// SignatureAndData contains a signature and the data signed over to create that +/// signature. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SignatureAndData { + #[prost(bytes="vec", tag="1")] + pub signature: ::prost::alloc::vec::Vec, + #[prost(bytes="vec", tag="2")] + pub path: ::prost::alloc::vec::Vec, + #[prost(bytes="vec", tag="3")] + pub data: ::prost::alloc::vec::Vec, + #[prost(uint64, tag="4")] + pub timestamp: u64, +} +impl ::prost::Name for SignatureAndData { +const NAME: &'static str = "SignatureAndData"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v3"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v3.SignatureAndData".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v3.SignatureAndData".into() }} +/// TimestampedSignatureData contains the signature data and the timestamp of the +/// signature. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TimestampedSignatureData { + #[prost(bytes="vec", tag="1")] + pub signature_data: ::prost::alloc::vec::Vec, + #[prost(uint64, tag="2")] + pub timestamp: u64, +} +impl ::prost::Name for TimestampedSignatureData { +const NAME: &'static str = "TimestampedSignatureData"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v3"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v3.TimestampedSignatureData".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v3.TimestampedSignatureData".into() }} +/// SignBytes defines the signed bytes used for signature verification. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SignBytes { + /// the sequence number + #[prost(uint64, tag="1")] + pub sequence: u64, + /// the proof timestamp + #[prost(uint64, tag="2")] + pub timestamp: u64, + /// the public key diversifier + #[prost(string, tag="3")] + pub diversifier: ::prost::alloc::string::String, + /// the standardised path bytes + #[prost(bytes="vec", tag="4")] + pub path: ::prost::alloc::vec::Vec, + /// the marshaled data bytes + #[prost(bytes="vec", tag="5")] + pub data: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for SignBytes { +const NAME: &'static str = "SignBytes"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v3"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v3.SignBytes".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v3.SignBytes".into() }} +/// HeaderData returns the SignBytes data for update verification. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct HeaderData { + /// header public key + #[prost(message, optional, tag="1")] + pub new_pub_key: ::core::option::Option<::tendermint_proto::google::protobuf::Any>, + /// header diversifier + #[prost(string, tag="2")] + pub new_diversifier: ::prost::alloc::string::String, +} +impl ::prost::Name for HeaderData { +const NAME: &'static str = "HeaderData"; +const PACKAGE: &'static str = "ibc.lightclients.solomachine.v3"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.solomachine.v3.HeaderData".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.solomachine.v3.HeaderData".into() }} +// @@protoc_insertion_point(module) diff --git a/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.lightclients.tendermint.v1.rs b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.lightclients.tendermint.v1.rs new file mode 100644 index 00000000000..9600baf7ce4 --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.lightclients.tendermint.v1.rs @@ -0,0 +1,131 @@ +// @generated +// This file is @generated by prost-build. +/// ClientState from Tendermint tracks the current validator set, latest height, +/// and a possible frozen height. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ClientState { + #[prost(string, tag="1")] + pub chain_id: ::prost::alloc::string::String, + #[prost(message, optional, tag="2")] + pub trust_level: ::core::option::Option, + /// duration of the period since the LatestTimestamp during which the + /// submitted headers are valid for upgrade + #[prost(message, optional, tag="3")] + pub trusting_period: ::core::option::Option<::tendermint_proto::google::protobuf::Duration>, + /// duration of the staking unbonding period + #[prost(message, optional, tag="4")] + pub unbonding_period: ::core::option::Option<::tendermint_proto::google::protobuf::Duration>, + /// defines how much new (untrusted) header's Time can drift into the future. + #[prost(message, optional, tag="5")] + pub max_clock_drift: ::core::option::Option<::tendermint_proto::google::protobuf::Duration>, + /// Block height when the client was frozen due to a misbehaviour + #[prost(message, optional, tag="6")] + pub frozen_height: ::core::option::Option, + /// Latest height the client was updated to + #[prost(message, optional, tag="7")] + pub latest_height: ::core::option::Option, + /// Proof specifications used in verifying counterparty state + #[prost(message, repeated, tag="8")] + pub proof_specs: ::prost::alloc::vec::Vec<::ics23::ProofSpec>, + /// Path at which next upgraded client will be committed. + /// Each element corresponds to the key for a single CommitmentProof in the + /// chained proof. NOTE: ClientState must stored under + /// `{upgradePath}/{upgradeHeight}/clientState` ConsensusState must be stored + /// under `{upgradepath}/{upgradeHeight}/consensusState` For SDK chains using + /// the default upgrade module, upgrade_path should be \[\]string{"upgrade", + /// "upgradedIBCState"}` + #[prost(string, repeated, tag="9")] + pub upgrade_path: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// allow_update_after_expiry is deprecated + #[deprecated] + #[prost(bool, tag="10")] + pub allow_update_after_expiry: bool, + /// allow_update_after_misbehaviour is deprecated + #[deprecated] + #[prost(bool, tag="11")] + pub allow_update_after_misbehaviour: bool, +} +impl ::prost::Name for ClientState { +const NAME: &'static str = "ClientState"; +const PACKAGE: &'static str = "ibc.lightclients.tendermint.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.tendermint.v1.ClientState".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.tendermint.v1.ClientState".into() }} +/// ConsensusState defines the consensus state from Tendermint. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ConsensusState { + /// timestamp that corresponds to the block height in which the ConsensusState + /// was stored. + #[prost(message, optional, tag="1")] + pub timestamp: ::core::option::Option<::tendermint_proto::google::protobuf::Timestamp>, + /// commitment root (i.e app hash) + #[prost(message, optional, tag="2")] + pub root: ::core::option::Option, + #[prost(bytes="vec", tag="3")] + pub next_validators_hash: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for ConsensusState { +const NAME: &'static str = "ConsensusState"; +const PACKAGE: &'static str = "ibc.lightclients.tendermint.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.tendermint.v1.ConsensusState".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.tendermint.v1.ConsensusState".into() }} +/// Misbehaviour is a wrapper over two conflicting Headers +/// that implements Misbehaviour interface expected by ICS-02 +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Misbehaviour { + /// ClientID is deprecated + #[deprecated] + #[prost(string, tag="1")] + pub client_id: ::prost::alloc::string::String, + #[prost(message, optional, tag="2")] + pub header_1: ::core::option::Option
, + #[prost(message, optional, tag="3")] + pub header_2: ::core::option::Option
, +} +impl ::prost::Name for Misbehaviour { +const NAME: &'static str = "Misbehaviour"; +const PACKAGE: &'static str = "ibc.lightclients.tendermint.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.tendermint.v1.Misbehaviour".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.tendermint.v1.Misbehaviour".into() }} +/// Header defines the Tendermint client consensus Header. +/// It encapsulates all the information necessary to update from a trusted +/// Tendermint ConsensusState. The inclusion of TrustedHeight and +/// TrustedValidators allows this update to process correctly, so long as the +/// ConsensusState for the TrustedHeight exists, this removes race conditions +/// among relayers The SignedHeader and ValidatorSet are the new untrusted update +/// fields for the client. The TrustedHeight is the height of a stored +/// ConsensusState on the client that will be used to verify the new untrusted +/// header. The Trusted ConsensusState must be within the unbonding period of +/// current time in order to correctly verify, and the TrustedValidators must +/// hash to TrustedConsensusState.NextValidatorsHash since that is the last +/// trusted validator set at the TrustedHeight. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Header { + #[prost(message, optional, tag="1")] + pub signed_header: ::core::option::Option<::tendermint_proto::types::SignedHeader>, + #[prost(message, optional, tag="2")] + pub validator_set: ::core::option::Option<::tendermint_proto::types::ValidatorSet>, + #[prost(message, optional, tag="3")] + pub trusted_height: ::core::option::Option, + #[prost(message, optional, tag="4")] + pub trusted_validators: ::core::option::Option<::tendermint_proto::types::ValidatorSet>, +} +impl ::prost::Name for Header { +const NAME: &'static str = "Header"; +const PACKAGE: &'static str = "ibc.lightclients.tendermint.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.tendermint.v1.Header".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.tendermint.v1.Header".into() }} +/// Fraction defines the protobuf message type for tmmath.Fraction that only +/// supports positive values. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct Fraction { + #[prost(uint64, tag="1")] + pub numerator: u64, + #[prost(uint64, tag="2")] + pub denominator: u64, +} +impl ::prost::Name for Fraction { +const NAME: &'static str = "Fraction"; +const PACKAGE: &'static str = "ibc.lightclients.tendermint.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.tendermint.v1.Fraction".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.tendermint.v1.Fraction".into() }} +// @@protoc_insertion_point(module) diff --git a/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.lightclients.wasm.v1.rs b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.lightclients.wasm.v1.rs new file mode 100644 index 00000000000..34caaf35885 --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ibc.lightclients.wasm.v1.rs @@ -0,0 +1,213 @@ +// @generated +// This file is @generated by prost-build. +/// GenesisState defines 08-wasm's keeper genesis state +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct GenesisState { + /// uploaded light client wasm contracts + #[prost(message, repeated, tag="1")] + pub contracts: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for GenesisState { +const NAME: &'static str = "GenesisState"; +const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.wasm.v1.GenesisState".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.wasm.v1.GenesisState".into() }} +/// Contract stores contract code +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Contract { + /// contract byte code + #[prost(bytes="vec", tag="1")] + pub code_bytes: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for Contract { +const NAME: &'static str = "Contract"; +const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.wasm.v1.Contract".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.wasm.v1.Contract".into() }} +/// QueryChecksumsRequest is the request type for the Query/Checksums RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryChecksumsRequest { + /// pagination defines an optional pagination for the request. + #[prost(message, optional, tag="1")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageRequest>, +} +impl ::prost::Name for QueryChecksumsRequest { +const NAME: &'static str = "QueryChecksumsRequest"; +const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.wasm.v1.QueryChecksumsRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.wasm.v1.QueryChecksumsRequest".into() }} +/// QueryChecksumsResponse is the response type for the Query/Checksums RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryChecksumsResponse { + /// checksums is a list of the hex encoded checksums of all wasm codes stored. + #[prost(string, repeated, tag="1")] + pub checksums: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// pagination defines the pagination in the response. + #[prost(message, optional, tag="2")] + pub pagination: ::core::option::Option<::cosmos_sdk_proto::cosmos::base::query::v1beta1::PageResponse>, +} +impl ::prost::Name for QueryChecksumsResponse { +const NAME: &'static str = "QueryChecksumsResponse"; +const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.wasm.v1.QueryChecksumsResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.wasm.v1.QueryChecksumsResponse".into() }} +/// QueryCodeRequest is the request type for the Query/Code RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryCodeRequest { + /// checksum is a hex encoded string of the code stored. + #[prost(string, tag="1")] + pub checksum: ::prost::alloc::string::String, +} +impl ::prost::Name for QueryCodeRequest { +const NAME: &'static str = "QueryCodeRequest"; +const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.wasm.v1.QueryCodeRequest".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.wasm.v1.QueryCodeRequest".into() }} +/// QueryCodeResponse is the response type for the Query/Code RPC method. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryCodeResponse { + #[prost(bytes="vec", tag="1")] + pub data: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for QueryCodeResponse { +const NAME: &'static str = "QueryCodeResponse"; +const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.wasm.v1.QueryCodeResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.wasm.v1.QueryCodeResponse".into() }} +/// MsgStoreCode defines the request type for the StoreCode rpc. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgStoreCode { + /// signer address + #[prost(string, tag="1")] + pub signer: ::prost::alloc::string::String, + /// wasm byte code of light client contract. It can be raw or gzip compressed + #[prost(bytes="vec", tag="2")] + pub wasm_byte_code: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for MsgStoreCode { +const NAME: &'static str = "MsgStoreCode"; +const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.wasm.v1.MsgStoreCode".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.wasm.v1.MsgStoreCode".into() }} +/// MsgStoreCodeResponse defines the response type for the StoreCode rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgStoreCodeResponse { + /// checksum is the sha256 hash of the stored code + #[prost(bytes="vec", tag="1")] + pub checksum: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for MsgStoreCodeResponse { +const NAME: &'static str = "MsgStoreCodeResponse"; +const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.wasm.v1.MsgStoreCodeResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.wasm.v1.MsgStoreCodeResponse".into() }} +/// MsgRemoveChecksum defines the request type for the MsgRemoveChecksum rpc. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgRemoveChecksum { + /// signer address + #[prost(string, tag="1")] + pub signer: ::prost::alloc::string::String, + /// checksum is the sha256 hash to be removed from the store + #[prost(bytes="vec", tag="2")] + pub checksum: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for MsgRemoveChecksum { +const NAME: &'static str = "MsgRemoveChecksum"; +const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.wasm.v1.MsgRemoveChecksum".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.wasm.v1.MsgRemoveChecksum".into() }} +/// MsgStoreChecksumResponse defines the response type for the StoreCode rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgRemoveChecksumResponse { +} +impl ::prost::Name for MsgRemoveChecksumResponse { +const NAME: &'static str = "MsgRemoveChecksumResponse"; +const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.wasm.v1.MsgRemoveChecksumResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.wasm.v1.MsgRemoveChecksumResponse".into() }} +/// MsgMigrateContract defines the request type for the MigrateContract rpc. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MsgMigrateContract { + /// signer address + #[prost(string, tag="1")] + pub signer: ::prost::alloc::string::String, + /// the client id of the contract + #[prost(string, tag="2")] + pub client_id: ::prost::alloc::string::String, + /// checksum is the sha256 hash of the new wasm byte code for the contract + #[prost(bytes="vec", tag="3")] + pub checksum: ::prost::alloc::vec::Vec, + /// the json encoded message to be passed to the contract on migration + #[prost(bytes="vec", tag="4")] + pub msg: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for MsgMigrateContract { +const NAME: &'static str = "MsgMigrateContract"; +const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.wasm.v1.MsgMigrateContract".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.wasm.v1.MsgMigrateContract".into() }} +/// MsgMigrateContractResponse defines the response type for the MigrateContract rpc +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct MsgMigrateContractResponse { +} +impl ::prost::Name for MsgMigrateContractResponse { +const NAME: &'static str = "MsgMigrateContractResponse"; +const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.wasm.v1.MsgMigrateContractResponse".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.wasm.v1.MsgMigrateContractResponse".into() }} +/// Wasm light client's Client state +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ClientState { + /// bytes encoding the client state of the underlying light client + /// implemented as a Wasm contract. + #[prost(bytes="vec", tag="1")] + pub data: ::prost::alloc::vec::Vec, + #[prost(bytes="vec", tag="2")] + pub checksum: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="3")] + pub latest_height: ::core::option::Option, +} +impl ::prost::Name for ClientState { +const NAME: &'static str = "ClientState"; +const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.wasm.v1.ClientState".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.wasm.v1.ClientState".into() }} +/// Wasm light client's ConsensusState +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ConsensusState { + /// bytes encoding the consensus state of the underlying light client + /// implemented as a Wasm contract. + #[prost(bytes="vec", tag="1")] + pub data: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for ConsensusState { +const NAME: &'static str = "ConsensusState"; +const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.wasm.v1.ConsensusState".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.wasm.v1.ConsensusState".into() }} +/// Wasm light client message (either header(s) or misbehaviour) +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ClientMessage { + #[prost(bytes="vec", tag="1")] + pub data: ::prost::alloc::vec::Vec, +} +impl ::prost::Name for ClientMessage { +const NAME: &'static str = "ClientMessage"; +const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.wasm.v1.ClientMessage".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.wasm.v1.ClientMessage".into() }} +/// Checksums defines a list of all checksums that are stored +/// +/// Deprecated: This message is deprecated in favor of storing the checksums +/// using a Collections.KeySet. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Checksums { + #[prost(bytes="vec", repeated, tag="1")] + pub checksums: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec>, +} +impl ::prost::Name for Checksums { +const NAME: &'static str = "Checksums"; +const PACKAGE: &'static str = "ibc.lightclients.wasm.v1"; +fn full_name() -> ::prost::alloc::string::String { "ibc.lightclients.wasm.v1.Checksums".into() }fn type_url() -> ::prost::alloc::string::String { "/ibc.lightclients.wasm.v1.Checksums".into() }} +// @@protoc_insertion_point(module) diff --git a/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/lib.rs b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/lib.rs new file mode 100644 index 00000000000..99fbe68545d --- /dev/null +++ b/modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/lib.rs @@ -0,0 +1,127 @@ +// @generated +pub mod ibc { + pub mod applications { + pub mod fee { + // @@protoc_insertion_point(attribute:ibc.applications.fee.v1) + pub mod v1 { + include!("ibc.applications.fee.v1.rs"); + // @@protoc_insertion_point(ibc.applications.fee.v1) + } + } + pub mod interchain_accounts { + pub mod controller { + // @@protoc_insertion_point(attribute:ibc.applications.interchain_accounts.controller.v1) + pub mod v1 { + include!("ibc.applications.interchain_accounts.controller.v1.rs"); + // @@protoc_insertion_point(ibc.applications.interchain_accounts.controller.v1) + } + } + pub mod genesis { + // @@protoc_insertion_point(attribute:ibc.applications.interchain_accounts.genesis.v1) + pub mod v1 { + include!("ibc.applications.interchain_accounts.genesis.v1.rs"); + // @@protoc_insertion_point(ibc.applications.interchain_accounts.genesis.v1) + } + } + pub mod host { + // @@protoc_insertion_point(attribute:ibc.applications.interchain_accounts.host.v1) + pub mod v1 { + include!("ibc.applications.interchain_accounts.host.v1.rs"); + // @@protoc_insertion_point(ibc.applications.interchain_accounts.host.v1) + } + } + // @@protoc_insertion_point(attribute:ibc.applications.interchain_accounts.v1) + pub mod v1 { + include!("ibc.applications.interchain_accounts.v1.rs"); + // @@protoc_insertion_point(ibc.applications.interchain_accounts.v1) + } + } + pub mod transfer { + // @@protoc_insertion_point(attribute:ibc.applications.transfer.v1) + pub mod v1 { + include!("ibc.applications.transfer.v1.rs"); + // @@protoc_insertion_point(ibc.applications.transfer.v1) + } + // @@protoc_insertion_point(attribute:ibc.applications.transfer.v2) + pub mod v2 { + include!("ibc.applications.transfer.v2.rs"); + // @@protoc_insertion_point(ibc.applications.transfer.v2) + } + } + } + pub mod core { + pub mod channel { + // @@protoc_insertion_point(attribute:ibc.core.channel.v1) + pub mod v1 { + include!("ibc.core.channel.v1.rs"); + // @@protoc_insertion_point(ibc.core.channel.v1) + } + // @@protoc_insertion_point(attribute:ibc.core.channel.v2) + pub mod v2 { + include!("ibc.core.channel.v2.rs"); + // @@protoc_insertion_point(ibc.core.channel.v2) + } + } + pub mod client { + // @@protoc_insertion_point(attribute:ibc.core.client.v1) + pub mod v1 { + include!("ibc.core.client.v1.rs"); + // @@protoc_insertion_point(ibc.core.client.v1) + } + } + pub mod commitment { + // @@protoc_insertion_point(attribute:ibc.core.commitment.v1) + pub mod v1 { + include!("ibc.core.commitment.v1.rs"); + // @@protoc_insertion_point(ibc.core.commitment.v1) + } + // @@protoc_insertion_point(attribute:ibc.core.commitment.v2) + pub mod v2 { + include!("ibc.core.commitment.v2.rs"); + // @@protoc_insertion_point(ibc.core.commitment.v2) + } + } + pub mod connection { + // @@protoc_insertion_point(attribute:ibc.core.connection.v1) + pub mod v1 { + include!("ibc.core.connection.v1.rs"); + // @@protoc_insertion_point(ibc.core.connection.v1) + } + } + pub mod types { + // @@protoc_insertion_point(attribute:ibc.core.types.v1) + pub mod v1 { + include!("ibc.core.types.v1.rs"); + // @@protoc_insertion_point(ibc.core.types.v1) + } + } + } + pub mod lightclients { + pub mod solomachine { + // @@protoc_insertion_point(attribute:ibc.lightclients.solomachine.v2) + pub mod v2 { + include!("ibc.lightclients.solomachine.v2.rs"); + // @@protoc_insertion_point(ibc.lightclients.solomachine.v2) + } + // @@protoc_insertion_point(attribute:ibc.lightclients.solomachine.v3) + pub mod v3 { + include!("ibc.lightclients.solomachine.v3.rs"); + // @@protoc_insertion_point(ibc.lightclients.solomachine.v3) + } + } + pub mod tendermint { + // @@protoc_insertion_point(attribute:ibc.lightclients.tendermint.v1) + pub mod v1 { + include!("ibc.lightclients.tendermint.v1.rs"); + // @@protoc_insertion_point(ibc.lightclients.tendermint.v1) + } + } + pub mod wasm { + // @@protoc_insertion_point(attribute:ibc.lightclients.wasm.v1) + pub mod v1 { + include!("ibc.lightclients.wasm.v1.rs"); + // @@protoc_insertion_point(ibc.lightclients.wasm.v1) + } + } + } +} diff --git a/proto/buf.gen.prost.yaml b/proto/buf.gen.prost.yaml new file mode 100644 index 00000000000..65805d072aa --- /dev/null +++ b/proto/buf.gen.prost.yaml @@ -0,0 +1,16 @@ +version: v1 +plugins: + - plugin: buf.build/community/neoeinstein-prost:v0.4.0 + out: ../prostgen + opt: + - compile_well_known_types + - enable_type_names + - extern_path=.google.protobuf=::tendermint_proto::google::protobuf + - extern_path=.cosmos.ics23.v1=::ics23 + - extern_path=.tendermint=::tendermint_proto + - extern_path=.cosmos=::cosmos_sdk_proto::cosmos + - extern_path=.cosmwasm.Binary=::cosmwasm::Binary + - plugin: buf.build/community/neoeinstein-prost-crate:v0.4.1 + out: ../prostgen + opt: + - no_features diff --git a/scripts/protocgen.sh b/scripts/protocgen.sh index e25c443039f..b9930bed310 100755 --- a/scripts/protocgen.sh +++ b/scripts/protocgen.sh @@ -18,3 +18,14 @@ rm -rf github.com mv modules/apps/transfer/types/denomtrace.pb.go modules/apps/transfer/internal/types/ go mod tidy + +echo "Generating prost proto code" +cd proto + +buf generate --template buf.gen.prost.yaml $file + +cd .. + +mv prostgen/mod.rs prostgen/lib.rs +cp prostgen/* modules/light-clients/08-wasm-light-clients/packages/ibc-go-proto/src/ +rm -rf prostgen From 637f15291ed6b6e714a30d760b172b77326c4d59 Mon Sep 17 00:00:00 2001 From: Gjermund Garaba Date: Tue, 26 Nov 2024 19:57:38 +0100 Subject: [PATCH 2/6] set target on correct job --- .github/workflows/wasm-light-clients.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/wasm-light-clients.yml b/.github/workflows/wasm-light-clients.yml index 2d2cdeaa740..6bf312ea395 100644 --- a/.github/workflows/wasm-light-clients.yml +++ b/.github/workflows/wasm-light-clients.yml @@ -23,7 +23,6 @@ jobs: profile: minimal toolchain: stable components: rustfmt, clippy - target: wasm32-unknown-unknown - name: Lint 08-wasm-light-clients workspace run: make lint-wasm-light-clients @@ -40,6 +39,7 @@ jobs: profile: minimal toolchain: stable components: rustfmt, clippy + target: wasm32-unknown-unknown - name: Cargo build 08-wasm-light-clients workspace run: make build-wasm-light-clients From 0786d8123e5259890cc52093f212b89cf4d2d40a Mon Sep 17 00:00:00 2001 From: Gjermund Garaba Date: Wed, 27 Nov 2024 09:28:12 +0100 Subject: [PATCH 3/6] Update modules/light-clients/08-wasm-light-clients/Cargo.toml Co-authored-by: srdtrk <59252793+srdtrk@users.noreply.github.com> --- modules/light-clients/08-wasm-light-clients/Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/light-clients/08-wasm-light-clients/Cargo.toml b/modules/light-clients/08-wasm-light-clients/Cargo.toml index 5328b8b4d96..802b31432e9 100644 --- a/modules/light-clients/08-wasm-light-clients/Cargo.toml +++ b/modules/light-clients/08-wasm-light-clients/Cargo.toml @@ -14,7 +14,7 @@ version = "0.1.0" optimize = """docker run --rm -v "$(pwd)":/code \ --mount type=volume,source="$(basename "$(pwd)")_cache",target=/target \ --mount type=volume,source=registry_cache,target=/usr/local/cargo/registry \ - cosmwasm/optimizer:0.16.0""" + cosmwasm/optimizer:0.16.1""" [workspace.dependencies] # Local packages From 38683968d10be8213c88aec95c7c9faa8fc1cc63 Mon Sep 17 00:00:00 2001 From: Gjermund Garaba Date: Wed, 27 Nov 2024 09:30:36 +0100 Subject: [PATCH 4/6] Update modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/error.rs Co-authored-by: srdtrk <59252793+srdtrk@users.noreply.github.com> --- .../contracts/ethereum-light-client/src/error.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/error.rs b/modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/error.rs index dc19f103399..840de74f3c4 100644 --- a/modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/error.rs +++ b/modules/light-clients/08-wasm-light-clients/contracts/ethereum-light-client/src/error.rs @@ -7,5 +7,5 @@ pub enum ContractError { Std(#[from] StdError), #[error("Unauthorized")] - Unauthorized {}, + Unauthorized, } From f8ad05327059aaa41098132687e79567cda27ba9 Mon Sep 17 00:00:00 2001 From: Gjermund Garaba Date: Wed, 27 Nov 2024 11:41:15 +0100 Subject: [PATCH 5/6] Update modules/light-clients/08-wasm-light-clients/Cargo.toml Co-authored-by: srdtrk <59252793+srdtrk@users.noreply.github.com> --- modules/light-clients/08-wasm-light-clients/Cargo.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/modules/light-clients/08-wasm-light-clients/Cargo.toml b/modules/light-clients/08-wasm-light-clients/Cargo.toml index 802b31432e9..ef8ce57b6db 100644 --- a/modules/light-clients/08-wasm-light-clients/Cargo.toml +++ b/modules/light-clients/08-wasm-light-clients/Cargo.toml @@ -22,10 +22,10 @@ ibc-go-proto = { path = "packages/ibc-go-proto" } # CosmWasm related dependencies cosmwasm-schema = "2.1.4" -cosmwasm-std = { version = "2.1.4" } +cosmwasm-std = "2.1.4" cw-storage-plus = "2.0.0" serde = { version = "1.0.215", default-features = false, features = ["derive"] } -thiserror = { version = "2.0.3" } +thiserror = "2.0.3" # Proto related dependencies ics23 = { version = "0.12.0", default-features = false } From 6696ceb780423a8470b1614a554c7808ac30a22f Mon Sep 17 00:00:00 2001 From: Gjermund Garaba Date: Wed, 27 Nov 2024 11:45:40 +0100 Subject: [PATCH 6/6] code review cleanups --- Makefile | 2 +- .../08-wasm-light-clients/.cargo/config.toml | 3 --- .../08-wasm-light-clients/Cargo.lock | 4 ++-- .../08-wasm-light-clients/Cargo.toml | 16 ++++++++-------- 4 files changed, 11 insertions(+), 14 deletions(-) delete mode 100644 modules/light-clients/08-wasm-light-clients/.cargo/config.toml diff --git a/Makefile b/Makefile index 179361264bc..ee46fa2b01d 100644 --- a/Makefile +++ b/Makefile @@ -142,7 +142,7 @@ build-docker-wasm: .PHONY: build-docker-wasm build-wasm-light-clients: - cd modules/light-clients/08-wasm-light-clients && cargo wasm + cd modules/light-clients/08-wasm-light-clients && cargo build --release --lib --target wasm32-unknown-unknown .PHONY: build-wasm-light-clients diff --git a/modules/light-clients/08-wasm-light-clients/.cargo/config.toml b/modules/light-clients/08-wasm-light-clients/.cargo/config.toml deleted file mode 100644 index 86f292b69cd..00000000000 --- a/modules/light-clients/08-wasm-light-clients/.cargo/config.toml +++ /dev/null @@ -1,3 +0,0 @@ -[alias] -wasm = "build --release --lib --target wasm32-unknown-unknown" - diff --git a/modules/light-clients/08-wasm-light-clients/Cargo.lock b/modules/light-clients/08-wasm-light-clients/Cargo.lock index 7cd6d2cb9c4..1fd4ee0121d 100644 --- a/modules/light-clients/08-wasm-light-clients/Cargo.lock +++ b/modules/light-clients/08-wasm-light-clients/Cargo.lock @@ -734,9 +734,9 @@ dependencies = [ [[package]] name = "libc" -version = "0.2.165" +version = "0.2.166" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fcb4d3d38eab6c5239a362fa8bae48c03baf980a6e7079f063942d563ef3533e" +checksum = "c2ccc108bbc0b1331bd061864e7cd823c0cab660bbe6970e66e2c0614decde36" [[package]] name = "memchr" diff --git a/modules/light-clients/08-wasm-light-clients/Cargo.toml b/modules/light-clients/08-wasm-light-clients/Cargo.toml index ef8ce57b6db..e7a84019874 100644 --- a/modules/light-clients/08-wasm-light-clients/Cargo.toml +++ b/modules/light-clients/08-wasm-light-clients/Cargo.toml @@ -21,17 +21,17 @@ optimize = """docker run --rm -v "$(pwd)":/code \ ibc-go-proto = { path = "packages/ibc-go-proto" } # CosmWasm related dependencies -cosmwasm-schema = "2.1.4" -cosmwasm-std = "2.1.4" -cw-storage-plus = "2.0.0" +cosmwasm-schema = "2.1" +cosmwasm-std = "2.1" +cw-storage-plus = "2.0" serde = { version = "1.0.215", default-features = false, features = ["derive"] } -thiserror = "2.0.3" +thiserror = "2.0" # Proto related dependencies -ics23 = { version = "0.12.0", default-features = false } -tendermint-proto = { version = "0.40.0", default-features = false } -cosmos-sdk-proto = { version = "0.26.1", default-features = false } -prost = { version = "0.13.3", default-features = false, features = ["prost-derive"] } +ics23 = { version = "0.12", default-features = false } +tendermint-proto = { version = "0.40", default-features = false } +cosmos-sdk-proto = { version = "0.26", default-features = false } +prost = { version = "0.13", default-features = false, features = ["prost-derive"] } # dev-dependencies cw-multi-test = "2.2.0"