From 27d723f6d99d313c5627ec227e2df18121e97dc3 Mon Sep 17 00:00:00 2001 From: willclarktech Date: Wed, 9 Dec 2020 12:37:27 +0000 Subject: [PATCH 01/33] scripts: Deploy hackatom contract in wasmd --- scripts/wasmd/deploy_hackatom.js | 76 ++++++++++++++++++++++++++++++++ scripts/wasmd/init.sh | 4 +- 2 files changed, 78 insertions(+), 2 deletions(-) create mode 100755 scripts/wasmd/deploy_hackatom.js diff --git a/scripts/wasmd/deploy_hackatom.js b/scripts/wasmd/deploy_hackatom.js new file mode 100755 index 00000000..b2efa8a1 --- /dev/null +++ b/scripts/wasmd/deploy_hackatom.js @@ -0,0 +1,76 @@ +#!/usr/bin/env node + +/* eslint-disable @typescript-eslint/naming-convention */ +const { DirectSecp256k1HdWallet } = require("@cosmjs/proto-signing"); +const { SigningCosmWasmClient } = require("@cosmjs/cosmwasm-stargate"); +const fs = require("fs"); + +const endpoint = "http://localhost:26659"; +const alice = { + mnemonic: "enlist hip relief stomach skate base shallow young switch frequent cry park", + address0: "wasm14qemq0vw6y3gc3u3e0aty2e764u4gs5lndxgyk", + address1: "wasm1hhg2rlu9jscacku2wwckws7932qqqu8xm5ca8y", + address2: "wasm1xv9tklw7d82sezh9haa573wufgy59vmwnxhnsl", + address3: "wasm17yg9mssjenmc3jkqth6ulcwj9cxujrxxg9nmzk", + address4: "wasm1f7j7ryulwjfe9ljplvhtcaxa6wqgula3nh873j", +}; + +const codeMeta = { + source: "https://crates.io/api/v1/crates/hackatom/not-yet-released/download", + builder: "cosmwasm/rust-optimizer:0.9.1", +}; + +const inits = [ + { + label: "From deploy_hackatom.js (0)", + msg: { + beneficiary: alice.address0, + verifier: alice.address0, + }, + admin: undefined, + }, + { + label: "From deploy_hackatom.js (1)", + msg: { + beneficiary: alice.address1, + verifier: alice.address1, + }, + admin: undefined, + }, + { + label: "From deploy_hackatom.js (2)", + msg: { + beneficiary: alice.address2, + verifier: alice.address2, + }, + admin: alice.address1, + }, +]; + +async function main() { + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, "wasm"); + const client = await SigningCosmWasmClient.connectWithWallet(endpoint, wallet); + + const wasm = fs.readFileSync(__dirname + "/contracts/hackatom.wasm"); + const uploadReceipt = await client.upload(alice.address0, wasm, codeMeta, "Upload hackatom contract"); + console.info(`Upload succeeded. Receipt: ${JSON.stringify(uploadReceipt)}`); + + for (const { label, msg, admin } of inits) { + const { contractAddress } = await client.instantiate(alice.address0, uploadReceipt.codeId, msg, label, { + memo: `Create a hackatom instance in deploy_hackatom.js`, + admin: admin, + }); + console.info(`Contract instantiated at ${contractAddress}`); + } +} + +main().then( + () => { + console.info("All done, let the coins flow."); + process.exit(0); + }, + (error) => { + console.error(error); + process.exit(1); + }, +); diff --git a/scripts/wasmd/init.sh b/scripts/wasmd/init.sh index c091d790..9620403e 100755 --- a/scripts/wasmd/init.sh +++ b/scripts/wasmd/init.sh @@ -5,7 +5,7 @@ command -v shellcheck >/dev/null && shellcheck "$0" echo "Waiting for blockchain and REST server to be available ..." timeout 60 bash -c "until curl -s http://localhost:1319/node_info > /dev/null; do sleep 0.5; done" # The chain is unreliable in the first second of its existence (https://gist.github.com/webmaster128/8175692d4af5e6c572fddda7a9ef437c) -sleep 1 +sleep 2 echo "Waiting for height to be >= 1 ..." timeout 20 bash -c "until [ \"\$( curl -s http://localhost:1319/blocks/latest | jq -r '.block.header.height // 0' )\" -ge 1 ]; do sleep 0.5; done" echo "Okay, thank you for your patience." @@ -25,7 +25,7 @@ SCRIPT_DIR="$(realpath "$(dirname "$0")")" cd "$SCRIPT_DIR/contracts" sha256sum --check checksums.sha256 ) -# "$SCRIPT_DIR/deploy_hackatom.js" +"$SCRIPT_DIR/deploy_hackatom.js" # "$SCRIPT_DIR/deploy_erc20.js" # "$SCRIPT_DIR/deploy_cw3.js" # "$SCRIPT_DIR/deploy_cw1.js" From 32bff353e5478cbf2f7f3cce914d686528ea4e9c Mon Sep 17 00:00:00 2001 From: willclarktech Date: Wed, 2 Dec 2020 15:07:22 +0000 Subject: [PATCH 02/33] cosmwasm-stargate: Add package.json --- packages/cosmwasm-stargate/package.json | 45 +++++++++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 packages/cosmwasm-stargate/package.json diff --git a/packages/cosmwasm-stargate/package.json b/packages/cosmwasm-stargate/package.json new file mode 100644 index 00000000..439068f5 --- /dev/null +++ b/packages/cosmwasm-stargate/package.json @@ -0,0 +1,45 @@ +{ + "name": "@cosmjs/cosmwasm-stargate", + "version": "0.24.0-alpha.10", + "description": "CosmWasm SDK", + "contributors": [ + "Will Clark " + ], + "license": "Apache-2.0", + "main": "build/index.js", + "types": "types/index.d.ts", + "files": [ + "build/", + "types/", + "*.md", + "!*.spec.*", + "!**/testdata/" + ], + "repository": { + "type": "git", + "url": "https://github.com/CosmWasm/cosmjs/tree/master/packages/cosmwasm-stargate" + }, + "publishConfig": { + "access": "public" + }, + "private": true, + "scripts": { + "docs": "typedoc --options typedoc.js", + "format": "prettier --write --loglevel warn \"./src/**/*.ts\"", + "format-text": "prettier --write --prose-wrap always --print-width 80 \"./*.md\"", + "lint": "eslint --max-warnings 0 \"**/*.{js,ts}\"", + "lint-fix": "eslint --max-warnings 0 \"**/*.{js,ts}\" --fix", + "move-types": "shx rm -rf ./types/* && shx mv build/types/* ./types && rm -rf ./types/testdata && shx rm -f ./types/*.spec.d.ts && shx rm ./types/**/*.spec.d.ts", + "format-types": "prettier --write --loglevel warn \"./types/**/*.d.ts\"", + "prebuild": "shx rm -rf ./build", + "build": "tsc", + "postbuild": "yarn move-types && yarn format-types", + "build-or-skip": "[ -n \"$SKIP_BUILD\" ] || yarn build", + "test-node": "node jasmine-testrunner.js", + "test-firefox": "yarn pack-web && karma start --single-run --browsers Firefox", + "test-chrome": "yarn pack-web && karma start --single-run --browsers ChromeHeadless", + "test": "yarn build-or-skip && yarn test-node", + "coverage": "nyc --reporter=text --reporter=lcov yarn test --quiet", + "pack-web": "yarn build-or-skip && webpack --mode development --config webpack.web.config.js" + } +} From 77225217c2ccbf4a6cf96c2c388c24edbfe7eae1 Mon Sep 17 00:00:00 2001 From: willclarktech Date: Wed, 2 Dec 2020 15:04:53 +0000 Subject: [PATCH 03/33] cosmwasm-stargate: Add README --- packages/cosmwasm-stargate/README.md | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 packages/cosmwasm-stargate/README.md diff --git a/packages/cosmwasm-stargate/README.md b/packages/cosmwasm-stargate/README.md new file mode 100644 index 00000000..de15c931 --- /dev/null +++ b/packages/cosmwasm-stargate/README.md @@ -0,0 +1,27 @@ +# @cosmjs/cosmwasm-stargate + +[![npm version](https://img.shields.io/npm/v/@cosmjs/cosmwasm-stargate.svg)](https://www.npmjs.com/package/@cosmjs/cosmwasm-stargate) + +An SDK to build CosmWasm clients. + +## Compatibility + +| CosmWasm | x/wasm | @cosmjs/cosmwasm-stargate | +| -------- | ------ | ------------------------- | +| 0.12 | 0.12 | `^0.24.0` | + +## Development + +Updating Hackatom development contract in `src/testdata/contract.json`: + +```sh +cd packages/cosmwasm-stargate +export HACKATOM_URL=https://github.com/CosmWasm/cosmwasm/releases/download/v0.12.0/hackatom.wasm +echo "{\"// source\": \"$HACKATOM_URL\", \"data\": \"$(curl -sS --location $HACKATOM_URL | base64)\" }" | jq > src/testdata/contract.json +``` + +## License + +This package is part of the cosmjs repository, licensed under the Apache License +2.0 (see [NOTICE](https://github.com/CosmWasm/cosmjs/blob/master/NOTICE) and +[LICENSE](https://github.com/CosmWasm/cosmjs/blob/master/LICENSE)). From 80cf70ef04185b8e02da077e6a7ef0cce405c7e0 Mon Sep 17 00:00:00 2001 From: willclarktech Date: Wed, 2 Dec 2020 15:03:13 +0000 Subject: [PATCH 04/33] cosmwasm-stargate: Add auxiliary files --- packages/cosmwasm-stargate/.eslintignore | 1 + packages/cosmwasm-stargate/.gitignore | 3 ++ packages/cosmwasm-stargate/.nycrc.yml | 1 + .../cosmwasm-stargate/jasmine-testrunner.js | 33 +++++++++++++ packages/cosmwasm-stargate/karma.conf.js | 47 +++++++++++++++++++ packages/cosmwasm-stargate/tsconfig.json | 12 +++++ packages/cosmwasm-stargate/typedoc.js | 13 +++++ .../cosmwasm-stargate/webpack.web.config.js | 19 ++++++++ 8 files changed, 129 insertions(+) create mode 120000 packages/cosmwasm-stargate/.eslintignore create mode 100644 packages/cosmwasm-stargate/.gitignore create mode 120000 packages/cosmwasm-stargate/.nycrc.yml create mode 100755 packages/cosmwasm-stargate/jasmine-testrunner.js create mode 100644 packages/cosmwasm-stargate/karma.conf.js create mode 100644 packages/cosmwasm-stargate/tsconfig.json create mode 100644 packages/cosmwasm-stargate/typedoc.js create mode 100644 packages/cosmwasm-stargate/webpack.web.config.js diff --git a/packages/cosmwasm-stargate/.eslintignore b/packages/cosmwasm-stargate/.eslintignore new file mode 120000 index 00000000..86039baf --- /dev/null +++ b/packages/cosmwasm-stargate/.eslintignore @@ -0,0 +1 @@ +../../.eslintignore \ No newline at end of file diff --git a/packages/cosmwasm-stargate/.gitignore b/packages/cosmwasm-stargate/.gitignore new file mode 100644 index 00000000..68bf3735 --- /dev/null +++ b/packages/cosmwasm-stargate/.gitignore @@ -0,0 +1,3 @@ +build/ +dist/ +docs/ diff --git a/packages/cosmwasm-stargate/.nycrc.yml b/packages/cosmwasm-stargate/.nycrc.yml new file mode 120000 index 00000000..1f95ac55 --- /dev/null +++ b/packages/cosmwasm-stargate/.nycrc.yml @@ -0,0 +1 @@ +../../.nycrc.yml \ No newline at end of file diff --git a/packages/cosmwasm-stargate/jasmine-testrunner.js b/packages/cosmwasm-stargate/jasmine-testrunner.js new file mode 100755 index 00000000..7a17962e --- /dev/null +++ b/packages/cosmwasm-stargate/jasmine-testrunner.js @@ -0,0 +1,33 @@ +#!/usr/bin/env node + +/* eslint-disable @typescript-eslint/naming-convention */ +require("source-map-support").install(); +const defaultSpecReporterConfig = require("../../jasmine-spec-reporter.config.json"); + +// setup Jasmine +const Jasmine = require("jasmine"); +const jasmine = new Jasmine(); +jasmine.loadConfig({ + spec_dir: "build", + spec_files: ["**/*.spec.js"], + helpers: [], + random: false, + seed: null, + stopSpecOnExpectationFailure: false, +}); +jasmine.jasmine.DEFAULT_TIMEOUT_INTERVAL = 15 * 1000; + +// setup reporter +const { SpecReporter } = require("jasmine-spec-reporter"); +const reporter = new SpecReporter({ + ...defaultSpecReporterConfig, + spec: { + ...defaultSpecReporterConfig.spec, + displaySuccessful: !process.argv.includes("--quiet"), + }, +}); + +// initialize and execute +jasmine.env.clearReporters(); +jasmine.addReporter(reporter); +jasmine.execute(); diff --git a/packages/cosmwasm-stargate/karma.conf.js b/packages/cosmwasm-stargate/karma.conf.js new file mode 100644 index 00000000..006da5fe --- /dev/null +++ b/packages/cosmwasm-stargate/karma.conf.js @@ -0,0 +1,47 @@ +module.exports = function (config) { + config.set({ + // base path that will be used to resolve all patterns (eg. files, exclude) + basePath: ".", + + // frameworks to use + // available frameworks: https://npmjs.org/browse/keyword/karma-adapter + frameworks: ["jasmine"], + + // list of files / patterns to load in the browser + files: ["dist/web/tests.js"], + + client: { + jasmine: { + random: false, + timeoutInterval: 15000, + }, + }, + + // test results reporter to use + // possible values: 'dots', 'progress' + // available reporters: https://npmjs.org/browse/keyword/karma-reporter + reporters: ["progress", "kjhtml"], + + // web server port + port: 9876, + + // enable / disable colors in the output (reporters and logs) + colors: true, + + // level of logging + // possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG + logLevel: config.LOG_INFO, + + // enable / disable watching file and executing tests whenever any file changes + autoWatch: false, + + // start these browsers + // available browser launchers: https://npmjs.org/browse/keyword/karma-launcher + browsers: ["Firefox"], + + browserNoActivityTimeout: 90000, + + // Keep brower open for debugging. This is overridden by yarn scripts + singleRun: false, + }); +}; diff --git a/packages/cosmwasm-stargate/tsconfig.json b/packages/cosmwasm-stargate/tsconfig.json new file mode 100644 index 00000000..167e8c02 --- /dev/null +++ b/packages/cosmwasm-stargate/tsconfig.json @@ -0,0 +1,12 @@ +{ + "extends": "../../tsconfig.json", + "compilerOptions": { + "baseUrl": ".", + "outDir": "build", + "declarationDir": "build/types", + "rootDir": "src" + }, + "include": [ + "src/**/*" + ] +} diff --git a/packages/cosmwasm-stargate/typedoc.js b/packages/cosmwasm-stargate/typedoc.js new file mode 100644 index 00000000..4dfbe49d --- /dev/null +++ b/packages/cosmwasm-stargate/typedoc.js @@ -0,0 +1,13 @@ +const packageJson = require("./package.json"); + +module.exports = { + inputFiles: ["./src"], + out: "docs", + exclude: "**/*.spec.ts", + name: `${packageJson.name} Documentation`, + readme: "README.md", + mode: "file", + excludeExternals: true, + excludeNotExported: true, + excludePrivate: true, +}; diff --git a/packages/cosmwasm-stargate/webpack.web.config.js b/packages/cosmwasm-stargate/webpack.web.config.js new file mode 100644 index 00000000..15fc60f0 --- /dev/null +++ b/packages/cosmwasm-stargate/webpack.web.config.js @@ -0,0 +1,19 @@ +const glob = require("glob"); +const path = require("path"); +// const webpack = require("webpack"); + +const target = "web"; +const distdir = path.join(__dirname, "dist", "web"); + +module.exports = [ + { + // bundle used for Karma tests + target: target, + entry: glob.sync("./build/**/*.spec.js"), + output: { + path: distdir, + filename: "tests.js", + }, + // plugins: [new webpack.EnvironmentPlugin(["LAUNCHPAD_ENABLED", "ERC20_ENABLED"])], + }, +]; From 5972832598991ca13a3a8371d373ac2ca6667f1d Mon Sep 17 00:00:00 2001 From: willclarktech Date: Thu, 3 Dec 2020 12:23:16 +0000 Subject: [PATCH 05/33] cosmwasm-stargate: Update .gitignore for proto files --- packages/cosmwasm-stargate/.gitignore | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/packages/cosmwasm-stargate/.gitignore b/packages/cosmwasm-stargate/.gitignore index 68bf3735..5d19789f 100644 --- a/packages/cosmwasm-stargate/.gitignore +++ b/packages/cosmwasm-stargate/.gitignore @@ -1,3 +1,7 @@ build/ dist/ docs/ + +# protobuf code generation +proto/ +tmp/ From 1f3c77c6852f494474b5b9b00794cb6b33c364e9 Mon Sep 17 00:00:00 2001 From: willclarktech Date: Thu, 3 Dec 2020 12:25:26 +0000 Subject: [PATCH 06/33] cosmwasm-stargate: Add proto scripts to package.json --- packages/cosmwasm-stargate/package.json | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/packages/cosmwasm-stargate/package.json b/packages/cosmwasm-stargate/package.json index 439068f5..20695812 100644 --- a/packages/cosmwasm-stargate/package.json +++ b/packages/cosmwasm-stargate/package.json @@ -40,6 +40,11 @@ "test-chrome": "yarn pack-web && karma start --single-run --browsers ChromeHeadless", "test": "yarn build-or-skip && yarn test-node", "coverage": "nyc --reporter=text --reporter=lcov yarn test --quiet", - "pack-web": "yarn build-or-skip && webpack --mode development --config webpack.web.config.js" + "pack-web": "yarn build-or-skip && webpack --mode development --config webpack.web.config.js", + "preget-proto": "rm -rf proto", + "get-proto": "WASM_REF=v0.12.1 COSMOS_REF=v0.40.0-rc3 ./scripts/get-proto.sh", + "predefine-proto": "./scripts/predefine-proto.sh", + "define-proto": "./scripts/define-proto.sh", + "postdefine-proto": "prettier --write \"src/codec/generated/codecimpl.*\"" } } From 85279b72712d9d9fbca9d9ca531379ad20093ee4 Mon Sep 17 00:00:00 2001 From: willclarktech Date: Tue, 8 Dec 2020 11:31:58 +0000 Subject: [PATCH 07/33] cosmwasm-stargate: Add decorators to tsconfig --- packages/cosmwasm-stargate/tsconfig.json | 1 + 1 file changed, 1 insertion(+) diff --git a/packages/cosmwasm-stargate/tsconfig.json b/packages/cosmwasm-stargate/tsconfig.json index 167e8c02..c605e918 100644 --- a/packages/cosmwasm-stargate/tsconfig.json +++ b/packages/cosmwasm-stargate/tsconfig.json @@ -4,6 +4,7 @@ "baseUrl": ".", "outDir": "build", "declarationDir": "build/types", + "experimentalDecorators": true, "rootDir": "src" }, "include": [ From 55396df47b903fe2189c4fb8eb72cd8963edee84 Mon Sep 17 00:00:00 2001 From: willclarktech Date: Tue, 8 Dec 2020 11:50:27 +0000 Subject: [PATCH 08/33] cosmwasm-stargate: Update package.json proto/build scripts --- packages/cosmwasm-stargate/package.json | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/packages/cosmwasm-stargate/package.json b/packages/cosmwasm-stargate/package.json index 20695812..bf13a859 100644 --- a/packages/cosmwasm-stargate/package.json +++ b/packages/cosmwasm-stargate/package.json @@ -29,11 +29,11 @@ "format-text": "prettier --write --prose-wrap always --print-width 80 \"./*.md\"", "lint": "eslint --max-warnings 0 \"**/*.{js,ts}\"", "lint-fix": "eslint --max-warnings 0 \"**/*.{js,ts}\" --fix", - "move-types": "shx rm -rf ./types/* && shx mv build/types/* ./types && rm -rf ./types/testdata && shx rm -f ./types/*.spec.d.ts && shx rm ./types/**/*.spec.d.ts", + "move-types": "shx rm -rf ./types/* && shx mv build/types/* ./types && rm -rf ./types/testdata && shx rm -f ./types/*.spec.d.ts && shx rm -f ./types/**/*.spec.d.ts", "format-types": "prettier --write --loglevel warn \"./types/**/*.d.ts\"", "prebuild": "shx rm -rf ./build", - "build": "tsc", - "postbuild": "yarn move-types && yarn format-types", + "build": "tsc && shx mkdir -p build/codec/generated && shx cp ./src/codec/generated/*.js ./build/codec/generated", + "postbuild": "shx mkdir -p ./build/types/codec/generated && shx cp ./src/codec/generated/*.d.ts ./build/types/codec/generated && yarn move-types && yarn format-types", "build-or-skip": "[ -n \"$SKIP_BUILD\" ] || yarn build", "test-node": "node jasmine-testrunner.js", "test-firefox": "yarn pack-web && karma start --single-run --browsers Firefox", @@ -42,7 +42,7 @@ "coverage": "nyc --reporter=text --reporter=lcov yarn test --quiet", "pack-web": "yarn build-or-skip && webpack --mode development --config webpack.web.config.js", "preget-proto": "rm -rf proto", - "get-proto": "WASM_REF=v0.12.1 COSMOS_REF=v0.40.0-rc3 ./scripts/get-proto.sh", + "get-proto": "WASM_REF=v0.13.0 COSMOS_REF=v0.40.0-rc3 ./scripts/get-proto.sh", "predefine-proto": "./scripts/predefine-proto.sh", "define-proto": "./scripts/define-proto.sh", "postdefine-proto": "prettier --write \"src/codec/generated/codecimpl.*\"" From 97fe2d1e2d1d5fa3268a0f92aa4b99ae681e1a3a Mon Sep 17 00:00:00 2001 From: willclarktech Date: Wed, 9 Dec 2020 12:34:47 +0000 Subject: [PATCH 09/33] cosmwasm-stargate: Add dependencies to package.json --- packages/cosmwasm-stargate/package.json | 18 ++++++++++++++++++ yarn.lock | 5 +++++ 2 files changed, 23 insertions(+) diff --git a/packages/cosmwasm-stargate/package.json b/packages/cosmwasm-stargate/package.json index bf13a859..616fd3f1 100644 --- a/packages/cosmwasm-stargate/package.json +++ b/packages/cosmwasm-stargate/package.json @@ -46,5 +46,23 @@ "predefine-proto": "./scripts/predefine-proto.sh", "define-proto": "./scripts/define-proto.sh", "postdefine-proto": "prettier --write \"src/codec/generated/codecimpl.*\"" + }, + "dependencies": { + "@cosmjs/cosmwasm": "^0.24.0-alpha.10", + "@cosmjs/crypto": "^0.24.0-alpha.10", + "@cosmjs/encoding": "^0.24.0-alpha.10", + "@cosmjs/launchpad": "^0.24.0-alpha.10", + "@cosmjs/math": "^0.24.0-alpha.10", + "@cosmjs/proto-signing": "^0.24.0-alpha.10", + "@cosmjs/stargate": "^0.24.0-alpha.10", + "@cosmjs/tendermint-rpc": "^0.24.0-alpha.10", + "@cosmjs/utils": "^0.24.0-alpha.10", + "long": "^4.0.0", + "pako": "^2.0.2", + "protobufjs": "~6.10.2" + }, + "devDependencies": { + "@types/pako": "^1.0.1", + "readonly-date": "^1.0.0" } } diff --git a/yarn.lock b/yarn.lock index 159bee1b..125a1b79 100644 --- a/yarn.lock +++ b/yarn.lock @@ -6807,6 +6807,11 @@ pako@^1.0.11, pako@~1.0.5: resolved "https://registry.yarnpkg.com/pako/-/pako-1.0.11.tgz#6c9599d340d54dfd3946380252a35705a6b992bf" integrity sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw== +pako@^2.0.2: + version "2.0.2" + resolved "https://registry.yarnpkg.com/pako/-/pako-2.0.2.tgz#8a72af7a93431ef22aa97e0d53b0acaa3c689220" + integrity sha512-9e8DRI3+dRLomCmMBAH30B2ejh+blwXr7VmMEx/pVFZlSDA7oyI8uKMhKXr8IrZpoxBF2YlxUvhqRXzTT1i0NA== + parallel-transform@^1.1.0: version "1.2.0" resolved "https://registry.yarnpkg.com/parallel-transform/-/parallel-transform-1.2.0.tgz#9049ca37d6cb2182c3b1d2c720be94d14a5814fc" From 4207e8e373661e3d2d9ee9a58b2fb4788645068b Mon Sep 17 00:00:00 2001 From: willclarktech Date: Thu, 3 Dec 2020 12:25:47 +0000 Subject: [PATCH 10/33] cosmwasm-stargate: Add proto scripts --- .../cosmwasm-stargate/scripts/define-proto.sh | 16 ++++++++++ .../cosmwasm-stargate/scripts/get-proto.sh | 31 +++++++++++++++++++ .../scripts/predefine-proto.sh | 29 +++++++++++++++++ 3 files changed, 76 insertions(+) create mode 100755 packages/cosmwasm-stargate/scripts/define-proto.sh create mode 100755 packages/cosmwasm-stargate/scripts/get-proto.sh create mode 100755 packages/cosmwasm-stargate/scripts/predefine-proto.sh diff --git a/packages/cosmwasm-stargate/scripts/define-proto.sh b/packages/cosmwasm-stargate/scripts/define-proto.sh new file mode 100755 index 00000000..ac077ff0 --- /dev/null +++ b/packages/cosmwasm-stargate/scripts/define-proto.sh @@ -0,0 +1,16 @@ +#!/bin/bash +set -o errexit -o nounset -o pipefail +command -v shellcheck >/dev/null && shellcheck "$0" + +TMP_DIR="./tmp" +JS_SOURCE_FILE="$TMP_DIR/codecimpl.js" +DEFINITIONS_FILE="$TMP_DIR/codecimpl.d.ts" +OUTPUT_DIR="./src/codec/generated/" + +yarn pbts "$JS_SOURCE_FILE" -o "$DEFINITIONS_FILE" +# Remove comments after using them for the .d.ts +# Note "When input files are specified on the command line, tsconfig.json files are ignored." (https://www.typescriptlang.org/docs/handbook/tsconfig-json.html) +yarn tsc --removeComments --target es2017 --module commonjs --outDir "$OUTPUT_DIR" --allowJs "$JS_SOURCE_FILE" + +cp "$DEFINITIONS_FILE" "$OUTPUT_DIR" +rm "$DEFINITIONS_FILE" "$JS_SOURCE_FILE" diff --git a/packages/cosmwasm-stargate/scripts/get-proto.sh b/packages/cosmwasm-stargate/scripts/get-proto.sh new file mode 100755 index 00000000..c12a45c6 --- /dev/null +++ b/packages/cosmwasm-stargate/scripts/get-proto.sh @@ -0,0 +1,31 @@ +#!/bin/bash +set -o errexit -o nounset -o pipefail +command -v shellcheck >/dev/null && shellcheck "$0" + +PROTO_DIR="./proto" + +COSMOS_DIR="$PROTO_DIR/cosmos" +COSMOS_SDK_DIR="$COSMOS_DIR/cosmos-sdk" +COSMOS_SDK_ZIP_FILE="$COSMOS_DIR/tmp.zip" +COSMOS_REF=${COSMOS_REF:-"master"} +COSMOS_SUFFIX=${COSMOS_REF} +[[ $COSMOS_SUFFIX =~ ^v[0-9]+\.[0-9]+\.[0-9]+(-.+)?$ ]] && COSMOS_SUFFIX=${COSMOS_SUFFIX#v} + +COSMWASM_DIR="$PROTO_DIR/cosmwasm" +WASMD_DIR="$COSMWASM_DIR/wasmd" +WASMD_ZIP_FILE="$COSMWASM_DIR/tmp.zip" +WASM_REF=${WASM_REF:-"master"} +WASM_SUFFIX=${WASM_REF} +[[ $WASM_SUFFIX =~ ^v[0-9]+\.[0-9]+\.[0-9]+(-.+)?$ ]] && WASM_SUFFIX=${WASM_SUFFIX#v} + +mkdir -p "$COSMOS_DIR" +wget -qO "$COSMOS_SDK_ZIP_FILE" "https://github.com/cosmos/cosmos-sdk/archive/$COSMOS_REF.zip" +unzip "$COSMOS_SDK_ZIP_FILE" "*.proto" -d "$COSMOS_DIR" +mv "$COSMOS_SDK_DIR-$COSMOS_SUFFIX" "$COSMOS_SDK_DIR" +rm "$COSMOS_SDK_ZIP_FILE" + +mkdir -p "$COSMWASM_DIR" +wget -qO "$WASMD_ZIP_FILE" "https://github.com/cosmwasm/wasmd/archive/$WASM_REF.zip" +unzip "$WASMD_ZIP_FILE" "*.proto" -d "$COSMWASM_DIR" +mv "$WASMD_DIR-$WASM_SUFFIX" "$WASMD_DIR" +rm "$WASMD_ZIP_FILE" diff --git a/packages/cosmwasm-stargate/scripts/predefine-proto.sh b/packages/cosmwasm-stargate/scripts/predefine-proto.sh new file mode 100755 index 00000000..35547ca0 --- /dev/null +++ b/packages/cosmwasm-stargate/scripts/predefine-proto.sh @@ -0,0 +1,29 @@ +#!/bin/bash +set -o errexit -o nounset -o pipefail +command -v shellcheck >/dev/null && shellcheck "$0" + +GENERATED_DIR="./tmp" +ROOT_PROTO_DIR="./proto/cosmwasm/wasmd" +WASM_PROTO_DIR="$ROOT_PROTO_DIR/x/wasm" + +mkdir -p "$GENERATED_DIR" +# Can't use --sparse for some reason. Seems related to https://github.com/protobufjs/protobuf.js/issues/1165 +yarn pbjs \ + -t static-module \ + --es6 \ + -w commonjs \ + -o "$GENERATED_DIR/codecimpl.js" \ + --no-beautify \ + --no-delimited \ + --no-verify \ + --no-convert \ + --force-long \ + "$WASM_PROTO_DIR/internal/types/msg.proto" \ + "$WASM_PROTO_DIR/internal/types/query.proto" \ + "$WASM_PROTO_DIR/internal/types/types.proto" \ + "./proto/cosmos/cosmos-sdk/proto/cosmos/base/v1beta1/coin.proto" \ + "./proto/cosmos/cosmos-sdk/proto/cosmos/base/query/v1beta1/pagination.proto" + +# Work around https://github.com/protobufjs/protobuf.js/issues/1477 +# shellcheck disable=SC2016 +sed -i "" -e 's/^const \$root =.*$/const \$root = {};/' "$GENERATED_DIR/codecimpl.js" From 91405d2834b02a473c483088062bb8857d832862 Mon Sep 17 00:00:00 2001 From: willclarktech Date: Thu, 3 Dec 2020 12:30:56 +0000 Subject: [PATCH 11/33] cosmwasm-stargate: Add codec --- .../src/codec/generated/codecimpl.d.ts | 4435 +++++++++++++++++ .../src/codec/generated/codecimpl.js | 3615 ++++++++++++++ packages/cosmwasm-stargate/src/codec/index.ts | 9 + .../types/codec/generated/codecimpl.d.ts | 4435 +++++++++++++++++ .../cosmwasm-stargate/types/codec/index.d.ts | 1 + 5 files changed, 12495 insertions(+) create mode 100644 packages/cosmwasm-stargate/src/codec/generated/codecimpl.d.ts create mode 100644 packages/cosmwasm-stargate/src/codec/generated/codecimpl.js create mode 100644 packages/cosmwasm-stargate/src/codec/index.ts create mode 100644 packages/cosmwasm-stargate/types/codec/generated/codecimpl.d.ts create mode 100644 packages/cosmwasm-stargate/types/codec/index.d.ts diff --git a/packages/cosmwasm-stargate/src/codec/generated/codecimpl.d.ts b/packages/cosmwasm-stargate/src/codec/generated/codecimpl.d.ts new file mode 100644 index 00000000..22d9bf39 --- /dev/null +++ b/packages/cosmwasm-stargate/src/codec/generated/codecimpl.d.ts @@ -0,0 +1,4435 @@ +import * as $protobuf from "protobufjs"; +/** Namespace cosmwasm. */ +export namespace cosmwasm { + /** Namespace wasm. */ + namespace wasm { + /** Namespace v1beta1. */ + namespace v1beta1 { + /** Properties of a MsgStoreCode. */ + interface IMsgStoreCode { + /** MsgStoreCode sender */ + sender?: string | null; + + /** MsgStoreCode wasmByteCode */ + wasmByteCode?: Uint8Array | null; + + /** MsgStoreCode source */ + source?: string | null; + + /** MsgStoreCode builder */ + builder?: string | null; + + /** MsgStoreCode instantiatePermission */ + instantiatePermission?: cosmwasm.wasm.v1beta1.IAccessConfig | null; + } + + /** Represents a MsgStoreCode. */ + class MsgStoreCode implements IMsgStoreCode { + /** + * Constructs a new MsgStoreCode. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IMsgStoreCode); + + /** MsgStoreCode sender. */ + public sender: string; + + /** MsgStoreCode wasmByteCode. */ + public wasmByteCode: Uint8Array; + + /** MsgStoreCode source. */ + public source: string; + + /** MsgStoreCode builder. */ + public builder: string; + + /** MsgStoreCode instantiatePermission. */ + public instantiatePermission?: cosmwasm.wasm.v1beta1.IAccessConfig | null; + + /** + * Creates a new MsgStoreCode instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgStoreCode instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IMsgStoreCode, + ): cosmwasm.wasm.v1beta1.MsgStoreCode; + + /** + * Encodes the specified MsgStoreCode message. Does not implicitly {@link cosmwasm.wasm.v1beta1.MsgStoreCode.verify|verify} messages. + * @param m MsgStoreCode message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmwasm.wasm.v1beta1.IMsgStoreCode, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgStoreCode message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgStoreCode + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.MsgStoreCode; + } + + /** Properties of a MsgInstantiateContract. */ + interface IMsgInstantiateContract { + /** MsgInstantiateContract sender */ + sender?: string | null; + + /** MsgInstantiateContract admin */ + admin?: string | null; + + /** MsgInstantiateContract codeId */ + codeId?: Long | null; + + /** MsgInstantiateContract label */ + label?: string | null; + + /** MsgInstantiateContract initMsg */ + initMsg?: Uint8Array | null; + + /** MsgInstantiateContract initFunds */ + initFunds?: cosmos.base.v1beta1.ICoin[] | null; + } + + /** Represents a MsgInstantiateContract. */ + class MsgInstantiateContract implements IMsgInstantiateContract { + /** + * Constructs a new MsgInstantiateContract. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IMsgInstantiateContract); + + /** MsgInstantiateContract sender. */ + public sender: string; + + /** MsgInstantiateContract admin. */ + public admin: string; + + /** MsgInstantiateContract codeId. */ + public codeId: Long; + + /** MsgInstantiateContract label. */ + public label: string; + + /** MsgInstantiateContract initMsg. */ + public initMsg: Uint8Array; + + /** MsgInstantiateContract initFunds. */ + public initFunds: cosmos.base.v1beta1.ICoin[]; + + /** + * Creates a new MsgInstantiateContract instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgInstantiateContract instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IMsgInstantiateContract, + ): cosmwasm.wasm.v1beta1.MsgInstantiateContract; + + /** + * Encodes the specified MsgInstantiateContract message. Does not implicitly {@link cosmwasm.wasm.v1beta1.MsgInstantiateContract.verify|verify} messages. + * @param m MsgInstantiateContract message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IMsgInstantiateContract, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a MsgInstantiateContract message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgInstantiateContract + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.MsgInstantiateContract; + } + + /** Properties of a MsgExecuteContract. */ + interface IMsgExecuteContract { + /** MsgExecuteContract sender */ + sender?: string | null; + + /** MsgExecuteContract contract */ + contract?: string | null; + + /** MsgExecuteContract msg */ + msg?: Uint8Array | null; + + /** MsgExecuteContract sentFunds */ + sentFunds?: cosmos.base.v1beta1.ICoin[] | null; + } + + /** Represents a MsgExecuteContract. */ + class MsgExecuteContract implements IMsgExecuteContract { + /** + * Constructs a new MsgExecuteContract. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IMsgExecuteContract); + + /** MsgExecuteContract sender. */ + public sender: string; + + /** MsgExecuteContract contract. */ + public contract: string; + + /** MsgExecuteContract msg. */ + public msg: Uint8Array; + + /** MsgExecuteContract sentFunds. */ + public sentFunds: cosmos.base.v1beta1.ICoin[]; + + /** + * Creates a new MsgExecuteContract instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgExecuteContract instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IMsgExecuteContract, + ): cosmwasm.wasm.v1beta1.MsgExecuteContract; + + /** + * Encodes the specified MsgExecuteContract message. Does not implicitly {@link cosmwasm.wasm.v1beta1.MsgExecuteContract.verify|verify} messages. + * @param m MsgExecuteContract message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IMsgExecuteContract, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a MsgExecuteContract message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgExecuteContract + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.MsgExecuteContract; + } + + /** Properties of a MsgMigrateContract. */ + interface IMsgMigrateContract { + /** MsgMigrateContract sender */ + sender?: string | null; + + /** MsgMigrateContract contract */ + contract?: string | null; + + /** MsgMigrateContract codeId */ + codeId?: Long | null; + + /** MsgMigrateContract migrateMsg */ + migrateMsg?: Uint8Array | null; + } + + /** Represents a MsgMigrateContract. */ + class MsgMigrateContract implements IMsgMigrateContract { + /** + * Constructs a new MsgMigrateContract. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IMsgMigrateContract); + + /** MsgMigrateContract sender. */ + public sender: string; + + /** MsgMigrateContract contract. */ + public contract: string; + + /** MsgMigrateContract codeId. */ + public codeId: Long; + + /** MsgMigrateContract migrateMsg. */ + public migrateMsg: Uint8Array; + + /** + * Creates a new MsgMigrateContract instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgMigrateContract instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IMsgMigrateContract, + ): cosmwasm.wasm.v1beta1.MsgMigrateContract; + + /** + * Encodes the specified MsgMigrateContract message. Does not implicitly {@link cosmwasm.wasm.v1beta1.MsgMigrateContract.verify|verify} messages. + * @param m MsgMigrateContract message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IMsgMigrateContract, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a MsgMigrateContract message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgMigrateContract + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.MsgMigrateContract; + } + + /** Properties of a MsgUpdateAdmin. */ + interface IMsgUpdateAdmin { + /** MsgUpdateAdmin sender */ + sender?: string | null; + + /** MsgUpdateAdmin newAdmin */ + newAdmin?: string | null; + + /** MsgUpdateAdmin contract */ + contract?: string | null; + } + + /** Represents a MsgUpdateAdmin. */ + class MsgUpdateAdmin implements IMsgUpdateAdmin { + /** + * Constructs a new MsgUpdateAdmin. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IMsgUpdateAdmin); + + /** MsgUpdateAdmin sender. */ + public sender: string; + + /** MsgUpdateAdmin newAdmin. */ + public newAdmin: string; + + /** MsgUpdateAdmin contract. */ + public contract: string; + + /** + * Creates a new MsgUpdateAdmin instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgUpdateAdmin instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IMsgUpdateAdmin, + ): cosmwasm.wasm.v1beta1.MsgUpdateAdmin; + + /** + * Encodes the specified MsgUpdateAdmin message. Does not implicitly {@link cosmwasm.wasm.v1beta1.MsgUpdateAdmin.verify|verify} messages. + * @param m MsgUpdateAdmin message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IMsgUpdateAdmin, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a MsgUpdateAdmin message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgUpdateAdmin + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.MsgUpdateAdmin; + } + + /** Properties of a MsgClearAdmin. */ + interface IMsgClearAdmin { + /** MsgClearAdmin sender */ + sender?: string | null; + + /** MsgClearAdmin contract */ + contract?: string | null; + } + + /** Represents a MsgClearAdmin. */ + class MsgClearAdmin implements IMsgClearAdmin { + /** + * Constructs a new MsgClearAdmin. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IMsgClearAdmin); + + /** MsgClearAdmin sender. */ + public sender: string; + + /** MsgClearAdmin contract. */ + public contract: string; + + /** + * Creates a new MsgClearAdmin instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgClearAdmin instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IMsgClearAdmin, + ): cosmwasm.wasm.v1beta1.MsgClearAdmin; + + /** + * Encodes the specified MsgClearAdmin message. Does not implicitly {@link cosmwasm.wasm.v1beta1.MsgClearAdmin.verify|verify} messages. + * @param m MsgClearAdmin message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmwasm.wasm.v1beta1.IMsgClearAdmin, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgClearAdmin message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgClearAdmin + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.MsgClearAdmin; + } + + /** Represents a Query */ + class Query extends $protobuf.rpc.Service { + /** + * Constructs a new Query service. + * @param rpcImpl RPC implementation + * @param [requestDelimited=false] Whether requests are length-delimited + * @param [responseDelimited=false] Whether responses are length-delimited + */ + constructor(rpcImpl: $protobuf.RPCImpl, requestDelimited?: boolean, responseDelimited?: boolean); + + /** + * Creates new Query service using the specified rpc implementation. + * @param rpcImpl RPC implementation + * @param [requestDelimited=false] Whether requests are length-delimited + * @param [responseDelimited=false] Whether responses are length-delimited + * @returns RPC service. Useful where requests and/or responses are streamed. + */ + public static create( + rpcImpl: $protobuf.RPCImpl, + requestDelimited?: boolean, + responseDelimited?: boolean, + ): Query; + + /** + * Calls ContractInfo. + * @param request QueryContractInfoRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryContractInfoResponse + */ + public contractInfo( + request: cosmwasm.wasm.v1beta1.IQueryContractInfoRequest, + callback: cosmwasm.wasm.v1beta1.Query.ContractInfoCallback, + ): void; + + /** + * Calls ContractInfo. + * @param request QueryContractInfoRequest message or plain object + * @returns Promise + */ + public contractInfo( + request: cosmwasm.wasm.v1beta1.IQueryContractInfoRequest, + ): Promise; + + /** + * Calls ContractHistory. + * @param request QueryContractHistoryRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryContractHistoryResponse + */ + public contractHistory( + request: cosmwasm.wasm.v1beta1.IQueryContractHistoryRequest, + callback: cosmwasm.wasm.v1beta1.Query.ContractHistoryCallback, + ): void; + + /** + * Calls ContractHistory. + * @param request QueryContractHistoryRequest message or plain object + * @returns Promise + */ + public contractHistory( + request: cosmwasm.wasm.v1beta1.IQueryContractHistoryRequest, + ): Promise; + + /** + * Calls ContractsByCode. + * @param request QueryContractsByCodeRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryContractsByCodeResponse + */ + public contractsByCode( + request: cosmwasm.wasm.v1beta1.IQueryContractsByCodeRequest, + callback: cosmwasm.wasm.v1beta1.Query.ContractsByCodeCallback, + ): void; + + /** + * Calls ContractsByCode. + * @param request QueryContractsByCodeRequest message or plain object + * @returns Promise + */ + public contractsByCode( + request: cosmwasm.wasm.v1beta1.IQueryContractsByCodeRequest, + ): Promise; + + /** + * Calls AllContractState. + * @param request QueryAllContractStateRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryAllContractStateResponse + */ + public allContractState( + request: cosmwasm.wasm.v1beta1.IQueryAllContractStateRequest, + callback: cosmwasm.wasm.v1beta1.Query.AllContractStateCallback, + ): void; + + /** + * Calls AllContractState. + * @param request QueryAllContractStateRequest message or plain object + * @returns Promise + */ + public allContractState( + request: cosmwasm.wasm.v1beta1.IQueryAllContractStateRequest, + ): Promise; + + /** + * Calls RawContractState. + * @param request QueryRawContractStateRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryRawContractStateResponse + */ + public rawContractState( + request: cosmwasm.wasm.v1beta1.IQueryRawContractStateRequest, + callback: cosmwasm.wasm.v1beta1.Query.RawContractStateCallback, + ): void; + + /** + * Calls RawContractState. + * @param request QueryRawContractStateRequest message or plain object + * @returns Promise + */ + public rawContractState( + request: cosmwasm.wasm.v1beta1.IQueryRawContractStateRequest, + ): Promise; + + /** + * Calls SmartContractState. + * @param request QuerySmartContractStateRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QuerySmartContractStateResponse + */ + public smartContractState( + request: cosmwasm.wasm.v1beta1.IQuerySmartContractStateRequest, + callback: cosmwasm.wasm.v1beta1.Query.SmartContractStateCallback, + ): void; + + /** + * Calls SmartContractState. + * @param request QuerySmartContractStateRequest message or plain object + * @returns Promise + */ + public smartContractState( + request: cosmwasm.wasm.v1beta1.IQuerySmartContractStateRequest, + ): Promise; + + /** + * Calls Code. + * @param request QueryCodeRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryCodeResponse + */ + public code( + request: cosmwasm.wasm.v1beta1.IQueryCodeRequest, + callback: cosmwasm.wasm.v1beta1.Query.CodeCallback, + ): void; + + /** + * Calls Code. + * @param request QueryCodeRequest message or plain object + * @returns Promise + */ + public code( + request: cosmwasm.wasm.v1beta1.IQueryCodeRequest, + ): Promise; + + /** + * Calls Codes. + * @param request QueryCodesRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryCodesResponse + */ + public codes( + request: cosmwasm.wasm.v1beta1.IQueryCodesRequest, + callback: cosmwasm.wasm.v1beta1.Query.CodesCallback, + ): void; + + /** + * Calls Codes. + * @param request QueryCodesRequest message or plain object + * @returns Promise + */ + public codes( + request: cosmwasm.wasm.v1beta1.IQueryCodesRequest, + ): Promise; + } + + namespace Query { + /** + * Callback as used by {@link cosmwasm.wasm.v1beta1.Query#contractInfo}. + * @param error Error, if any + * @param [response] QueryContractInfoResponse + */ + type ContractInfoCallback = ( + error: Error | null, + response?: cosmwasm.wasm.v1beta1.QueryContractInfoResponse, + ) => void; + + /** + * Callback as used by {@link cosmwasm.wasm.v1beta1.Query#contractHistory}. + * @param error Error, if any + * @param [response] QueryContractHistoryResponse + */ + type ContractHistoryCallback = ( + error: Error | null, + response?: cosmwasm.wasm.v1beta1.QueryContractHistoryResponse, + ) => void; + + /** + * Callback as used by {@link cosmwasm.wasm.v1beta1.Query#contractsByCode}. + * @param error Error, if any + * @param [response] QueryContractsByCodeResponse + */ + type ContractsByCodeCallback = ( + error: Error | null, + response?: cosmwasm.wasm.v1beta1.QueryContractsByCodeResponse, + ) => void; + + /** + * Callback as used by {@link cosmwasm.wasm.v1beta1.Query#allContractState}. + * @param error Error, if any + * @param [response] QueryAllContractStateResponse + */ + type AllContractStateCallback = ( + error: Error | null, + response?: cosmwasm.wasm.v1beta1.QueryAllContractStateResponse, + ) => void; + + /** + * Callback as used by {@link cosmwasm.wasm.v1beta1.Query#rawContractState}. + * @param error Error, if any + * @param [response] QueryRawContractStateResponse + */ + type RawContractStateCallback = ( + error: Error | null, + response?: cosmwasm.wasm.v1beta1.QueryRawContractStateResponse, + ) => void; + + /** + * Callback as used by {@link cosmwasm.wasm.v1beta1.Query#smartContractState}. + * @param error Error, if any + * @param [response] QuerySmartContractStateResponse + */ + type SmartContractStateCallback = ( + error: Error | null, + response?: cosmwasm.wasm.v1beta1.QuerySmartContractStateResponse, + ) => void; + + /** + * Callback as used by {@link cosmwasm.wasm.v1beta1.Query#code}. + * @param error Error, if any + * @param [response] QueryCodeResponse + */ + type CodeCallback = (error: Error | null, response?: cosmwasm.wasm.v1beta1.QueryCodeResponse) => void; + + /** + * Callback as used by {@link cosmwasm.wasm.v1beta1.Query#codes}. + * @param error Error, if any + * @param [response] QueryCodesResponse + */ + type CodesCallback = ( + error: Error | null, + response?: cosmwasm.wasm.v1beta1.QueryCodesResponse, + ) => void; + } + + /** Properties of a QueryContractInfoRequest. */ + interface IQueryContractInfoRequest { + /** QueryContractInfoRequest address */ + address?: string | null; + } + + /** Represents a QueryContractInfoRequest. */ + class QueryContractInfoRequest implements IQueryContractInfoRequest { + /** + * Constructs a new QueryContractInfoRequest. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryContractInfoRequest); + + /** QueryContractInfoRequest address. */ + public address: string; + + /** + * Creates a new QueryContractInfoRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryContractInfoRequest instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryContractInfoRequest, + ): cosmwasm.wasm.v1beta1.QueryContractInfoRequest; + + /** + * Encodes the specified QueryContractInfoRequest message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryContractInfoRequest.verify|verify} messages. + * @param m QueryContractInfoRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryContractInfoRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryContractInfoRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryContractInfoRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryContractInfoRequest; + } + + /** Properties of a QueryContractInfoResponse. */ + interface IQueryContractInfoResponse { + /** QueryContractInfoResponse address */ + address?: string | null; + + /** QueryContractInfoResponse contractInfo */ + contractInfo?: cosmwasm.wasm.v1beta1.IContractInfo | null; + } + + /** Represents a QueryContractInfoResponse. */ + class QueryContractInfoResponse implements IQueryContractInfoResponse { + /** + * Constructs a new QueryContractInfoResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryContractInfoResponse); + + /** QueryContractInfoResponse address. */ + public address: string; + + /** QueryContractInfoResponse contractInfo. */ + public contractInfo?: cosmwasm.wasm.v1beta1.IContractInfo | null; + + /** + * Creates a new QueryContractInfoResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryContractInfoResponse instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryContractInfoResponse, + ): cosmwasm.wasm.v1beta1.QueryContractInfoResponse; + + /** + * Encodes the specified QueryContractInfoResponse message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryContractInfoResponse.verify|verify} messages. + * @param m QueryContractInfoResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryContractInfoResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryContractInfoResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryContractInfoResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryContractInfoResponse; + } + + /** Properties of a QueryContractHistoryRequest. */ + interface IQueryContractHistoryRequest { + /** QueryContractHistoryRequest address */ + address?: string | null; + + /** QueryContractHistoryRequest pagination */ + pagination?: cosmos.base.query.v1beta1.IPageRequest | null; + } + + /** Represents a QueryContractHistoryRequest. */ + class QueryContractHistoryRequest implements IQueryContractHistoryRequest { + /** + * Constructs a new QueryContractHistoryRequest. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryContractHistoryRequest); + + /** QueryContractHistoryRequest address. */ + public address: string; + + /** QueryContractHistoryRequest pagination. */ + public pagination?: cosmos.base.query.v1beta1.IPageRequest | null; + + /** + * Creates a new QueryContractHistoryRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryContractHistoryRequest instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryContractHistoryRequest, + ): cosmwasm.wasm.v1beta1.QueryContractHistoryRequest; + + /** + * Encodes the specified QueryContractHistoryRequest message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryContractHistoryRequest.verify|verify} messages. + * @param m QueryContractHistoryRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryContractHistoryRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryContractHistoryRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryContractHistoryRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryContractHistoryRequest; + } + + /** Properties of a QueryContractHistoryResponse. */ + interface IQueryContractHistoryResponse { + /** QueryContractHistoryResponse entries */ + entries?: cosmwasm.wasm.v1beta1.IContractCodeHistoryEntry[] | null; + + /** QueryContractHistoryResponse pagination */ + pagination?: cosmos.base.query.v1beta1.IPageResponse | null; + } + + /** Represents a QueryContractHistoryResponse. */ + class QueryContractHistoryResponse implements IQueryContractHistoryResponse { + /** + * Constructs a new QueryContractHistoryResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryContractHistoryResponse); + + /** QueryContractHistoryResponse entries. */ + public entries: cosmwasm.wasm.v1beta1.IContractCodeHistoryEntry[]; + + /** QueryContractHistoryResponse pagination. */ + public pagination?: cosmos.base.query.v1beta1.IPageResponse | null; + + /** + * Creates a new QueryContractHistoryResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryContractHistoryResponse instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryContractHistoryResponse, + ): cosmwasm.wasm.v1beta1.QueryContractHistoryResponse; + + /** + * Encodes the specified QueryContractHistoryResponse message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryContractHistoryResponse.verify|verify} messages. + * @param m QueryContractHistoryResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryContractHistoryResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryContractHistoryResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryContractHistoryResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryContractHistoryResponse; + } + + /** Properties of a QueryContractsByCodeRequest. */ + interface IQueryContractsByCodeRequest { + /** QueryContractsByCodeRequest codeId */ + codeId?: Long | null; + + /** QueryContractsByCodeRequest pagination */ + pagination?: cosmos.base.query.v1beta1.IPageRequest | null; + } + + /** Represents a QueryContractsByCodeRequest. */ + class QueryContractsByCodeRequest implements IQueryContractsByCodeRequest { + /** + * Constructs a new QueryContractsByCodeRequest. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryContractsByCodeRequest); + + /** QueryContractsByCodeRequest codeId. */ + public codeId: Long; + + /** QueryContractsByCodeRequest pagination. */ + public pagination?: cosmos.base.query.v1beta1.IPageRequest | null; + + /** + * Creates a new QueryContractsByCodeRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryContractsByCodeRequest instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryContractsByCodeRequest, + ): cosmwasm.wasm.v1beta1.QueryContractsByCodeRequest; + + /** + * Encodes the specified QueryContractsByCodeRequest message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryContractsByCodeRequest.verify|verify} messages. + * @param m QueryContractsByCodeRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryContractsByCodeRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryContractsByCodeRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryContractsByCodeRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryContractsByCodeRequest; + } + + /** Properties of a ContractInfoWithAddress. */ + interface IContractInfoWithAddress { + /** ContractInfoWithAddress address */ + address?: string | null; + + /** ContractInfoWithAddress contractInfo */ + contractInfo?: cosmwasm.wasm.v1beta1.IContractInfo | null; + } + + /** Represents a ContractInfoWithAddress. */ + class ContractInfoWithAddress implements IContractInfoWithAddress { + /** + * Constructs a new ContractInfoWithAddress. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IContractInfoWithAddress); + + /** ContractInfoWithAddress address. */ + public address: string; + + /** ContractInfoWithAddress contractInfo. */ + public contractInfo?: cosmwasm.wasm.v1beta1.IContractInfo | null; + + /** + * Creates a new ContractInfoWithAddress instance using the specified properties. + * @param [properties] Properties to set + * @returns ContractInfoWithAddress instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IContractInfoWithAddress, + ): cosmwasm.wasm.v1beta1.ContractInfoWithAddress; + + /** + * Encodes the specified ContractInfoWithAddress message. Does not implicitly {@link cosmwasm.wasm.v1beta1.ContractInfoWithAddress.verify|verify} messages. + * @param m ContractInfoWithAddress message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IContractInfoWithAddress, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a ContractInfoWithAddress message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ContractInfoWithAddress + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.ContractInfoWithAddress; + } + + /** Properties of a QueryContractsByCodeResponse. */ + interface IQueryContractsByCodeResponse { + /** QueryContractsByCodeResponse contractInfos */ + contractInfos?: cosmwasm.wasm.v1beta1.IContractInfoWithAddress[] | null; + + /** QueryContractsByCodeResponse pagination */ + pagination?: cosmos.base.query.v1beta1.IPageResponse | null; + } + + /** Represents a QueryContractsByCodeResponse. */ + class QueryContractsByCodeResponse implements IQueryContractsByCodeResponse { + /** + * Constructs a new QueryContractsByCodeResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryContractsByCodeResponse); + + /** QueryContractsByCodeResponse contractInfos. */ + public contractInfos: cosmwasm.wasm.v1beta1.IContractInfoWithAddress[]; + + /** QueryContractsByCodeResponse pagination. */ + public pagination?: cosmos.base.query.v1beta1.IPageResponse | null; + + /** + * Creates a new QueryContractsByCodeResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryContractsByCodeResponse instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryContractsByCodeResponse, + ): cosmwasm.wasm.v1beta1.QueryContractsByCodeResponse; + + /** + * Encodes the specified QueryContractsByCodeResponse message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryContractsByCodeResponse.verify|verify} messages. + * @param m QueryContractsByCodeResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryContractsByCodeResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryContractsByCodeResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryContractsByCodeResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryContractsByCodeResponse; + } + + /** Properties of a QueryAllContractStateRequest. */ + interface IQueryAllContractStateRequest { + /** QueryAllContractStateRequest address */ + address?: string | null; + + /** QueryAllContractStateRequest pagination */ + pagination?: cosmos.base.query.v1beta1.IPageRequest | null; + } + + /** Represents a QueryAllContractStateRequest. */ + class QueryAllContractStateRequest implements IQueryAllContractStateRequest { + /** + * Constructs a new QueryAllContractStateRequest. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryAllContractStateRequest); + + /** QueryAllContractStateRequest address. */ + public address: string; + + /** QueryAllContractStateRequest pagination. */ + public pagination?: cosmos.base.query.v1beta1.IPageRequest | null; + + /** + * Creates a new QueryAllContractStateRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryAllContractStateRequest instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryAllContractStateRequest, + ): cosmwasm.wasm.v1beta1.QueryAllContractStateRequest; + + /** + * Encodes the specified QueryAllContractStateRequest message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryAllContractStateRequest.verify|verify} messages. + * @param m QueryAllContractStateRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryAllContractStateRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryAllContractStateRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryAllContractStateRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryAllContractStateRequest; + } + + /** Properties of a QueryAllContractStateResponse. */ + interface IQueryAllContractStateResponse { + /** QueryAllContractStateResponse models */ + models?: cosmwasm.wasm.v1beta1.IModel[] | null; + + /** QueryAllContractStateResponse pagination */ + pagination?: cosmos.base.query.v1beta1.IPageResponse | null; + } + + /** Represents a QueryAllContractStateResponse. */ + class QueryAllContractStateResponse implements IQueryAllContractStateResponse { + /** + * Constructs a new QueryAllContractStateResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryAllContractStateResponse); + + /** QueryAllContractStateResponse models. */ + public models: cosmwasm.wasm.v1beta1.IModel[]; + + /** QueryAllContractStateResponse pagination. */ + public pagination?: cosmos.base.query.v1beta1.IPageResponse | null; + + /** + * Creates a new QueryAllContractStateResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryAllContractStateResponse instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryAllContractStateResponse, + ): cosmwasm.wasm.v1beta1.QueryAllContractStateResponse; + + /** + * Encodes the specified QueryAllContractStateResponse message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryAllContractStateResponse.verify|verify} messages. + * @param m QueryAllContractStateResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryAllContractStateResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryAllContractStateResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryAllContractStateResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryAllContractStateResponse; + } + + /** Properties of a QueryRawContractStateRequest. */ + interface IQueryRawContractStateRequest { + /** QueryRawContractStateRequest address */ + address?: string | null; + + /** QueryRawContractStateRequest queryData */ + queryData?: Uint8Array | null; + } + + /** Represents a QueryRawContractStateRequest. */ + class QueryRawContractStateRequest implements IQueryRawContractStateRequest { + /** + * Constructs a new QueryRawContractStateRequest. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryRawContractStateRequest); + + /** QueryRawContractStateRequest address. */ + public address: string; + + /** QueryRawContractStateRequest queryData. */ + public queryData: Uint8Array; + + /** + * Creates a new QueryRawContractStateRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryRawContractStateRequest instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryRawContractStateRequest, + ): cosmwasm.wasm.v1beta1.QueryRawContractStateRequest; + + /** + * Encodes the specified QueryRawContractStateRequest message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryRawContractStateRequest.verify|verify} messages. + * @param m QueryRawContractStateRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryRawContractStateRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryRawContractStateRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryRawContractStateRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryRawContractStateRequest; + } + + /** Properties of a QueryRawContractStateResponse. */ + interface IQueryRawContractStateResponse { + /** QueryRawContractStateResponse data */ + data?: Uint8Array | null; + } + + /** Represents a QueryRawContractStateResponse. */ + class QueryRawContractStateResponse implements IQueryRawContractStateResponse { + /** + * Constructs a new QueryRawContractStateResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryRawContractStateResponse); + + /** QueryRawContractStateResponse data. */ + public data: Uint8Array; + + /** + * Creates a new QueryRawContractStateResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryRawContractStateResponse instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryRawContractStateResponse, + ): cosmwasm.wasm.v1beta1.QueryRawContractStateResponse; + + /** + * Encodes the specified QueryRawContractStateResponse message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryRawContractStateResponse.verify|verify} messages. + * @param m QueryRawContractStateResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryRawContractStateResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryRawContractStateResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryRawContractStateResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryRawContractStateResponse; + } + + /** Properties of a QuerySmartContractStateRequest. */ + interface IQuerySmartContractStateRequest { + /** QuerySmartContractStateRequest address */ + address?: string | null; + + /** QuerySmartContractStateRequest queryData */ + queryData?: Uint8Array | null; + } + + /** Represents a QuerySmartContractStateRequest. */ + class QuerySmartContractStateRequest implements IQuerySmartContractStateRequest { + /** + * Constructs a new QuerySmartContractStateRequest. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQuerySmartContractStateRequest); + + /** QuerySmartContractStateRequest address. */ + public address: string; + + /** QuerySmartContractStateRequest queryData. */ + public queryData: Uint8Array; + + /** + * Creates a new QuerySmartContractStateRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QuerySmartContractStateRequest instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQuerySmartContractStateRequest, + ): cosmwasm.wasm.v1beta1.QuerySmartContractStateRequest; + + /** + * Encodes the specified QuerySmartContractStateRequest message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QuerySmartContractStateRequest.verify|verify} messages. + * @param m QuerySmartContractStateRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQuerySmartContractStateRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QuerySmartContractStateRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QuerySmartContractStateRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QuerySmartContractStateRequest; + } + + /** Properties of a QuerySmartContractStateResponse. */ + interface IQuerySmartContractStateResponse { + /** QuerySmartContractStateResponse data */ + data?: Uint8Array | null; + } + + /** Represents a QuerySmartContractStateResponse. */ + class QuerySmartContractStateResponse implements IQuerySmartContractStateResponse { + /** + * Constructs a new QuerySmartContractStateResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQuerySmartContractStateResponse); + + /** QuerySmartContractStateResponse data. */ + public data: Uint8Array; + + /** + * Creates a new QuerySmartContractStateResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QuerySmartContractStateResponse instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQuerySmartContractStateResponse, + ): cosmwasm.wasm.v1beta1.QuerySmartContractStateResponse; + + /** + * Encodes the specified QuerySmartContractStateResponse message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QuerySmartContractStateResponse.verify|verify} messages. + * @param m QuerySmartContractStateResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQuerySmartContractStateResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QuerySmartContractStateResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QuerySmartContractStateResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QuerySmartContractStateResponse; + } + + /** Properties of a QueryCodeRequest. */ + interface IQueryCodeRequest { + /** QueryCodeRequest codeId */ + codeId?: Long | null; + } + + /** Represents a QueryCodeRequest. */ + class QueryCodeRequest implements IQueryCodeRequest { + /** + * Constructs a new QueryCodeRequest. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryCodeRequest); + + /** QueryCodeRequest codeId. */ + public codeId: Long; + + /** + * Creates a new QueryCodeRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryCodeRequest instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryCodeRequest, + ): cosmwasm.wasm.v1beta1.QueryCodeRequest; + + /** + * Encodes the specified QueryCodeRequest message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryCodeRequest.verify|verify} messages. + * @param m QueryCodeRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryCodeRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryCodeRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryCodeRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryCodeRequest; + } + + /** Properties of a CodeInfoResponse. */ + interface ICodeInfoResponse { + /** CodeInfoResponse codeId */ + codeId?: Long | null; + + /** CodeInfoResponse creator */ + creator?: string | null; + + /** CodeInfoResponse dataHash */ + dataHash?: Uint8Array | null; + + /** CodeInfoResponse source */ + source?: string | null; + + /** CodeInfoResponse builder */ + builder?: string | null; + } + + /** Represents a CodeInfoResponse. */ + class CodeInfoResponse implements ICodeInfoResponse { + /** + * Constructs a new CodeInfoResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.ICodeInfoResponse); + + /** CodeInfoResponse codeId. */ + public codeId: Long; + + /** CodeInfoResponse creator. */ + public creator: string; + + /** CodeInfoResponse dataHash. */ + public dataHash: Uint8Array; + + /** CodeInfoResponse source. */ + public source: string; + + /** CodeInfoResponse builder. */ + public builder: string; + + /** + * Creates a new CodeInfoResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns CodeInfoResponse instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.ICodeInfoResponse, + ): cosmwasm.wasm.v1beta1.CodeInfoResponse; + + /** + * Encodes the specified CodeInfoResponse message. Does not implicitly {@link cosmwasm.wasm.v1beta1.CodeInfoResponse.verify|verify} messages. + * @param m CodeInfoResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.ICodeInfoResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a CodeInfoResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns CodeInfoResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.CodeInfoResponse; + } + + /** Properties of a QueryCodeResponse. */ + interface IQueryCodeResponse { + /** QueryCodeResponse codeInfo */ + codeInfo?: cosmwasm.wasm.v1beta1.ICodeInfoResponse | null; + + /** QueryCodeResponse data */ + data?: Uint8Array | null; + } + + /** Represents a QueryCodeResponse. */ + class QueryCodeResponse implements IQueryCodeResponse { + /** + * Constructs a new QueryCodeResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryCodeResponse); + + /** QueryCodeResponse codeInfo. */ + public codeInfo?: cosmwasm.wasm.v1beta1.ICodeInfoResponse | null; + + /** QueryCodeResponse data. */ + public data: Uint8Array; + + /** + * Creates a new QueryCodeResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryCodeResponse instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryCodeResponse, + ): cosmwasm.wasm.v1beta1.QueryCodeResponse; + + /** + * Encodes the specified QueryCodeResponse message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryCodeResponse.verify|verify} messages. + * @param m QueryCodeResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryCodeResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryCodeResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryCodeResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryCodeResponse; + } + + /** Properties of a QueryCodesRequest. */ + interface IQueryCodesRequest { + /** QueryCodesRequest pagination */ + pagination?: cosmos.base.query.v1beta1.IPageRequest | null; + } + + /** Represents a QueryCodesRequest. */ + class QueryCodesRequest implements IQueryCodesRequest { + /** + * Constructs a new QueryCodesRequest. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryCodesRequest); + + /** QueryCodesRequest pagination. */ + public pagination?: cosmos.base.query.v1beta1.IPageRequest | null; + + /** + * Creates a new QueryCodesRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryCodesRequest instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryCodesRequest, + ): cosmwasm.wasm.v1beta1.QueryCodesRequest; + + /** + * Encodes the specified QueryCodesRequest message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryCodesRequest.verify|verify} messages. + * @param m QueryCodesRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryCodesRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryCodesRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryCodesRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryCodesRequest; + } + + /** Properties of a QueryCodesResponse. */ + interface IQueryCodesResponse { + /** QueryCodesResponse codeInfos */ + codeInfos?: cosmwasm.wasm.v1beta1.ICodeInfoResponse[] | null; + + /** QueryCodesResponse pagination */ + pagination?: cosmos.base.query.v1beta1.IPageResponse | null; + } + + /** Represents a QueryCodesResponse. */ + class QueryCodesResponse implements IQueryCodesResponse { + /** + * Constructs a new QueryCodesResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryCodesResponse); + + /** QueryCodesResponse codeInfos. */ + public codeInfos: cosmwasm.wasm.v1beta1.ICodeInfoResponse[]; + + /** QueryCodesResponse pagination. */ + public pagination?: cosmos.base.query.v1beta1.IPageResponse | null; + + /** + * Creates a new QueryCodesResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryCodesResponse instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryCodesResponse, + ): cosmwasm.wasm.v1beta1.QueryCodesResponse; + + /** + * Encodes the specified QueryCodesResponse message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryCodesResponse.verify|verify} messages. + * @param m QueryCodesResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryCodesResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryCodesResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryCodesResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryCodesResponse; + } + + /** AccessType enum. */ + enum AccessType { + ACCESS_TYPE_UNSPECIFIED = 0, + ACCESS_TYPE_NOBODY = 1, + ACCESS_TYPE_ONLY_ADDRESS = 2, + ACCESS_TYPE_EVERYBODY = 3, + } + + /** Properties of an AccessTypeParam. */ + interface IAccessTypeParam { + /** AccessTypeParam value */ + value?: cosmwasm.wasm.v1beta1.AccessType | null; + } + + /** Represents an AccessTypeParam. */ + class AccessTypeParam implements IAccessTypeParam { + /** + * Constructs a new AccessTypeParam. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IAccessTypeParam); + + /** AccessTypeParam value. */ + public value: cosmwasm.wasm.v1beta1.AccessType; + + /** + * Creates a new AccessTypeParam instance using the specified properties. + * @param [properties] Properties to set + * @returns AccessTypeParam instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IAccessTypeParam, + ): cosmwasm.wasm.v1beta1.AccessTypeParam; + + /** + * Encodes the specified AccessTypeParam message. Does not implicitly {@link cosmwasm.wasm.v1beta1.AccessTypeParam.verify|verify} messages. + * @param m AccessTypeParam message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IAccessTypeParam, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes an AccessTypeParam message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns AccessTypeParam + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.AccessTypeParam; + } + + /** Properties of an AccessConfig. */ + interface IAccessConfig { + /** AccessConfig permission */ + permission?: cosmwasm.wasm.v1beta1.AccessType | null; + + /** AccessConfig address */ + address?: string | null; + } + + /** Represents an AccessConfig. */ + class AccessConfig implements IAccessConfig { + /** + * Constructs a new AccessConfig. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IAccessConfig); + + /** AccessConfig permission. */ + public permission: cosmwasm.wasm.v1beta1.AccessType; + + /** AccessConfig address. */ + public address: string; + + /** + * Creates a new AccessConfig instance using the specified properties. + * @param [properties] Properties to set + * @returns AccessConfig instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IAccessConfig, + ): cosmwasm.wasm.v1beta1.AccessConfig; + + /** + * Encodes the specified AccessConfig message. Does not implicitly {@link cosmwasm.wasm.v1beta1.AccessConfig.verify|verify} messages. + * @param m AccessConfig message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmwasm.wasm.v1beta1.IAccessConfig, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an AccessConfig message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns AccessConfig + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.AccessConfig; + } + + /** Properties of a Params. */ + interface IParams { + /** Params codeUploadAccess */ + codeUploadAccess?: cosmwasm.wasm.v1beta1.IAccessConfig | null; + + /** Params instantiateDefaultPermission */ + instantiateDefaultPermission?: cosmwasm.wasm.v1beta1.AccessType | null; + + /** Params maxWasmCodeSize */ + maxWasmCodeSize?: Long | null; + } + + /** Represents a Params. */ + class Params implements IParams { + /** + * Constructs a new Params. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IParams); + + /** Params codeUploadAccess. */ + public codeUploadAccess?: cosmwasm.wasm.v1beta1.IAccessConfig | null; + + /** Params instantiateDefaultPermission. */ + public instantiateDefaultPermission: cosmwasm.wasm.v1beta1.AccessType; + + /** Params maxWasmCodeSize. */ + public maxWasmCodeSize: Long; + + /** + * Creates a new Params instance using the specified properties. + * @param [properties] Properties to set + * @returns Params instance + */ + public static create(properties?: cosmwasm.wasm.v1beta1.IParams): cosmwasm.wasm.v1beta1.Params; + + /** + * Encodes the specified Params message. Does not implicitly {@link cosmwasm.wasm.v1beta1.Params.verify|verify} messages. + * @param m Params message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmwasm.wasm.v1beta1.IParams, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Params message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Params + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmwasm.wasm.v1beta1.Params; + } + + /** Properties of a CodeInfo. */ + interface ICodeInfo { + /** CodeInfo codeHash */ + codeHash?: Uint8Array | null; + + /** CodeInfo creator */ + creator?: string | null; + + /** CodeInfo source */ + source?: string | null; + + /** CodeInfo builder */ + builder?: string | null; + + /** CodeInfo instantiateConfig */ + instantiateConfig?: cosmwasm.wasm.v1beta1.IAccessConfig | null; + } + + /** Represents a CodeInfo. */ + class CodeInfo implements ICodeInfo { + /** + * Constructs a new CodeInfo. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.ICodeInfo); + + /** CodeInfo codeHash. */ + public codeHash: Uint8Array; + + /** CodeInfo creator. */ + public creator: string; + + /** CodeInfo source. */ + public source: string; + + /** CodeInfo builder. */ + public builder: string; + + /** CodeInfo instantiateConfig. */ + public instantiateConfig?: cosmwasm.wasm.v1beta1.IAccessConfig | null; + + /** + * Creates a new CodeInfo instance using the specified properties. + * @param [properties] Properties to set + * @returns CodeInfo instance + */ + public static create(properties?: cosmwasm.wasm.v1beta1.ICodeInfo): cosmwasm.wasm.v1beta1.CodeInfo; + + /** + * Encodes the specified CodeInfo message. Does not implicitly {@link cosmwasm.wasm.v1beta1.CodeInfo.verify|verify} messages. + * @param m CodeInfo message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmwasm.wasm.v1beta1.ICodeInfo, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a CodeInfo message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns CodeInfo + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmwasm.wasm.v1beta1.CodeInfo; + } + + /** Properties of a ContractInfo. */ + interface IContractInfo { + /** ContractInfo codeId */ + codeId?: Long | null; + + /** ContractInfo creator */ + creator?: string | null; + + /** ContractInfo admin */ + admin?: string | null; + + /** ContractInfo label */ + label?: string | null; + + /** ContractInfo created */ + created?: cosmwasm.wasm.v1beta1.IAbsoluteTxPosition | null; + } + + /** Represents a ContractInfo. */ + class ContractInfo implements IContractInfo { + /** + * Constructs a new ContractInfo. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IContractInfo); + + /** ContractInfo codeId. */ + public codeId: Long; + + /** ContractInfo creator. */ + public creator: string; + + /** ContractInfo admin. */ + public admin: string; + + /** ContractInfo label. */ + public label: string; + + /** ContractInfo created. */ + public created?: cosmwasm.wasm.v1beta1.IAbsoluteTxPosition | null; + + /** + * Creates a new ContractInfo instance using the specified properties. + * @param [properties] Properties to set + * @returns ContractInfo instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IContractInfo, + ): cosmwasm.wasm.v1beta1.ContractInfo; + + /** + * Encodes the specified ContractInfo message. Does not implicitly {@link cosmwasm.wasm.v1beta1.ContractInfo.verify|verify} messages. + * @param m ContractInfo message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmwasm.wasm.v1beta1.IContractInfo, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a ContractInfo message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ContractInfo + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.ContractInfo; + } + + /** ContractCodeHistoryOperationType enum. */ + enum ContractCodeHistoryOperationType { + CONTRACT_CODE_HISTORY_OPERATION_TYPE_UNSPECIFIED = 0, + CONTRACT_CODE_HISTORY_OPERATION_TYPE_INIT = 1, + CONTRACT_CODE_HISTORY_OPERATION_TYPE_MIGRATE = 2, + CONTRACT_CODE_HISTORY_OPERATION_TYPE_GENESIS = 3, + } + + /** Properties of a ContractCodeHistoryEntry. */ + interface IContractCodeHistoryEntry { + /** ContractCodeHistoryEntry operation */ + operation?: cosmwasm.wasm.v1beta1.ContractCodeHistoryOperationType | null; + + /** ContractCodeHistoryEntry codeId */ + codeId?: Long | null; + + /** ContractCodeHistoryEntry updated */ + updated?: cosmwasm.wasm.v1beta1.IAbsoluteTxPosition | null; + + /** ContractCodeHistoryEntry msg */ + msg?: Uint8Array | null; + } + + /** Represents a ContractCodeHistoryEntry. */ + class ContractCodeHistoryEntry implements IContractCodeHistoryEntry { + /** + * Constructs a new ContractCodeHistoryEntry. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IContractCodeHistoryEntry); + + /** ContractCodeHistoryEntry operation. */ + public operation: cosmwasm.wasm.v1beta1.ContractCodeHistoryOperationType; + + /** ContractCodeHistoryEntry codeId. */ + public codeId: Long; + + /** ContractCodeHistoryEntry updated. */ + public updated?: cosmwasm.wasm.v1beta1.IAbsoluteTxPosition | null; + + /** ContractCodeHistoryEntry msg. */ + public msg: Uint8Array; + + /** + * Creates a new ContractCodeHistoryEntry instance using the specified properties. + * @param [properties] Properties to set + * @returns ContractCodeHistoryEntry instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IContractCodeHistoryEntry, + ): cosmwasm.wasm.v1beta1.ContractCodeHistoryEntry; + + /** + * Encodes the specified ContractCodeHistoryEntry message. Does not implicitly {@link cosmwasm.wasm.v1beta1.ContractCodeHistoryEntry.verify|verify} messages. + * @param m ContractCodeHistoryEntry message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IContractCodeHistoryEntry, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a ContractCodeHistoryEntry message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ContractCodeHistoryEntry + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.ContractCodeHistoryEntry; + } + + /** Properties of an AbsoluteTxPosition. */ + interface IAbsoluteTxPosition { + /** AbsoluteTxPosition blockHeight */ + blockHeight?: Long | null; + + /** AbsoluteTxPosition txIndex */ + txIndex?: Long | null; + } + + /** Represents an AbsoluteTxPosition. */ + class AbsoluteTxPosition implements IAbsoluteTxPosition { + /** + * Constructs a new AbsoluteTxPosition. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IAbsoluteTxPosition); + + /** AbsoluteTxPosition blockHeight. */ + public blockHeight: Long; + + /** AbsoluteTxPosition txIndex. */ + public txIndex: Long; + + /** + * Creates a new AbsoluteTxPosition instance using the specified properties. + * @param [properties] Properties to set + * @returns AbsoluteTxPosition instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IAbsoluteTxPosition, + ): cosmwasm.wasm.v1beta1.AbsoluteTxPosition; + + /** + * Encodes the specified AbsoluteTxPosition message. Does not implicitly {@link cosmwasm.wasm.v1beta1.AbsoluteTxPosition.verify|verify} messages. + * @param m AbsoluteTxPosition message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IAbsoluteTxPosition, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes an AbsoluteTxPosition message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns AbsoluteTxPosition + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.AbsoluteTxPosition; + } + + /** Properties of a Model. */ + interface IModel { + /** Model key */ + key?: Uint8Array | null; + + /** Model value */ + value?: Uint8Array | null; + } + + /** Represents a Model. */ + class Model implements IModel { + /** + * Constructs a new Model. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IModel); + + /** Model key. */ + public key: Uint8Array; + + /** Model value. */ + public value: Uint8Array; + + /** + * Creates a new Model instance using the specified properties. + * @param [properties] Properties to set + * @returns Model instance + */ + public static create(properties?: cosmwasm.wasm.v1beta1.IModel): cosmwasm.wasm.v1beta1.Model; + + /** + * Encodes the specified Model message. Does not implicitly {@link cosmwasm.wasm.v1beta1.Model.verify|verify} messages. + * @param m Model message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmwasm.wasm.v1beta1.IModel, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Model message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Model + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmwasm.wasm.v1beta1.Model; + } + } + } +} + +/** Namespace google. */ +export namespace google { + /** Namespace api. */ + namespace api { + /** Properties of a Http. */ + interface IHttp { + /** Http rules */ + rules?: google.api.IHttpRule[] | null; + } + + /** Represents a Http. */ + class Http implements IHttp { + /** + * Constructs a new Http. + * @param [p] Properties to set + */ + constructor(p?: google.api.IHttp); + + /** Http rules. */ + public rules: google.api.IHttpRule[]; + + /** + * Creates a new Http instance using the specified properties. + * @param [properties] Properties to set + * @returns Http instance + */ + public static create(properties?: google.api.IHttp): google.api.Http; + + /** + * Encodes the specified Http message. Does not implicitly {@link google.api.Http.verify|verify} messages. + * @param m Http message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.api.IHttp, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Http message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Http + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.api.Http; + } + + /** Properties of a HttpRule. */ + interface IHttpRule { + /** HttpRule get */ + get?: string | null; + + /** HttpRule put */ + put?: string | null; + + /** HttpRule post */ + post?: string | null; + + /** HttpRule delete */ + delete?: string | null; + + /** HttpRule patch */ + patch?: string | null; + + /** HttpRule custom */ + custom?: google.api.ICustomHttpPattern | null; + + /** HttpRule selector */ + selector?: string | null; + + /** HttpRule body */ + body?: string | null; + + /** HttpRule additionalBindings */ + additionalBindings?: google.api.IHttpRule[] | null; + } + + /** Represents a HttpRule. */ + class HttpRule implements IHttpRule { + /** + * Constructs a new HttpRule. + * @param [p] Properties to set + */ + constructor(p?: google.api.IHttpRule); + + /** HttpRule get. */ + public get: string; + + /** HttpRule put. */ + public put: string; + + /** HttpRule post. */ + public post: string; + + /** HttpRule delete. */ + public delete: string; + + /** HttpRule patch. */ + public patch: string; + + /** HttpRule custom. */ + public custom?: google.api.ICustomHttpPattern | null; + + /** HttpRule selector. */ + public selector: string; + + /** HttpRule body. */ + public body: string; + + /** HttpRule additionalBindings. */ + public additionalBindings: google.api.IHttpRule[]; + + /** HttpRule pattern. */ + public pattern?: "get" | "put" | "post" | "delete" | "patch" | "custom"; + + /** + * Creates a new HttpRule instance using the specified properties. + * @param [properties] Properties to set + * @returns HttpRule instance + */ + public static create(properties?: google.api.IHttpRule): google.api.HttpRule; + + /** + * Encodes the specified HttpRule message. Does not implicitly {@link google.api.HttpRule.verify|verify} messages. + * @param m HttpRule message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.api.IHttpRule, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a HttpRule message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns HttpRule + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.api.HttpRule; + } + + /** Properties of a CustomHttpPattern. */ + interface ICustomHttpPattern { + /** CustomHttpPattern kind */ + kind?: string | null; + + /** CustomHttpPattern path */ + path?: string | null; + } + + /** Represents a CustomHttpPattern. */ + class CustomHttpPattern implements ICustomHttpPattern { + /** + * Constructs a new CustomHttpPattern. + * @param [p] Properties to set + */ + constructor(p?: google.api.ICustomHttpPattern); + + /** CustomHttpPattern kind. */ + public kind: string; + + /** CustomHttpPattern path. */ + public path: string; + + /** + * Creates a new CustomHttpPattern instance using the specified properties. + * @param [properties] Properties to set + * @returns CustomHttpPattern instance + */ + public static create(properties?: google.api.ICustomHttpPattern): google.api.CustomHttpPattern; + + /** + * Encodes the specified CustomHttpPattern message. Does not implicitly {@link google.api.CustomHttpPattern.verify|verify} messages. + * @param m CustomHttpPattern message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.api.ICustomHttpPattern, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a CustomHttpPattern message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns CustomHttpPattern + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.api.CustomHttpPattern; + } + } + + /** Namespace protobuf. */ + namespace protobuf { + /** Properties of a FileDescriptorSet. */ + interface IFileDescriptorSet { + /** FileDescriptorSet file */ + file?: google.protobuf.IFileDescriptorProto[] | null; + } + + /** Represents a FileDescriptorSet. */ + class FileDescriptorSet implements IFileDescriptorSet { + /** + * Constructs a new FileDescriptorSet. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IFileDescriptorSet); + + /** FileDescriptorSet file. */ + public file: google.protobuf.IFileDescriptorProto[]; + + /** + * Creates a new FileDescriptorSet instance using the specified properties. + * @param [properties] Properties to set + * @returns FileDescriptorSet instance + */ + public static create( + properties?: google.protobuf.IFileDescriptorSet, + ): google.protobuf.FileDescriptorSet; + + /** + * Encodes the specified FileDescriptorSet message. Does not implicitly {@link google.protobuf.FileDescriptorSet.verify|verify} messages. + * @param m FileDescriptorSet message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IFileDescriptorSet, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a FileDescriptorSet message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns FileDescriptorSet + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.FileDescriptorSet; + } + + /** Properties of a FileDescriptorProto. */ + interface IFileDescriptorProto { + /** FileDescriptorProto name */ + name?: string | null; + + /** FileDescriptorProto package */ + package?: string | null; + + /** FileDescriptorProto dependency */ + dependency?: string[] | null; + + /** FileDescriptorProto publicDependency */ + publicDependency?: number[] | null; + + /** FileDescriptorProto weakDependency */ + weakDependency?: number[] | null; + + /** FileDescriptorProto messageType */ + messageType?: google.protobuf.IDescriptorProto[] | null; + + /** FileDescriptorProto enumType */ + enumType?: google.protobuf.IEnumDescriptorProto[] | null; + + /** FileDescriptorProto service */ + service?: google.protobuf.IServiceDescriptorProto[] | null; + + /** FileDescriptorProto extension */ + extension?: google.protobuf.IFieldDescriptorProto[] | null; + + /** FileDescriptorProto options */ + options?: google.protobuf.IFileOptions | null; + + /** FileDescriptorProto sourceCodeInfo */ + sourceCodeInfo?: google.protobuf.ISourceCodeInfo | null; + + /** FileDescriptorProto syntax */ + syntax?: string | null; + } + + /** Represents a FileDescriptorProto. */ + class FileDescriptorProto implements IFileDescriptorProto { + /** + * Constructs a new FileDescriptorProto. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IFileDescriptorProto); + + /** FileDescriptorProto name. */ + public name: string; + + /** FileDescriptorProto package. */ + public package: string; + + /** FileDescriptorProto dependency. */ + public dependency: string[]; + + /** FileDescriptorProto publicDependency. */ + public publicDependency: number[]; + + /** FileDescriptorProto weakDependency. */ + public weakDependency: number[]; + + /** FileDescriptorProto messageType. */ + public messageType: google.protobuf.IDescriptorProto[]; + + /** FileDescriptorProto enumType. */ + public enumType: google.protobuf.IEnumDescriptorProto[]; + + /** FileDescriptorProto service. */ + public service: google.protobuf.IServiceDescriptorProto[]; + + /** FileDescriptorProto extension. */ + public extension: google.protobuf.IFieldDescriptorProto[]; + + /** FileDescriptorProto options. */ + public options?: google.protobuf.IFileOptions | null; + + /** FileDescriptorProto sourceCodeInfo. */ + public sourceCodeInfo?: google.protobuf.ISourceCodeInfo | null; + + /** FileDescriptorProto syntax. */ + public syntax: string; + + /** + * Creates a new FileDescriptorProto instance using the specified properties. + * @param [properties] Properties to set + * @returns FileDescriptorProto instance + */ + public static create( + properties?: google.protobuf.IFileDescriptorProto, + ): google.protobuf.FileDescriptorProto; + + /** + * Encodes the specified FileDescriptorProto message. Does not implicitly {@link google.protobuf.FileDescriptorProto.verify|verify} messages. + * @param m FileDescriptorProto message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IFileDescriptorProto, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a FileDescriptorProto message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns FileDescriptorProto + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.FileDescriptorProto; + } + + /** Properties of a DescriptorProto. */ + interface IDescriptorProto { + /** DescriptorProto name */ + name?: string | null; + + /** DescriptorProto field */ + field?: google.protobuf.IFieldDescriptorProto[] | null; + + /** DescriptorProto extension */ + extension?: google.protobuf.IFieldDescriptorProto[] | null; + + /** DescriptorProto nestedType */ + nestedType?: google.protobuf.IDescriptorProto[] | null; + + /** DescriptorProto enumType */ + enumType?: google.protobuf.IEnumDescriptorProto[] | null; + + /** DescriptorProto extensionRange */ + extensionRange?: google.protobuf.DescriptorProto.IExtensionRange[] | null; + + /** DescriptorProto oneofDecl */ + oneofDecl?: google.protobuf.IOneofDescriptorProto[] | null; + + /** DescriptorProto options */ + options?: google.protobuf.IMessageOptions | null; + + /** DescriptorProto reservedRange */ + reservedRange?: google.protobuf.DescriptorProto.IReservedRange[] | null; + + /** DescriptorProto reservedName */ + reservedName?: string[] | null; + } + + /** Represents a DescriptorProto. */ + class DescriptorProto implements IDescriptorProto { + /** + * Constructs a new DescriptorProto. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IDescriptorProto); + + /** DescriptorProto name. */ + public name: string; + + /** DescriptorProto field. */ + public field: google.protobuf.IFieldDescriptorProto[]; + + /** DescriptorProto extension. */ + public extension: google.protobuf.IFieldDescriptorProto[]; + + /** DescriptorProto nestedType. */ + public nestedType: google.protobuf.IDescriptorProto[]; + + /** DescriptorProto enumType. */ + public enumType: google.protobuf.IEnumDescriptorProto[]; + + /** DescriptorProto extensionRange. */ + public extensionRange: google.protobuf.DescriptorProto.IExtensionRange[]; + + /** DescriptorProto oneofDecl. */ + public oneofDecl: google.protobuf.IOneofDescriptorProto[]; + + /** DescriptorProto options. */ + public options?: google.protobuf.IMessageOptions | null; + + /** DescriptorProto reservedRange. */ + public reservedRange: google.protobuf.DescriptorProto.IReservedRange[]; + + /** DescriptorProto reservedName. */ + public reservedName: string[]; + + /** + * Creates a new DescriptorProto instance using the specified properties. + * @param [properties] Properties to set + * @returns DescriptorProto instance + */ + public static create(properties?: google.protobuf.IDescriptorProto): google.protobuf.DescriptorProto; + + /** + * Encodes the specified DescriptorProto message. Does not implicitly {@link google.protobuf.DescriptorProto.verify|verify} messages. + * @param m DescriptorProto message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IDescriptorProto, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a DescriptorProto message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns DescriptorProto + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.DescriptorProto; + } + + namespace DescriptorProto { + /** Properties of an ExtensionRange. */ + interface IExtensionRange { + /** ExtensionRange start */ + start?: number | null; + + /** ExtensionRange end */ + end?: number | null; + } + + /** Represents an ExtensionRange. */ + class ExtensionRange implements IExtensionRange { + /** + * Constructs a new ExtensionRange. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.DescriptorProto.IExtensionRange); + + /** ExtensionRange start. */ + public start: number; + + /** ExtensionRange end. */ + public end: number; + + /** + * Creates a new ExtensionRange instance using the specified properties. + * @param [properties] Properties to set + * @returns ExtensionRange instance + */ + public static create( + properties?: google.protobuf.DescriptorProto.IExtensionRange, + ): google.protobuf.DescriptorProto.ExtensionRange; + + /** + * Encodes the specified ExtensionRange message. Does not implicitly {@link google.protobuf.DescriptorProto.ExtensionRange.verify|verify} messages. + * @param m ExtensionRange message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: google.protobuf.DescriptorProto.IExtensionRange, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes an ExtensionRange message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ExtensionRange + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): google.protobuf.DescriptorProto.ExtensionRange; + } + + /** Properties of a ReservedRange. */ + interface IReservedRange { + /** ReservedRange start */ + start?: number | null; + + /** ReservedRange end */ + end?: number | null; + } + + /** Represents a ReservedRange. */ + class ReservedRange implements IReservedRange { + /** + * Constructs a new ReservedRange. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.DescriptorProto.IReservedRange); + + /** ReservedRange start. */ + public start: number; + + /** ReservedRange end. */ + public end: number; + + /** + * Creates a new ReservedRange instance using the specified properties. + * @param [properties] Properties to set + * @returns ReservedRange instance + */ + public static create( + properties?: google.protobuf.DescriptorProto.IReservedRange, + ): google.protobuf.DescriptorProto.ReservedRange; + + /** + * Encodes the specified ReservedRange message. Does not implicitly {@link google.protobuf.DescriptorProto.ReservedRange.verify|verify} messages. + * @param m ReservedRange message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: google.protobuf.DescriptorProto.IReservedRange, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a ReservedRange message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ReservedRange + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): google.protobuf.DescriptorProto.ReservedRange; + } + } + + /** Properties of a FieldDescriptorProto. */ + interface IFieldDescriptorProto { + /** FieldDescriptorProto name */ + name?: string | null; + + /** FieldDescriptorProto number */ + number?: number | null; + + /** FieldDescriptorProto label */ + label?: google.protobuf.FieldDescriptorProto.Label | null; + + /** FieldDescriptorProto type */ + type?: google.protobuf.FieldDescriptorProto.Type | null; + + /** FieldDescriptorProto typeName */ + typeName?: string | null; + + /** FieldDescriptorProto extendee */ + extendee?: string | null; + + /** FieldDescriptorProto defaultValue */ + defaultValue?: string | null; + + /** FieldDescriptorProto oneofIndex */ + oneofIndex?: number | null; + + /** FieldDescriptorProto jsonName */ + jsonName?: string | null; + + /** FieldDescriptorProto options */ + options?: google.protobuf.IFieldOptions | null; + } + + /** Represents a FieldDescriptorProto. */ + class FieldDescriptorProto implements IFieldDescriptorProto { + /** + * Constructs a new FieldDescriptorProto. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IFieldDescriptorProto); + + /** FieldDescriptorProto name. */ + public name: string; + + /** FieldDescriptorProto number. */ + public number: number; + + /** FieldDescriptorProto label. */ + public label: google.protobuf.FieldDescriptorProto.Label; + + /** FieldDescriptorProto type. */ + public type: google.protobuf.FieldDescriptorProto.Type; + + /** FieldDescriptorProto typeName. */ + public typeName: string; + + /** FieldDescriptorProto extendee. */ + public extendee: string; + + /** FieldDescriptorProto defaultValue. */ + public defaultValue: string; + + /** FieldDescriptorProto oneofIndex. */ + public oneofIndex: number; + + /** FieldDescriptorProto jsonName. */ + public jsonName: string; + + /** FieldDescriptorProto options. */ + public options?: google.protobuf.IFieldOptions | null; + + /** + * Creates a new FieldDescriptorProto instance using the specified properties. + * @param [properties] Properties to set + * @returns FieldDescriptorProto instance + */ + public static create( + properties?: google.protobuf.IFieldDescriptorProto, + ): google.protobuf.FieldDescriptorProto; + + /** + * Encodes the specified FieldDescriptorProto message. Does not implicitly {@link google.protobuf.FieldDescriptorProto.verify|verify} messages. + * @param m FieldDescriptorProto message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IFieldDescriptorProto, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a FieldDescriptorProto message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns FieldDescriptorProto + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): google.protobuf.FieldDescriptorProto; + } + + namespace FieldDescriptorProto { + /** Type enum. */ + enum Type { + TYPE_DOUBLE = 1, + TYPE_FLOAT = 2, + TYPE_INT64 = 3, + TYPE_UINT64 = 4, + TYPE_INT32 = 5, + TYPE_FIXED64 = 6, + TYPE_FIXED32 = 7, + TYPE_BOOL = 8, + TYPE_STRING = 9, + TYPE_GROUP = 10, + TYPE_MESSAGE = 11, + TYPE_BYTES = 12, + TYPE_UINT32 = 13, + TYPE_ENUM = 14, + TYPE_SFIXED32 = 15, + TYPE_SFIXED64 = 16, + TYPE_SINT32 = 17, + TYPE_SINT64 = 18, + } + + /** Label enum. */ + enum Label { + LABEL_OPTIONAL = 1, + LABEL_REQUIRED = 2, + LABEL_REPEATED = 3, + } + } + + /** Properties of an OneofDescriptorProto. */ + interface IOneofDescriptorProto { + /** OneofDescriptorProto name */ + name?: string | null; + + /** OneofDescriptorProto options */ + options?: google.protobuf.IOneofOptions | null; + } + + /** Represents an OneofDescriptorProto. */ + class OneofDescriptorProto implements IOneofDescriptorProto { + /** + * Constructs a new OneofDescriptorProto. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IOneofDescriptorProto); + + /** OneofDescriptorProto name. */ + public name: string; + + /** OneofDescriptorProto options. */ + public options?: google.protobuf.IOneofOptions | null; + + /** + * Creates a new OneofDescriptorProto instance using the specified properties. + * @param [properties] Properties to set + * @returns OneofDescriptorProto instance + */ + public static create( + properties?: google.protobuf.IOneofDescriptorProto, + ): google.protobuf.OneofDescriptorProto; + + /** + * Encodes the specified OneofDescriptorProto message. Does not implicitly {@link google.protobuf.OneofDescriptorProto.verify|verify} messages. + * @param m OneofDescriptorProto message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IOneofDescriptorProto, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an OneofDescriptorProto message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns OneofDescriptorProto + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): google.protobuf.OneofDescriptorProto; + } + + /** Properties of an EnumDescriptorProto. */ + interface IEnumDescriptorProto { + /** EnumDescriptorProto name */ + name?: string | null; + + /** EnumDescriptorProto value */ + value?: google.protobuf.IEnumValueDescriptorProto[] | null; + + /** EnumDescriptorProto options */ + options?: google.protobuf.IEnumOptions | null; + } + + /** Represents an EnumDescriptorProto. */ + class EnumDescriptorProto implements IEnumDescriptorProto { + /** + * Constructs a new EnumDescriptorProto. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IEnumDescriptorProto); + + /** EnumDescriptorProto name. */ + public name: string; + + /** EnumDescriptorProto value. */ + public value: google.protobuf.IEnumValueDescriptorProto[]; + + /** EnumDescriptorProto options. */ + public options?: google.protobuf.IEnumOptions | null; + + /** + * Creates a new EnumDescriptorProto instance using the specified properties. + * @param [properties] Properties to set + * @returns EnumDescriptorProto instance + */ + public static create( + properties?: google.protobuf.IEnumDescriptorProto, + ): google.protobuf.EnumDescriptorProto; + + /** + * Encodes the specified EnumDescriptorProto message. Does not implicitly {@link google.protobuf.EnumDescriptorProto.verify|verify} messages. + * @param m EnumDescriptorProto message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IEnumDescriptorProto, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an EnumDescriptorProto message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns EnumDescriptorProto + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.EnumDescriptorProto; + } + + /** Properties of an EnumValueDescriptorProto. */ + interface IEnumValueDescriptorProto { + /** EnumValueDescriptorProto name */ + name?: string | null; + + /** EnumValueDescriptorProto number */ + number?: number | null; + + /** EnumValueDescriptorProto options */ + options?: google.protobuf.IEnumValueOptions | null; + } + + /** Represents an EnumValueDescriptorProto. */ + class EnumValueDescriptorProto implements IEnumValueDescriptorProto { + /** + * Constructs a new EnumValueDescriptorProto. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IEnumValueDescriptorProto); + + /** EnumValueDescriptorProto name. */ + public name: string; + + /** EnumValueDescriptorProto number. */ + public number: number; + + /** EnumValueDescriptorProto options. */ + public options?: google.protobuf.IEnumValueOptions | null; + + /** + * Creates a new EnumValueDescriptorProto instance using the specified properties. + * @param [properties] Properties to set + * @returns EnumValueDescriptorProto instance + */ + public static create( + properties?: google.protobuf.IEnumValueDescriptorProto, + ): google.protobuf.EnumValueDescriptorProto; + + /** + * Encodes the specified EnumValueDescriptorProto message. Does not implicitly {@link google.protobuf.EnumValueDescriptorProto.verify|verify} messages. + * @param m EnumValueDescriptorProto message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: google.protobuf.IEnumValueDescriptorProto, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes an EnumValueDescriptorProto message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns EnumValueDescriptorProto + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): google.protobuf.EnumValueDescriptorProto; + } + + /** Properties of a ServiceDescriptorProto. */ + interface IServiceDescriptorProto { + /** ServiceDescriptorProto name */ + name?: string | null; + + /** ServiceDescriptorProto method */ + method?: google.protobuf.IMethodDescriptorProto[] | null; + + /** ServiceDescriptorProto options */ + options?: google.protobuf.IServiceOptions | null; + } + + /** Represents a ServiceDescriptorProto. */ + class ServiceDescriptorProto implements IServiceDescriptorProto { + /** + * Constructs a new ServiceDescriptorProto. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IServiceDescriptorProto); + + /** ServiceDescriptorProto name. */ + public name: string; + + /** ServiceDescriptorProto method. */ + public method: google.protobuf.IMethodDescriptorProto[]; + + /** ServiceDescriptorProto options. */ + public options?: google.protobuf.IServiceOptions | null; + + /** + * Creates a new ServiceDescriptorProto instance using the specified properties. + * @param [properties] Properties to set + * @returns ServiceDescriptorProto instance + */ + public static create( + properties?: google.protobuf.IServiceDescriptorProto, + ): google.protobuf.ServiceDescriptorProto; + + /** + * Encodes the specified ServiceDescriptorProto message. Does not implicitly {@link google.protobuf.ServiceDescriptorProto.verify|verify} messages. + * @param m ServiceDescriptorProto message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: google.protobuf.IServiceDescriptorProto, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a ServiceDescriptorProto message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ServiceDescriptorProto + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): google.protobuf.ServiceDescriptorProto; + } + + /** Properties of a MethodDescriptorProto. */ + interface IMethodDescriptorProto { + /** MethodDescriptorProto name */ + name?: string | null; + + /** MethodDescriptorProto inputType */ + inputType?: string | null; + + /** MethodDescriptorProto outputType */ + outputType?: string | null; + + /** MethodDescriptorProto options */ + options?: google.protobuf.IMethodOptions | null; + + /** MethodDescriptorProto clientStreaming */ + clientStreaming?: boolean | null; + + /** MethodDescriptorProto serverStreaming */ + serverStreaming?: boolean | null; + } + + /** Represents a MethodDescriptorProto. */ + class MethodDescriptorProto implements IMethodDescriptorProto { + /** + * Constructs a new MethodDescriptorProto. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IMethodDescriptorProto); + + /** MethodDescriptorProto name. */ + public name: string; + + /** MethodDescriptorProto inputType. */ + public inputType: string; + + /** MethodDescriptorProto outputType. */ + public outputType: string; + + /** MethodDescriptorProto options. */ + public options?: google.protobuf.IMethodOptions | null; + + /** MethodDescriptorProto clientStreaming. */ + public clientStreaming: boolean; + + /** MethodDescriptorProto serverStreaming. */ + public serverStreaming: boolean; + + /** + * Creates a new MethodDescriptorProto instance using the specified properties. + * @param [properties] Properties to set + * @returns MethodDescriptorProto instance + */ + public static create( + properties?: google.protobuf.IMethodDescriptorProto, + ): google.protobuf.MethodDescriptorProto; + + /** + * Encodes the specified MethodDescriptorProto message. Does not implicitly {@link google.protobuf.MethodDescriptorProto.verify|verify} messages. + * @param m MethodDescriptorProto message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IMethodDescriptorProto, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MethodDescriptorProto message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MethodDescriptorProto + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): google.protobuf.MethodDescriptorProto; + } + + /** Properties of a FileOptions. */ + interface IFileOptions { + /** FileOptions javaPackage */ + javaPackage?: string | null; + + /** FileOptions javaOuterClassname */ + javaOuterClassname?: string | null; + + /** FileOptions javaMultipleFiles */ + javaMultipleFiles?: boolean | null; + + /** FileOptions javaGenerateEqualsAndHash */ + javaGenerateEqualsAndHash?: boolean | null; + + /** FileOptions javaStringCheckUtf8 */ + javaStringCheckUtf8?: boolean | null; + + /** FileOptions optimizeFor */ + optimizeFor?: google.protobuf.FileOptions.OptimizeMode | null; + + /** FileOptions goPackage */ + goPackage?: string | null; + + /** FileOptions ccGenericServices */ + ccGenericServices?: boolean | null; + + /** FileOptions javaGenericServices */ + javaGenericServices?: boolean | null; + + /** FileOptions pyGenericServices */ + pyGenericServices?: boolean | null; + + /** FileOptions deprecated */ + deprecated?: boolean | null; + + /** FileOptions ccEnableArenas */ + ccEnableArenas?: boolean | null; + + /** FileOptions objcClassPrefix */ + objcClassPrefix?: string | null; + + /** FileOptions csharpNamespace */ + csharpNamespace?: string | null; + + /** FileOptions uninterpretedOption */ + uninterpretedOption?: google.protobuf.IUninterpretedOption[] | null; + } + + /** Represents a FileOptions. */ + class FileOptions implements IFileOptions { + /** + * Constructs a new FileOptions. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IFileOptions); + + /** FileOptions javaPackage. */ + public javaPackage: string; + + /** FileOptions javaOuterClassname. */ + public javaOuterClassname: string; + + /** FileOptions javaMultipleFiles. */ + public javaMultipleFiles: boolean; + + /** FileOptions javaGenerateEqualsAndHash. */ + public javaGenerateEqualsAndHash: boolean; + + /** FileOptions javaStringCheckUtf8. */ + public javaStringCheckUtf8: boolean; + + /** FileOptions optimizeFor. */ + public optimizeFor: google.protobuf.FileOptions.OptimizeMode; + + /** FileOptions goPackage. */ + public goPackage: string; + + /** FileOptions ccGenericServices. */ + public ccGenericServices: boolean; + + /** FileOptions javaGenericServices. */ + public javaGenericServices: boolean; + + /** FileOptions pyGenericServices. */ + public pyGenericServices: boolean; + + /** FileOptions deprecated. */ + public deprecated: boolean; + + /** FileOptions ccEnableArenas. */ + public ccEnableArenas: boolean; + + /** FileOptions objcClassPrefix. */ + public objcClassPrefix: string; + + /** FileOptions csharpNamespace. */ + public csharpNamespace: string; + + /** FileOptions uninterpretedOption. */ + public uninterpretedOption: google.protobuf.IUninterpretedOption[]; + + /** + * Creates a new FileOptions instance using the specified properties. + * @param [properties] Properties to set + * @returns FileOptions instance + */ + public static create(properties?: google.protobuf.IFileOptions): google.protobuf.FileOptions; + + /** + * Encodes the specified FileOptions message. Does not implicitly {@link google.protobuf.FileOptions.verify|verify} messages. + * @param m FileOptions message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IFileOptions, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a FileOptions message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns FileOptions + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.FileOptions; + } + + namespace FileOptions { + /** OptimizeMode enum. */ + enum OptimizeMode { + SPEED = 1, + CODE_SIZE = 2, + LITE_RUNTIME = 3, + } + } + + /** Properties of a MessageOptions. */ + interface IMessageOptions { + /** MessageOptions messageSetWireFormat */ + messageSetWireFormat?: boolean | null; + + /** MessageOptions noStandardDescriptorAccessor */ + noStandardDescriptorAccessor?: boolean | null; + + /** MessageOptions deprecated */ + deprecated?: boolean | null; + + /** MessageOptions mapEntry */ + mapEntry?: boolean | null; + + /** MessageOptions uninterpretedOption */ + uninterpretedOption?: google.protobuf.IUninterpretedOption[] | null; + } + + /** Represents a MessageOptions. */ + class MessageOptions implements IMessageOptions { + /** + * Constructs a new MessageOptions. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IMessageOptions); + + /** MessageOptions messageSetWireFormat. */ + public messageSetWireFormat: boolean; + + /** MessageOptions noStandardDescriptorAccessor. */ + public noStandardDescriptorAccessor: boolean; + + /** MessageOptions deprecated. */ + public deprecated: boolean; + + /** MessageOptions mapEntry. */ + public mapEntry: boolean; + + /** MessageOptions uninterpretedOption. */ + public uninterpretedOption: google.protobuf.IUninterpretedOption[]; + + /** + * Creates a new MessageOptions instance using the specified properties. + * @param [properties] Properties to set + * @returns MessageOptions instance + */ + public static create(properties?: google.protobuf.IMessageOptions): google.protobuf.MessageOptions; + + /** + * Encodes the specified MessageOptions message. Does not implicitly {@link google.protobuf.MessageOptions.verify|verify} messages. + * @param m MessageOptions message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IMessageOptions, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MessageOptions message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MessageOptions + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.MessageOptions; + } + + /** Properties of a FieldOptions. */ + interface IFieldOptions { + /** FieldOptions ctype */ + ctype?: google.protobuf.FieldOptions.CType | null; + + /** FieldOptions packed */ + packed?: boolean | null; + + /** FieldOptions jstype */ + jstype?: google.protobuf.FieldOptions.JSType | null; + + /** FieldOptions lazy */ + lazy?: boolean | null; + + /** FieldOptions deprecated */ + deprecated?: boolean | null; + + /** FieldOptions weak */ + weak?: boolean | null; + + /** FieldOptions uninterpretedOption */ + uninterpretedOption?: google.protobuf.IUninterpretedOption[] | null; + } + + /** Represents a FieldOptions. */ + class FieldOptions implements IFieldOptions { + /** + * Constructs a new FieldOptions. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IFieldOptions); + + /** FieldOptions ctype. */ + public ctype: google.protobuf.FieldOptions.CType; + + /** FieldOptions packed. */ + public packed: boolean; + + /** FieldOptions jstype. */ + public jstype: google.protobuf.FieldOptions.JSType; + + /** FieldOptions lazy. */ + public lazy: boolean; + + /** FieldOptions deprecated. */ + public deprecated: boolean; + + /** FieldOptions weak. */ + public weak: boolean; + + /** FieldOptions uninterpretedOption. */ + public uninterpretedOption: google.protobuf.IUninterpretedOption[]; + + /** + * Creates a new FieldOptions instance using the specified properties. + * @param [properties] Properties to set + * @returns FieldOptions instance + */ + public static create(properties?: google.protobuf.IFieldOptions): google.protobuf.FieldOptions; + + /** + * Encodes the specified FieldOptions message. Does not implicitly {@link google.protobuf.FieldOptions.verify|verify} messages. + * @param m FieldOptions message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IFieldOptions, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a FieldOptions message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns FieldOptions + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.FieldOptions; + } + + namespace FieldOptions { + /** CType enum. */ + enum CType { + STRING = 0, + CORD = 1, + STRING_PIECE = 2, + } + + /** JSType enum. */ + enum JSType { + JS_NORMAL = 0, + JS_STRING = 1, + JS_NUMBER = 2, + } + } + + /** Properties of an OneofOptions. */ + interface IOneofOptions { + /** OneofOptions uninterpretedOption */ + uninterpretedOption?: google.protobuf.IUninterpretedOption[] | null; + } + + /** Represents an OneofOptions. */ + class OneofOptions implements IOneofOptions { + /** + * Constructs a new OneofOptions. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IOneofOptions); + + /** OneofOptions uninterpretedOption. */ + public uninterpretedOption: google.protobuf.IUninterpretedOption[]; + + /** + * Creates a new OneofOptions instance using the specified properties. + * @param [properties] Properties to set + * @returns OneofOptions instance + */ + public static create(properties?: google.protobuf.IOneofOptions): google.protobuf.OneofOptions; + + /** + * Encodes the specified OneofOptions message. Does not implicitly {@link google.protobuf.OneofOptions.verify|verify} messages. + * @param m OneofOptions message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IOneofOptions, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an OneofOptions message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns OneofOptions + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.OneofOptions; + } + + /** Properties of an EnumOptions. */ + interface IEnumOptions { + /** EnumOptions allowAlias */ + allowAlias?: boolean | null; + + /** EnumOptions deprecated */ + deprecated?: boolean | null; + + /** EnumOptions uninterpretedOption */ + uninterpretedOption?: google.protobuf.IUninterpretedOption[] | null; + } + + /** Represents an EnumOptions. */ + class EnumOptions implements IEnumOptions { + /** + * Constructs a new EnumOptions. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IEnumOptions); + + /** EnumOptions allowAlias. */ + public allowAlias: boolean; + + /** EnumOptions deprecated. */ + public deprecated: boolean; + + /** EnumOptions uninterpretedOption. */ + public uninterpretedOption: google.protobuf.IUninterpretedOption[]; + + /** + * Creates a new EnumOptions instance using the specified properties. + * @param [properties] Properties to set + * @returns EnumOptions instance + */ + public static create(properties?: google.protobuf.IEnumOptions): google.protobuf.EnumOptions; + + /** + * Encodes the specified EnumOptions message. Does not implicitly {@link google.protobuf.EnumOptions.verify|verify} messages. + * @param m EnumOptions message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IEnumOptions, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an EnumOptions message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns EnumOptions + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.EnumOptions; + } + + /** Properties of an EnumValueOptions. */ + interface IEnumValueOptions { + /** EnumValueOptions deprecated */ + deprecated?: boolean | null; + + /** EnumValueOptions uninterpretedOption */ + uninterpretedOption?: google.protobuf.IUninterpretedOption[] | null; + } + + /** Represents an EnumValueOptions. */ + class EnumValueOptions implements IEnumValueOptions { + /** + * Constructs a new EnumValueOptions. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IEnumValueOptions); + + /** EnumValueOptions deprecated. */ + public deprecated: boolean; + + /** EnumValueOptions uninterpretedOption. */ + public uninterpretedOption: google.protobuf.IUninterpretedOption[]; + + /** + * Creates a new EnumValueOptions instance using the specified properties. + * @param [properties] Properties to set + * @returns EnumValueOptions instance + */ + public static create(properties?: google.protobuf.IEnumValueOptions): google.protobuf.EnumValueOptions; + + /** + * Encodes the specified EnumValueOptions message. Does not implicitly {@link google.protobuf.EnumValueOptions.verify|verify} messages. + * @param m EnumValueOptions message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IEnumValueOptions, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an EnumValueOptions message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns EnumValueOptions + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.EnumValueOptions; + } + + /** Properties of a ServiceOptions. */ + interface IServiceOptions { + /** ServiceOptions deprecated */ + deprecated?: boolean | null; + + /** ServiceOptions uninterpretedOption */ + uninterpretedOption?: google.protobuf.IUninterpretedOption[] | null; + } + + /** Represents a ServiceOptions. */ + class ServiceOptions implements IServiceOptions { + /** + * Constructs a new ServiceOptions. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IServiceOptions); + + /** ServiceOptions deprecated. */ + public deprecated: boolean; + + /** ServiceOptions uninterpretedOption. */ + public uninterpretedOption: google.protobuf.IUninterpretedOption[]; + + /** + * Creates a new ServiceOptions instance using the specified properties. + * @param [properties] Properties to set + * @returns ServiceOptions instance + */ + public static create(properties?: google.protobuf.IServiceOptions): google.protobuf.ServiceOptions; + + /** + * Encodes the specified ServiceOptions message. Does not implicitly {@link google.protobuf.ServiceOptions.verify|verify} messages. + * @param m ServiceOptions message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IServiceOptions, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a ServiceOptions message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ServiceOptions + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.ServiceOptions; + } + + /** Properties of a MethodOptions. */ + interface IMethodOptions { + /** MethodOptions deprecated */ + deprecated?: boolean | null; + + /** MethodOptions uninterpretedOption */ + uninterpretedOption?: google.protobuf.IUninterpretedOption[] | null; + + /** MethodOptions .google.api.http */ + ".google.api.http"?: google.api.IHttpRule | null; + } + + /** Represents a MethodOptions. */ + class MethodOptions implements IMethodOptions { + /** + * Constructs a new MethodOptions. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IMethodOptions); + + /** MethodOptions deprecated. */ + public deprecated: boolean; + + /** MethodOptions uninterpretedOption. */ + public uninterpretedOption: google.protobuf.IUninterpretedOption[]; + + /** + * Creates a new MethodOptions instance using the specified properties. + * @param [properties] Properties to set + * @returns MethodOptions instance + */ + public static create(properties?: google.protobuf.IMethodOptions): google.protobuf.MethodOptions; + + /** + * Encodes the specified MethodOptions message. Does not implicitly {@link google.protobuf.MethodOptions.verify|verify} messages. + * @param m MethodOptions message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IMethodOptions, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MethodOptions message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MethodOptions + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.MethodOptions; + } + + /** Properties of an UninterpretedOption. */ + interface IUninterpretedOption { + /** UninterpretedOption name */ + name?: google.protobuf.UninterpretedOption.INamePart[] | null; + + /** UninterpretedOption identifierValue */ + identifierValue?: string | null; + + /** UninterpretedOption positiveIntValue */ + positiveIntValue?: Long | null; + + /** UninterpretedOption negativeIntValue */ + negativeIntValue?: Long | null; + + /** UninterpretedOption doubleValue */ + doubleValue?: number | null; + + /** UninterpretedOption stringValue */ + stringValue?: Uint8Array | null; + + /** UninterpretedOption aggregateValue */ + aggregateValue?: string | null; + } + + /** Represents an UninterpretedOption. */ + class UninterpretedOption implements IUninterpretedOption { + /** + * Constructs a new UninterpretedOption. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IUninterpretedOption); + + /** UninterpretedOption name. */ + public name: google.protobuf.UninterpretedOption.INamePart[]; + + /** UninterpretedOption identifierValue. */ + public identifierValue: string; + + /** UninterpretedOption positiveIntValue. */ + public positiveIntValue: Long; + + /** UninterpretedOption negativeIntValue. */ + public negativeIntValue: Long; + + /** UninterpretedOption doubleValue. */ + public doubleValue: number; + + /** UninterpretedOption stringValue. */ + public stringValue: Uint8Array; + + /** UninterpretedOption aggregateValue. */ + public aggregateValue: string; + + /** + * Creates a new UninterpretedOption instance using the specified properties. + * @param [properties] Properties to set + * @returns UninterpretedOption instance + */ + public static create( + properties?: google.protobuf.IUninterpretedOption, + ): google.protobuf.UninterpretedOption; + + /** + * Encodes the specified UninterpretedOption message. Does not implicitly {@link google.protobuf.UninterpretedOption.verify|verify} messages. + * @param m UninterpretedOption message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IUninterpretedOption, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an UninterpretedOption message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns UninterpretedOption + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.UninterpretedOption; + } + + namespace UninterpretedOption { + /** Properties of a NamePart. */ + interface INamePart { + /** NamePart namePart */ + namePart: string; + + /** NamePart isExtension */ + isExtension: boolean; + } + + /** Represents a NamePart. */ + class NamePart implements INamePart { + /** + * Constructs a new NamePart. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.UninterpretedOption.INamePart); + + /** NamePart namePart. */ + public namePart: string; + + /** NamePart isExtension. */ + public isExtension: boolean; + + /** + * Creates a new NamePart instance using the specified properties. + * @param [properties] Properties to set + * @returns NamePart instance + */ + public static create( + properties?: google.protobuf.UninterpretedOption.INamePart, + ): google.protobuf.UninterpretedOption.NamePart; + + /** + * Encodes the specified NamePart message. Does not implicitly {@link google.protobuf.UninterpretedOption.NamePart.verify|verify} messages. + * @param m NamePart message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: google.protobuf.UninterpretedOption.INamePart, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a NamePart message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns NamePart + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): google.protobuf.UninterpretedOption.NamePart; + } + } + + /** Properties of a SourceCodeInfo. */ + interface ISourceCodeInfo { + /** SourceCodeInfo location */ + location?: google.protobuf.SourceCodeInfo.ILocation[] | null; + } + + /** Represents a SourceCodeInfo. */ + class SourceCodeInfo implements ISourceCodeInfo { + /** + * Constructs a new SourceCodeInfo. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.ISourceCodeInfo); + + /** SourceCodeInfo location. */ + public location: google.protobuf.SourceCodeInfo.ILocation[]; + + /** + * Creates a new SourceCodeInfo instance using the specified properties. + * @param [properties] Properties to set + * @returns SourceCodeInfo instance + */ + public static create(properties?: google.protobuf.ISourceCodeInfo): google.protobuf.SourceCodeInfo; + + /** + * Encodes the specified SourceCodeInfo message. Does not implicitly {@link google.protobuf.SourceCodeInfo.verify|verify} messages. + * @param m SourceCodeInfo message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.ISourceCodeInfo, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a SourceCodeInfo message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns SourceCodeInfo + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.SourceCodeInfo; + } + + namespace SourceCodeInfo { + /** Properties of a Location. */ + interface ILocation { + /** Location path */ + path?: number[] | null; + + /** Location span */ + span?: number[] | null; + + /** Location leadingComments */ + leadingComments?: string | null; + + /** Location trailingComments */ + trailingComments?: string | null; + + /** Location leadingDetachedComments */ + leadingDetachedComments?: string[] | null; + } + + /** Represents a Location. */ + class Location implements ILocation { + /** + * Constructs a new Location. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.SourceCodeInfo.ILocation); + + /** Location path. */ + public path: number[]; + + /** Location span. */ + public span: number[]; + + /** Location leadingComments. */ + public leadingComments: string; + + /** Location trailingComments. */ + public trailingComments: string; + + /** Location leadingDetachedComments. */ + public leadingDetachedComments: string[]; + + /** + * Creates a new Location instance using the specified properties. + * @param [properties] Properties to set + * @returns Location instance + */ + public static create( + properties?: google.protobuf.SourceCodeInfo.ILocation, + ): google.protobuf.SourceCodeInfo.Location; + + /** + * Encodes the specified Location message. Does not implicitly {@link google.protobuf.SourceCodeInfo.Location.verify|verify} messages. + * @param m Location message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: google.protobuf.SourceCodeInfo.ILocation, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a Location message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Location + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): google.protobuf.SourceCodeInfo.Location; + } + } + + /** Properties of a GeneratedCodeInfo. */ + interface IGeneratedCodeInfo { + /** GeneratedCodeInfo annotation */ + annotation?: google.protobuf.GeneratedCodeInfo.IAnnotation[] | null; + } + + /** Represents a GeneratedCodeInfo. */ + class GeneratedCodeInfo implements IGeneratedCodeInfo { + /** + * Constructs a new GeneratedCodeInfo. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IGeneratedCodeInfo); + + /** GeneratedCodeInfo annotation. */ + public annotation: google.protobuf.GeneratedCodeInfo.IAnnotation[]; + + /** + * Creates a new GeneratedCodeInfo instance using the specified properties. + * @param [properties] Properties to set + * @returns GeneratedCodeInfo instance + */ + public static create( + properties?: google.protobuf.IGeneratedCodeInfo, + ): google.protobuf.GeneratedCodeInfo; + + /** + * Encodes the specified GeneratedCodeInfo message. Does not implicitly {@link google.protobuf.GeneratedCodeInfo.verify|verify} messages. + * @param m GeneratedCodeInfo message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IGeneratedCodeInfo, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a GeneratedCodeInfo message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns GeneratedCodeInfo + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.GeneratedCodeInfo; + } + + namespace GeneratedCodeInfo { + /** Properties of an Annotation. */ + interface IAnnotation { + /** Annotation path */ + path?: number[] | null; + + /** Annotation sourceFile */ + sourceFile?: string | null; + + /** Annotation begin */ + begin?: number | null; + + /** Annotation end */ + end?: number | null; + } + + /** Represents an Annotation. */ + class Annotation implements IAnnotation { + /** + * Constructs a new Annotation. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.GeneratedCodeInfo.IAnnotation); + + /** Annotation path. */ + public path: number[]; + + /** Annotation sourceFile. */ + public sourceFile: string; + + /** Annotation begin. */ + public begin: number; + + /** Annotation end. */ + public end: number; + + /** + * Creates a new Annotation instance using the specified properties. + * @param [properties] Properties to set + * @returns Annotation instance + */ + public static create( + properties?: google.protobuf.GeneratedCodeInfo.IAnnotation, + ): google.protobuf.GeneratedCodeInfo.Annotation; + + /** + * Encodes the specified Annotation message. Does not implicitly {@link google.protobuf.GeneratedCodeInfo.Annotation.verify|verify} messages. + * @param m Annotation message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: google.protobuf.GeneratedCodeInfo.IAnnotation, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes an Annotation message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Annotation + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): google.protobuf.GeneratedCodeInfo.Annotation; + } + } + } +} + +/** Namespace cosmos. */ +export namespace cosmos { + /** Namespace base. */ + namespace base { + /** Namespace v1beta1. */ + namespace v1beta1 { + /** Properties of a Coin. */ + interface ICoin { + /** Coin denom */ + denom?: string | null; + + /** Coin amount */ + amount?: string | null; + } + + /** Represents a Coin. */ + class Coin implements ICoin { + /** + * Constructs a new Coin. + * @param [p] Properties to set + */ + constructor(p?: cosmos.base.v1beta1.ICoin); + + /** Coin denom. */ + public denom: string; + + /** Coin amount. */ + public amount: string; + + /** + * Creates a new Coin instance using the specified properties. + * @param [properties] Properties to set + * @returns Coin instance + */ + public static create(properties?: cosmos.base.v1beta1.ICoin): cosmos.base.v1beta1.Coin; + + /** + * Encodes the specified Coin message. Does not implicitly {@link cosmos.base.v1beta1.Coin.verify|verify} messages. + * @param m Coin message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.base.v1beta1.ICoin, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Coin message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Coin + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.base.v1beta1.Coin; + } + + /** Properties of a DecCoin. */ + interface IDecCoin { + /** DecCoin denom */ + denom?: string | null; + + /** DecCoin amount */ + amount?: string | null; + } + + /** Represents a DecCoin. */ + class DecCoin implements IDecCoin { + /** + * Constructs a new DecCoin. + * @param [p] Properties to set + */ + constructor(p?: cosmos.base.v1beta1.IDecCoin); + + /** DecCoin denom. */ + public denom: string; + + /** DecCoin amount. */ + public amount: string; + + /** + * Creates a new DecCoin instance using the specified properties. + * @param [properties] Properties to set + * @returns DecCoin instance + */ + public static create(properties?: cosmos.base.v1beta1.IDecCoin): cosmos.base.v1beta1.DecCoin; + + /** + * Encodes the specified DecCoin message. Does not implicitly {@link cosmos.base.v1beta1.DecCoin.verify|verify} messages. + * @param m DecCoin message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.base.v1beta1.IDecCoin, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a DecCoin message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns DecCoin + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.base.v1beta1.DecCoin; + } + + /** Properties of an IntProto. */ + interface IIntProto { + /** IntProto int */ + int?: string | null; + } + + /** Represents an IntProto. */ + class IntProto implements IIntProto { + /** + * Constructs a new IntProto. + * @param [p] Properties to set + */ + constructor(p?: cosmos.base.v1beta1.IIntProto); + + /** IntProto int. */ + public int: string; + + /** + * Creates a new IntProto instance using the specified properties. + * @param [properties] Properties to set + * @returns IntProto instance + */ + public static create(properties?: cosmos.base.v1beta1.IIntProto): cosmos.base.v1beta1.IntProto; + + /** + * Encodes the specified IntProto message. Does not implicitly {@link cosmos.base.v1beta1.IntProto.verify|verify} messages. + * @param m IntProto message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.base.v1beta1.IIntProto, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an IntProto message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns IntProto + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.base.v1beta1.IntProto; + } + + /** Properties of a DecProto. */ + interface IDecProto { + /** DecProto dec */ + dec?: string | null; + } + + /** Represents a DecProto. */ + class DecProto implements IDecProto { + /** + * Constructs a new DecProto. + * @param [p] Properties to set + */ + constructor(p?: cosmos.base.v1beta1.IDecProto); + + /** DecProto dec. */ + public dec: string; + + /** + * Creates a new DecProto instance using the specified properties. + * @param [properties] Properties to set + * @returns DecProto instance + */ + public static create(properties?: cosmos.base.v1beta1.IDecProto): cosmos.base.v1beta1.DecProto; + + /** + * Encodes the specified DecProto message. Does not implicitly {@link cosmos.base.v1beta1.DecProto.verify|verify} messages. + * @param m DecProto message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.base.v1beta1.IDecProto, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a DecProto message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns DecProto + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.base.v1beta1.DecProto; + } + } + + /** Namespace query. */ + namespace query { + /** Namespace v1beta1. */ + namespace v1beta1 { + /** Properties of a PageRequest. */ + interface IPageRequest { + /** PageRequest key */ + key?: Uint8Array | null; + + /** PageRequest offset */ + offset?: Long | null; + + /** PageRequest limit */ + limit?: Long | null; + + /** PageRequest countTotal */ + countTotal?: boolean | null; + } + + /** Represents a PageRequest. */ + class PageRequest implements IPageRequest { + /** + * Constructs a new PageRequest. + * @param [p] Properties to set + */ + constructor(p?: cosmos.base.query.v1beta1.IPageRequest); + + /** PageRequest key. */ + public key: Uint8Array; + + /** PageRequest offset. */ + public offset: Long; + + /** PageRequest limit. */ + public limit: Long; + + /** PageRequest countTotal. */ + public countTotal: boolean; + + /** + * Creates a new PageRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns PageRequest instance + */ + public static create( + properties?: cosmos.base.query.v1beta1.IPageRequest, + ): cosmos.base.query.v1beta1.PageRequest; + + /** + * Encodes the specified PageRequest message. Does not implicitly {@link cosmos.base.query.v1beta1.PageRequest.verify|verify} messages. + * @param m PageRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.base.query.v1beta1.IPageRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a PageRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns PageRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.base.query.v1beta1.PageRequest; + } + + /** Properties of a PageResponse. */ + interface IPageResponse { + /** PageResponse nextKey */ + nextKey?: Uint8Array | null; + + /** PageResponse total */ + total?: Long | null; + } + + /** Represents a PageResponse. */ + class PageResponse implements IPageResponse { + /** + * Constructs a new PageResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmos.base.query.v1beta1.IPageResponse); + + /** PageResponse nextKey. */ + public nextKey: Uint8Array; + + /** PageResponse total. */ + public total: Long; + + /** + * Creates a new PageResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns PageResponse instance + */ + public static create( + properties?: cosmos.base.query.v1beta1.IPageResponse, + ): cosmos.base.query.v1beta1.PageResponse; + + /** + * Encodes the specified PageResponse message. Does not implicitly {@link cosmos.base.query.v1beta1.PageResponse.verify|verify} messages. + * @param m PageResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.base.query.v1beta1.IPageResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a PageResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns PageResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.base.query.v1beta1.PageResponse; + } + } + } + } +} diff --git a/packages/cosmwasm-stargate/src/codec/generated/codecimpl.js b/packages/cosmwasm-stargate/src/codec/generated/codecimpl.js new file mode 100644 index 00000000..a058f277 --- /dev/null +++ b/packages/cosmwasm-stargate/src/codec/generated/codecimpl.js @@ -0,0 +1,3615 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.cosmos = exports.google = exports.cosmwasm = void 0; +var $protobuf = require("protobufjs/minimal"); +const $Reader = $protobuf.Reader, + $Writer = $protobuf.Writer, + $util = $protobuf.util; +const $root = {}; +exports.cosmwasm = $root.cosmwasm = (() => { + const cosmwasm = {}; + cosmwasm.wasm = (function () { + const wasm = {}; + wasm.v1beta1 = (function () { + const v1beta1 = {}; + v1beta1.MsgStoreCode = (function () { + function MsgStoreCode(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + MsgStoreCode.prototype.sender = ""; + MsgStoreCode.prototype.wasmByteCode = $util.newBuffer([]); + MsgStoreCode.prototype.source = ""; + MsgStoreCode.prototype.builder = ""; + MsgStoreCode.prototype.instantiatePermission = null; + MsgStoreCode.create = function create(properties) { + return new MsgStoreCode(properties); + }; + MsgStoreCode.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.sender != null && Object.hasOwnProperty.call(m, "sender")) w.uint32(10).string(m.sender); + if (m.wasmByteCode != null && Object.hasOwnProperty.call(m, "wasmByteCode")) + w.uint32(18).bytes(m.wasmByteCode); + if (m.source != null && Object.hasOwnProperty.call(m, "source")) w.uint32(26).string(m.source); + if (m.builder != null && Object.hasOwnProperty.call(m, "builder")) w.uint32(34).string(m.builder); + if (m.instantiatePermission != null && Object.hasOwnProperty.call(m, "instantiatePermission")) + $root.cosmwasm.wasm.v1beta1.AccessConfig.encode( + m.instantiatePermission, + w.uint32(42).fork(), + ).ldelim(); + return w; + }; + MsgStoreCode.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.MsgStoreCode(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.sender = r.string(); + break; + case 2: + m.wasmByteCode = r.bytes(); + break; + case 3: + m.source = r.string(); + break; + case 4: + m.builder = r.string(); + break; + case 5: + m.instantiatePermission = $root.cosmwasm.wasm.v1beta1.AccessConfig.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgStoreCode; + })(); + v1beta1.MsgInstantiateContract = (function () { + function MsgInstantiateContract(p) { + this.initFunds = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + MsgInstantiateContract.prototype.sender = ""; + MsgInstantiateContract.prototype.admin = ""; + MsgInstantiateContract.prototype.codeId = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + MsgInstantiateContract.prototype.label = ""; + MsgInstantiateContract.prototype.initMsg = $util.newBuffer([]); + MsgInstantiateContract.prototype.initFunds = $util.emptyArray; + MsgInstantiateContract.create = function create(properties) { + return new MsgInstantiateContract(properties); + }; + MsgInstantiateContract.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.sender != null && Object.hasOwnProperty.call(m, "sender")) w.uint32(10).string(m.sender); + if (m.admin != null && Object.hasOwnProperty.call(m, "admin")) w.uint32(18).string(m.admin); + if (m.codeId != null && Object.hasOwnProperty.call(m, "codeId")) w.uint32(24).uint64(m.codeId); + if (m.label != null && Object.hasOwnProperty.call(m, "label")) w.uint32(34).string(m.label); + if (m.initMsg != null && Object.hasOwnProperty.call(m, "initMsg")) w.uint32(42).bytes(m.initMsg); + if (m.initFunds != null && m.initFunds.length) { + for (var i = 0; i < m.initFunds.length; ++i) + $root.cosmos.base.v1beta1.Coin.encode(m.initFunds[i], w.uint32(50).fork()).ldelim(); + } + return w; + }; + MsgInstantiateContract.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.MsgInstantiateContract(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.sender = r.string(); + break; + case 2: + m.admin = r.string(); + break; + case 3: + m.codeId = r.uint64(); + break; + case 4: + m.label = r.string(); + break; + case 5: + m.initMsg = r.bytes(); + break; + case 6: + if (!(m.initFunds && m.initFunds.length)) m.initFunds = []; + m.initFunds.push($root.cosmos.base.v1beta1.Coin.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgInstantiateContract; + })(); + v1beta1.MsgExecuteContract = (function () { + function MsgExecuteContract(p) { + this.sentFunds = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + MsgExecuteContract.prototype.sender = ""; + MsgExecuteContract.prototype.contract = ""; + MsgExecuteContract.prototype.msg = $util.newBuffer([]); + MsgExecuteContract.prototype.sentFunds = $util.emptyArray; + MsgExecuteContract.create = function create(properties) { + return new MsgExecuteContract(properties); + }; + MsgExecuteContract.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.sender != null && Object.hasOwnProperty.call(m, "sender")) w.uint32(10).string(m.sender); + if (m.contract != null && Object.hasOwnProperty.call(m, "contract")) + w.uint32(18).string(m.contract); + if (m.msg != null && Object.hasOwnProperty.call(m, "msg")) w.uint32(26).bytes(m.msg); + if (m.sentFunds != null && m.sentFunds.length) { + for (var i = 0; i < m.sentFunds.length; ++i) + $root.cosmos.base.v1beta1.Coin.encode(m.sentFunds[i], w.uint32(42).fork()).ldelim(); + } + return w; + }; + MsgExecuteContract.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.MsgExecuteContract(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.sender = r.string(); + break; + case 2: + m.contract = r.string(); + break; + case 3: + m.msg = r.bytes(); + break; + case 5: + if (!(m.sentFunds && m.sentFunds.length)) m.sentFunds = []; + m.sentFunds.push($root.cosmos.base.v1beta1.Coin.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgExecuteContract; + })(); + v1beta1.MsgMigrateContract = (function () { + function MsgMigrateContract(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + MsgMigrateContract.prototype.sender = ""; + MsgMigrateContract.prototype.contract = ""; + MsgMigrateContract.prototype.codeId = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + MsgMigrateContract.prototype.migrateMsg = $util.newBuffer([]); + MsgMigrateContract.create = function create(properties) { + return new MsgMigrateContract(properties); + }; + MsgMigrateContract.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.sender != null && Object.hasOwnProperty.call(m, "sender")) w.uint32(10).string(m.sender); + if (m.contract != null && Object.hasOwnProperty.call(m, "contract")) + w.uint32(18).string(m.contract); + if (m.codeId != null && Object.hasOwnProperty.call(m, "codeId")) w.uint32(24).uint64(m.codeId); + if (m.migrateMsg != null && Object.hasOwnProperty.call(m, "migrateMsg")) + w.uint32(34).bytes(m.migrateMsg); + return w; + }; + MsgMigrateContract.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.MsgMigrateContract(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.sender = r.string(); + break; + case 2: + m.contract = r.string(); + break; + case 3: + m.codeId = r.uint64(); + break; + case 4: + m.migrateMsg = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgMigrateContract; + })(); + v1beta1.MsgUpdateAdmin = (function () { + function MsgUpdateAdmin(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + MsgUpdateAdmin.prototype.sender = ""; + MsgUpdateAdmin.prototype.newAdmin = ""; + MsgUpdateAdmin.prototype.contract = ""; + MsgUpdateAdmin.create = function create(properties) { + return new MsgUpdateAdmin(properties); + }; + MsgUpdateAdmin.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.sender != null && Object.hasOwnProperty.call(m, "sender")) w.uint32(10).string(m.sender); + if (m.newAdmin != null && Object.hasOwnProperty.call(m, "newAdmin")) + w.uint32(18).string(m.newAdmin); + if (m.contract != null && Object.hasOwnProperty.call(m, "contract")) + w.uint32(26).string(m.contract); + return w; + }; + MsgUpdateAdmin.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.MsgUpdateAdmin(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.sender = r.string(); + break; + case 2: + m.newAdmin = r.string(); + break; + case 3: + m.contract = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgUpdateAdmin; + })(); + v1beta1.MsgClearAdmin = (function () { + function MsgClearAdmin(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + MsgClearAdmin.prototype.sender = ""; + MsgClearAdmin.prototype.contract = ""; + MsgClearAdmin.create = function create(properties) { + return new MsgClearAdmin(properties); + }; + MsgClearAdmin.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.sender != null && Object.hasOwnProperty.call(m, "sender")) w.uint32(10).string(m.sender); + if (m.contract != null && Object.hasOwnProperty.call(m, "contract")) + w.uint32(26).string(m.contract); + return w; + }; + MsgClearAdmin.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.MsgClearAdmin(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.sender = r.string(); + break; + case 3: + m.contract = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MsgClearAdmin; + })(); + v1beta1.Query = (function () { + function Query(rpcImpl, requestDelimited, responseDelimited) { + $protobuf.rpc.Service.call(this, rpcImpl, requestDelimited, responseDelimited); + } + (Query.prototype = Object.create($protobuf.rpc.Service.prototype)).constructor = Query; + Query.create = function create(rpcImpl, requestDelimited, responseDelimited) { + return new this(rpcImpl, requestDelimited, responseDelimited); + }; + Object.defineProperty( + (Query.prototype.contractInfo = function contractInfo(request, callback) { + return this.rpcCall( + contractInfo, + $root.cosmwasm.wasm.v1beta1.QueryContractInfoRequest, + $root.cosmwasm.wasm.v1beta1.QueryContractInfoResponse, + request, + callback, + ); + }), + "name", + { value: "ContractInfo" }, + ); + Object.defineProperty( + (Query.prototype.contractHistory = function contractHistory(request, callback) { + return this.rpcCall( + contractHistory, + $root.cosmwasm.wasm.v1beta1.QueryContractHistoryRequest, + $root.cosmwasm.wasm.v1beta1.QueryContractHistoryResponse, + request, + callback, + ); + }), + "name", + { value: "ContractHistory" }, + ); + Object.defineProperty( + (Query.prototype.contractsByCode = function contractsByCode(request, callback) { + return this.rpcCall( + contractsByCode, + $root.cosmwasm.wasm.v1beta1.QueryContractsByCodeRequest, + $root.cosmwasm.wasm.v1beta1.QueryContractsByCodeResponse, + request, + callback, + ); + }), + "name", + { value: "ContractsByCode" }, + ); + Object.defineProperty( + (Query.prototype.allContractState = function allContractState(request, callback) { + return this.rpcCall( + allContractState, + $root.cosmwasm.wasm.v1beta1.QueryAllContractStateRequest, + $root.cosmwasm.wasm.v1beta1.QueryAllContractStateResponse, + request, + callback, + ); + }), + "name", + { value: "AllContractState" }, + ); + Object.defineProperty( + (Query.prototype.rawContractState = function rawContractState(request, callback) { + return this.rpcCall( + rawContractState, + $root.cosmwasm.wasm.v1beta1.QueryRawContractStateRequest, + $root.cosmwasm.wasm.v1beta1.QueryRawContractStateResponse, + request, + callback, + ); + }), + "name", + { value: "RawContractState" }, + ); + Object.defineProperty( + (Query.prototype.smartContractState = function smartContractState(request, callback) { + return this.rpcCall( + smartContractState, + $root.cosmwasm.wasm.v1beta1.QuerySmartContractStateRequest, + $root.cosmwasm.wasm.v1beta1.QuerySmartContractStateResponse, + request, + callback, + ); + }), + "name", + { value: "SmartContractState" }, + ); + Object.defineProperty( + (Query.prototype.code = function code(request, callback) { + return this.rpcCall( + code, + $root.cosmwasm.wasm.v1beta1.QueryCodeRequest, + $root.cosmwasm.wasm.v1beta1.QueryCodeResponse, + request, + callback, + ); + }), + "name", + { value: "Code" }, + ); + Object.defineProperty( + (Query.prototype.codes = function codes(request, callback) { + return this.rpcCall( + codes, + $root.cosmwasm.wasm.v1beta1.QueryCodesRequest, + $root.cosmwasm.wasm.v1beta1.QueryCodesResponse, + request, + callback, + ); + }), + "name", + { value: "Codes" }, + ); + return Query; + })(); + v1beta1.QueryContractInfoRequest = (function () { + function QueryContractInfoRequest(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + QueryContractInfoRequest.prototype.address = ""; + QueryContractInfoRequest.create = function create(properties) { + return new QueryContractInfoRequest(properties); + }; + QueryContractInfoRequest.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.address != null && Object.hasOwnProperty.call(m, "address")) w.uint32(10).string(m.address); + return w; + }; + QueryContractInfoRequest.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.QueryContractInfoRequest(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.address = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryContractInfoRequest; + })(); + v1beta1.QueryContractInfoResponse = (function () { + function QueryContractInfoResponse(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + QueryContractInfoResponse.prototype.address = ""; + QueryContractInfoResponse.prototype.contractInfo = null; + QueryContractInfoResponse.create = function create(properties) { + return new QueryContractInfoResponse(properties); + }; + QueryContractInfoResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.address != null && Object.hasOwnProperty.call(m, "address")) w.uint32(10).string(m.address); + if (m.contractInfo != null && Object.hasOwnProperty.call(m, "contractInfo")) + $root.cosmwasm.wasm.v1beta1.ContractInfo.encode(m.contractInfo, w.uint32(18).fork()).ldelim(); + return w; + }; + QueryContractInfoResponse.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.QueryContractInfoResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.address = r.string(); + break; + case 2: + m.contractInfo = $root.cosmwasm.wasm.v1beta1.ContractInfo.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryContractInfoResponse; + })(); + v1beta1.QueryContractHistoryRequest = (function () { + function QueryContractHistoryRequest(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + QueryContractHistoryRequest.prototype.address = ""; + QueryContractHistoryRequest.prototype.pagination = null; + QueryContractHistoryRequest.create = function create(properties) { + return new QueryContractHistoryRequest(properties); + }; + QueryContractHistoryRequest.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.address != null && Object.hasOwnProperty.call(m, "address")) w.uint32(10).string(m.address); + if (m.pagination != null && Object.hasOwnProperty.call(m, "pagination")) + $root.cosmos.base.query.v1beta1.PageRequest.encode(m.pagination, w.uint32(18).fork()).ldelim(); + return w; + }; + QueryContractHistoryRequest.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.QueryContractHistoryRequest(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.address = r.string(); + break; + case 2: + m.pagination = $root.cosmos.base.query.v1beta1.PageRequest.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryContractHistoryRequest; + })(); + v1beta1.QueryContractHistoryResponse = (function () { + function QueryContractHistoryResponse(p) { + this.entries = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + QueryContractHistoryResponse.prototype.entries = $util.emptyArray; + QueryContractHistoryResponse.prototype.pagination = null; + QueryContractHistoryResponse.create = function create(properties) { + return new QueryContractHistoryResponse(properties); + }; + QueryContractHistoryResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.entries != null && m.entries.length) { + for (var i = 0; i < m.entries.length; ++i) + $root.cosmwasm.wasm.v1beta1.ContractCodeHistoryEntry.encode( + m.entries[i], + w.uint32(10).fork(), + ).ldelim(); + } + if (m.pagination != null && Object.hasOwnProperty.call(m, "pagination")) + $root.cosmos.base.query.v1beta1.PageResponse.encode(m.pagination, w.uint32(18).fork()).ldelim(); + return w; + }; + QueryContractHistoryResponse.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.QueryContractHistoryResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.entries && m.entries.length)) m.entries = []; + m.entries.push($root.cosmwasm.wasm.v1beta1.ContractCodeHistoryEntry.decode(r, r.uint32())); + break; + case 2: + m.pagination = $root.cosmos.base.query.v1beta1.PageResponse.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryContractHistoryResponse; + })(); + v1beta1.QueryContractsByCodeRequest = (function () { + function QueryContractsByCodeRequest(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + QueryContractsByCodeRequest.prototype.codeId = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + QueryContractsByCodeRequest.prototype.pagination = null; + QueryContractsByCodeRequest.create = function create(properties) { + return new QueryContractsByCodeRequest(properties); + }; + QueryContractsByCodeRequest.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.codeId != null && Object.hasOwnProperty.call(m, "codeId")) w.uint32(8).uint64(m.codeId); + if (m.pagination != null && Object.hasOwnProperty.call(m, "pagination")) + $root.cosmos.base.query.v1beta1.PageRequest.encode(m.pagination, w.uint32(18).fork()).ldelim(); + return w; + }; + QueryContractsByCodeRequest.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.QueryContractsByCodeRequest(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.codeId = r.uint64(); + break; + case 2: + m.pagination = $root.cosmos.base.query.v1beta1.PageRequest.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryContractsByCodeRequest; + })(); + v1beta1.ContractInfoWithAddress = (function () { + function ContractInfoWithAddress(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + ContractInfoWithAddress.prototype.address = ""; + ContractInfoWithAddress.prototype.contractInfo = null; + ContractInfoWithAddress.create = function create(properties) { + return new ContractInfoWithAddress(properties); + }; + ContractInfoWithAddress.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.address != null && Object.hasOwnProperty.call(m, "address")) w.uint32(10).string(m.address); + if (m.contractInfo != null && Object.hasOwnProperty.call(m, "contractInfo")) + $root.cosmwasm.wasm.v1beta1.ContractInfo.encode(m.contractInfo, w.uint32(18).fork()).ldelim(); + return w; + }; + ContractInfoWithAddress.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.ContractInfoWithAddress(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.address = r.string(); + break; + case 2: + m.contractInfo = $root.cosmwasm.wasm.v1beta1.ContractInfo.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return ContractInfoWithAddress; + })(); + v1beta1.QueryContractsByCodeResponse = (function () { + function QueryContractsByCodeResponse(p) { + this.contractInfos = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + QueryContractsByCodeResponse.prototype.contractInfos = $util.emptyArray; + QueryContractsByCodeResponse.prototype.pagination = null; + QueryContractsByCodeResponse.create = function create(properties) { + return new QueryContractsByCodeResponse(properties); + }; + QueryContractsByCodeResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.contractInfos != null && m.contractInfos.length) { + for (var i = 0; i < m.contractInfos.length; ++i) + $root.cosmwasm.wasm.v1beta1.ContractInfoWithAddress.encode( + m.contractInfos[i], + w.uint32(10).fork(), + ).ldelim(); + } + if (m.pagination != null && Object.hasOwnProperty.call(m, "pagination")) + $root.cosmos.base.query.v1beta1.PageResponse.encode(m.pagination, w.uint32(18).fork()).ldelim(); + return w; + }; + QueryContractsByCodeResponse.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.QueryContractsByCodeResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.contractInfos && m.contractInfos.length)) m.contractInfos = []; + m.contractInfos.push( + $root.cosmwasm.wasm.v1beta1.ContractInfoWithAddress.decode(r, r.uint32()), + ); + break; + case 2: + m.pagination = $root.cosmos.base.query.v1beta1.PageResponse.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryContractsByCodeResponse; + })(); + v1beta1.QueryAllContractStateRequest = (function () { + function QueryAllContractStateRequest(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + QueryAllContractStateRequest.prototype.address = ""; + QueryAllContractStateRequest.prototype.pagination = null; + QueryAllContractStateRequest.create = function create(properties) { + return new QueryAllContractStateRequest(properties); + }; + QueryAllContractStateRequest.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.address != null && Object.hasOwnProperty.call(m, "address")) w.uint32(10).string(m.address); + if (m.pagination != null && Object.hasOwnProperty.call(m, "pagination")) + $root.cosmos.base.query.v1beta1.PageRequest.encode(m.pagination, w.uint32(18).fork()).ldelim(); + return w; + }; + QueryAllContractStateRequest.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.QueryAllContractStateRequest(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.address = r.string(); + break; + case 2: + m.pagination = $root.cosmos.base.query.v1beta1.PageRequest.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryAllContractStateRequest; + })(); + v1beta1.QueryAllContractStateResponse = (function () { + function QueryAllContractStateResponse(p) { + this.models = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + QueryAllContractStateResponse.prototype.models = $util.emptyArray; + QueryAllContractStateResponse.prototype.pagination = null; + QueryAllContractStateResponse.create = function create(properties) { + return new QueryAllContractStateResponse(properties); + }; + QueryAllContractStateResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.models != null && m.models.length) { + for (var i = 0; i < m.models.length; ++i) + $root.cosmwasm.wasm.v1beta1.Model.encode(m.models[i], w.uint32(10).fork()).ldelim(); + } + if (m.pagination != null && Object.hasOwnProperty.call(m, "pagination")) + $root.cosmos.base.query.v1beta1.PageResponse.encode(m.pagination, w.uint32(18).fork()).ldelim(); + return w; + }; + QueryAllContractStateResponse.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.QueryAllContractStateResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.models && m.models.length)) m.models = []; + m.models.push($root.cosmwasm.wasm.v1beta1.Model.decode(r, r.uint32())); + break; + case 2: + m.pagination = $root.cosmos.base.query.v1beta1.PageResponse.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryAllContractStateResponse; + })(); + v1beta1.QueryRawContractStateRequest = (function () { + function QueryRawContractStateRequest(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + QueryRawContractStateRequest.prototype.address = ""; + QueryRawContractStateRequest.prototype.queryData = $util.newBuffer([]); + QueryRawContractStateRequest.create = function create(properties) { + return new QueryRawContractStateRequest(properties); + }; + QueryRawContractStateRequest.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.address != null && Object.hasOwnProperty.call(m, "address")) w.uint32(10).string(m.address); + if (m.queryData != null && Object.hasOwnProperty.call(m, "queryData")) + w.uint32(18).bytes(m.queryData); + return w; + }; + QueryRawContractStateRequest.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.QueryRawContractStateRequest(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.address = r.string(); + break; + case 2: + m.queryData = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryRawContractStateRequest; + })(); + v1beta1.QueryRawContractStateResponse = (function () { + function QueryRawContractStateResponse(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + QueryRawContractStateResponse.prototype.data = $util.newBuffer([]); + QueryRawContractStateResponse.create = function create(properties) { + return new QueryRawContractStateResponse(properties); + }; + QueryRawContractStateResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.data != null && Object.hasOwnProperty.call(m, "data")) w.uint32(10).bytes(m.data); + return w; + }; + QueryRawContractStateResponse.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.QueryRawContractStateResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.data = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryRawContractStateResponse; + })(); + v1beta1.QuerySmartContractStateRequest = (function () { + function QuerySmartContractStateRequest(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + QuerySmartContractStateRequest.prototype.address = ""; + QuerySmartContractStateRequest.prototype.queryData = $util.newBuffer([]); + QuerySmartContractStateRequest.create = function create(properties) { + return new QuerySmartContractStateRequest(properties); + }; + QuerySmartContractStateRequest.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.address != null && Object.hasOwnProperty.call(m, "address")) w.uint32(10).string(m.address); + if (m.queryData != null && Object.hasOwnProperty.call(m, "queryData")) + w.uint32(18).bytes(m.queryData); + return w; + }; + QuerySmartContractStateRequest.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.QuerySmartContractStateRequest(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.address = r.string(); + break; + case 2: + m.queryData = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QuerySmartContractStateRequest; + })(); + v1beta1.QuerySmartContractStateResponse = (function () { + function QuerySmartContractStateResponse(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + QuerySmartContractStateResponse.prototype.data = $util.newBuffer([]); + QuerySmartContractStateResponse.create = function create(properties) { + return new QuerySmartContractStateResponse(properties); + }; + QuerySmartContractStateResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.data != null && Object.hasOwnProperty.call(m, "data")) w.uint32(10).bytes(m.data); + return w; + }; + QuerySmartContractStateResponse.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.QuerySmartContractStateResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.data = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QuerySmartContractStateResponse; + })(); + v1beta1.QueryCodeRequest = (function () { + function QueryCodeRequest(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + QueryCodeRequest.prototype.codeId = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + QueryCodeRequest.create = function create(properties) { + return new QueryCodeRequest(properties); + }; + QueryCodeRequest.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.codeId != null && Object.hasOwnProperty.call(m, "codeId")) w.uint32(8).uint64(m.codeId); + return w; + }; + QueryCodeRequest.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.QueryCodeRequest(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.codeId = r.uint64(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryCodeRequest; + })(); + v1beta1.CodeInfoResponse = (function () { + function CodeInfoResponse(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + CodeInfoResponse.prototype.codeId = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + CodeInfoResponse.prototype.creator = ""; + CodeInfoResponse.prototype.dataHash = $util.newBuffer([]); + CodeInfoResponse.prototype.source = ""; + CodeInfoResponse.prototype.builder = ""; + CodeInfoResponse.create = function create(properties) { + return new CodeInfoResponse(properties); + }; + CodeInfoResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.codeId != null && Object.hasOwnProperty.call(m, "codeId")) w.uint32(8).uint64(m.codeId); + if (m.creator != null && Object.hasOwnProperty.call(m, "creator")) w.uint32(18).string(m.creator); + if (m.dataHash != null && Object.hasOwnProperty.call(m, "dataHash")) w.uint32(26).bytes(m.dataHash); + if (m.source != null && Object.hasOwnProperty.call(m, "source")) w.uint32(34).string(m.source); + if (m.builder != null && Object.hasOwnProperty.call(m, "builder")) w.uint32(42).string(m.builder); + return w; + }; + CodeInfoResponse.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.CodeInfoResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.codeId = r.uint64(); + break; + case 2: + m.creator = r.string(); + break; + case 3: + m.dataHash = r.bytes(); + break; + case 4: + m.source = r.string(); + break; + case 5: + m.builder = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return CodeInfoResponse; + })(); + v1beta1.QueryCodeResponse = (function () { + function QueryCodeResponse(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + QueryCodeResponse.prototype.codeInfo = null; + QueryCodeResponse.prototype.data = $util.newBuffer([]); + QueryCodeResponse.create = function create(properties) { + return new QueryCodeResponse(properties); + }; + QueryCodeResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.codeInfo != null && Object.hasOwnProperty.call(m, "codeInfo")) + $root.cosmwasm.wasm.v1beta1.CodeInfoResponse.encode(m.codeInfo, w.uint32(10).fork()).ldelim(); + if (m.data != null && Object.hasOwnProperty.call(m, "data")) w.uint32(18).bytes(m.data); + return w; + }; + QueryCodeResponse.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.QueryCodeResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.codeInfo = $root.cosmwasm.wasm.v1beta1.CodeInfoResponse.decode(r, r.uint32()); + break; + case 2: + m.data = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryCodeResponse; + })(); + v1beta1.QueryCodesRequest = (function () { + function QueryCodesRequest(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + QueryCodesRequest.prototype.pagination = null; + QueryCodesRequest.create = function create(properties) { + return new QueryCodesRequest(properties); + }; + QueryCodesRequest.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.pagination != null && Object.hasOwnProperty.call(m, "pagination")) + $root.cosmos.base.query.v1beta1.PageRequest.encode(m.pagination, w.uint32(10).fork()).ldelim(); + return w; + }; + QueryCodesRequest.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.QueryCodesRequest(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.pagination = $root.cosmos.base.query.v1beta1.PageRequest.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryCodesRequest; + })(); + v1beta1.QueryCodesResponse = (function () { + function QueryCodesResponse(p) { + this.codeInfos = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + QueryCodesResponse.prototype.codeInfos = $util.emptyArray; + QueryCodesResponse.prototype.pagination = null; + QueryCodesResponse.create = function create(properties) { + return new QueryCodesResponse(properties); + }; + QueryCodesResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.codeInfos != null && m.codeInfos.length) { + for (var i = 0; i < m.codeInfos.length; ++i) + $root.cosmwasm.wasm.v1beta1.CodeInfoResponse.encode( + m.codeInfos[i], + w.uint32(10).fork(), + ).ldelim(); + } + if (m.pagination != null && Object.hasOwnProperty.call(m, "pagination")) + $root.cosmos.base.query.v1beta1.PageResponse.encode(m.pagination, w.uint32(18).fork()).ldelim(); + return w; + }; + QueryCodesResponse.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.QueryCodesResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.codeInfos && m.codeInfos.length)) m.codeInfos = []; + m.codeInfos.push($root.cosmwasm.wasm.v1beta1.CodeInfoResponse.decode(r, r.uint32())); + break; + case 2: + m.pagination = $root.cosmos.base.query.v1beta1.PageResponse.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return QueryCodesResponse; + })(); + v1beta1.AccessType = (function () { + const valuesById = {}, + values = Object.create(valuesById); + values[(valuesById[0] = "ACCESS_TYPE_UNSPECIFIED")] = 0; + values[(valuesById[1] = "ACCESS_TYPE_NOBODY")] = 1; + values[(valuesById[2] = "ACCESS_TYPE_ONLY_ADDRESS")] = 2; + values[(valuesById[3] = "ACCESS_TYPE_EVERYBODY")] = 3; + return values; + })(); + v1beta1.AccessTypeParam = (function () { + function AccessTypeParam(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + AccessTypeParam.prototype.value = 0; + AccessTypeParam.create = function create(properties) { + return new AccessTypeParam(properties); + }; + AccessTypeParam.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.value != null && Object.hasOwnProperty.call(m, "value")) w.uint32(8).int32(m.value); + return w; + }; + AccessTypeParam.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.AccessTypeParam(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.value = r.int32(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return AccessTypeParam; + })(); + v1beta1.AccessConfig = (function () { + function AccessConfig(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + AccessConfig.prototype.permission = 0; + AccessConfig.prototype.address = ""; + AccessConfig.create = function create(properties) { + return new AccessConfig(properties); + }; + AccessConfig.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.permission != null && Object.hasOwnProperty.call(m, "permission")) + w.uint32(8).int32(m.permission); + if (m.address != null && Object.hasOwnProperty.call(m, "address")) w.uint32(18).string(m.address); + return w; + }; + AccessConfig.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.AccessConfig(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.permission = r.int32(); + break; + case 2: + m.address = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return AccessConfig; + })(); + v1beta1.Params = (function () { + function Params(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Params.prototype.codeUploadAccess = null; + Params.prototype.instantiateDefaultPermission = 0; + Params.prototype.maxWasmCodeSize = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + Params.create = function create(properties) { + return new Params(properties); + }; + Params.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.codeUploadAccess != null && Object.hasOwnProperty.call(m, "codeUploadAccess")) + $root.cosmwasm.wasm.v1beta1.AccessConfig.encode(m.codeUploadAccess, w.uint32(10).fork()).ldelim(); + if ( + m.instantiateDefaultPermission != null && + Object.hasOwnProperty.call(m, "instantiateDefaultPermission") + ) + w.uint32(16).int32(m.instantiateDefaultPermission); + if (m.maxWasmCodeSize != null && Object.hasOwnProperty.call(m, "maxWasmCodeSize")) + w.uint32(24).uint64(m.maxWasmCodeSize); + return w; + }; + Params.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.Params(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.codeUploadAccess = $root.cosmwasm.wasm.v1beta1.AccessConfig.decode(r, r.uint32()); + break; + case 2: + m.instantiateDefaultPermission = r.int32(); + break; + case 3: + m.maxWasmCodeSize = r.uint64(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Params; + })(); + v1beta1.CodeInfo = (function () { + function CodeInfo(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + CodeInfo.prototype.codeHash = $util.newBuffer([]); + CodeInfo.prototype.creator = ""; + CodeInfo.prototype.source = ""; + CodeInfo.prototype.builder = ""; + CodeInfo.prototype.instantiateConfig = null; + CodeInfo.create = function create(properties) { + return new CodeInfo(properties); + }; + CodeInfo.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.codeHash != null && Object.hasOwnProperty.call(m, "codeHash")) w.uint32(10).bytes(m.codeHash); + if (m.creator != null && Object.hasOwnProperty.call(m, "creator")) w.uint32(18).string(m.creator); + if (m.source != null && Object.hasOwnProperty.call(m, "source")) w.uint32(26).string(m.source); + if (m.builder != null && Object.hasOwnProperty.call(m, "builder")) w.uint32(34).string(m.builder); + if (m.instantiateConfig != null && Object.hasOwnProperty.call(m, "instantiateConfig")) + $root.cosmwasm.wasm.v1beta1.AccessConfig.encode( + m.instantiateConfig, + w.uint32(42).fork(), + ).ldelim(); + return w; + }; + CodeInfo.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.CodeInfo(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.codeHash = r.bytes(); + break; + case 2: + m.creator = r.string(); + break; + case 3: + m.source = r.string(); + break; + case 4: + m.builder = r.string(); + break; + case 5: + m.instantiateConfig = $root.cosmwasm.wasm.v1beta1.AccessConfig.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return CodeInfo; + })(); + v1beta1.ContractInfo = (function () { + function ContractInfo(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + ContractInfo.prototype.codeId = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + ContractInfo.prototype.creator = ""; + ContractInfo.prototype.admin = ""; + ContractInfo.prototype.label = ""; + ContractInfo.prototype.created = null; + ContractInfo.create = function create(properties) { + return new ContractInfo(properties); + }; + ContractInfo.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.codeId != null && Object.hasOwnProperty.call(m, "codeId")) w.uint32(8).uint64(m.codeId); + if (m.creator != null && Object.hasOwnProperty.call(m, "creator")) w.uint32(18).string(m.creator); + if (m.admin != null && Object.hasOwnProperty.call(m, "admin")) w.uint32(26).string(m.admin); + if (m.label != null && Object.hasOwnProperty.call(m, "label")) w.uint32(34).string(m.label); + if (m.created != null && Object.hasOwnProperty.call(m, "created")) + $root.cosmwasm.wasm.v1beta1.AbsoluteTxPosition.encode(m.created, w.uint32(42).fork()).ldelim(); + return w; + }; + ContractInfo.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.ContractInfo(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.codeId = r.uint64(); + break; + case 2: + m.creator = r.string(); + break; + case 3: + m.admin = r.string(); + break; + case 4: + m.label = r.string(); + break; + case 5: + m.created = $root.cosmwasm.wasm.v1beta1.AbsoluteTxPosition.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return ContractInfo; + })(); + v1beta1.ContractCodeHistoryOperationType = (function () { + const valuesById = {}, + values = Object.create(valuesById); + values[(valuesById[0] = "CONTRACT_CODE_HISTORY_OPERATION_TYPE_UNSPECIFIED")] = 0; + values[(valuesById[1] = "CONTRACT_CODE_HISTORY_OPERATION_TYPE_INIT")] = 1; + values[(valuesById[2] = "CONTRACT_CODE_HISTORY_OPERATION_TYPE_MIGRATE")] = 2; + values[(valuesById[3] = "CONTRACT_CODE_HISTORY_OPERATION_TYPE_GENESIS")] = 3; + return values; + })(); + v1beta1.ContractCodeHistoryEntry = (function () { + function ContractCodeHistoryEntry(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + ContractCodeHistoryEntry.prototype.operation = 0; + ContractCodeHistoryEntry.prototype.codeId = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + ContractCodeHistoryEntry.prototype.updated = null; + ContractCodeHistoryEntry.prototype.msg = $util.newBuffer([]); + ContractCodeHistoryEntry.create = function create(properties) { + return new ContractCodeHistoryEntry(properties); + }; + ContractCodeHistoryEntry.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.operation != null && Object.hasOwnProperty.call(m, "operation")) + w.uint32(8).int32(m.operation); + if (m.codeId != null && Object.hasOwnProperty.call(m, "codeId")) w.uint32(16).uint64(m.codeId); + if (m.updated != null && Object.hasOwnProperty.call(m, "updated")) + $root.cosmwasm.wasm.v1beta1.AbsoluteTxPosition.encode(m.updated, w.uint32(26).fork()).ldelim(); + if (m.msg != null && Object.hasOwnProperty.call(m, "msg")) w.uint32(34).bytes(m.msg); + return w; + }; + ContractCodeHistoryEntry.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.ContractCodeHistoryEntry(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.operation = r.int32(); + break; + case 2: + m.codeId = r.uint64(); + break; + case 3: + m.updated = $root.cosmwasm.wasm.v1beta1.AbsoluteTxPosition.decode(r, r.uint32()); + break; + case 4: + m.msg = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return ContractCodeHistoryEntry; + })(); + v1beta1.AbsoluteTxPosition = (function () { + function AbsoluteTxPosition(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + AbsoluteTxPosition.prototype.blockHeight = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + AbsoluteTxPosition.prototype.txIndex = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + AbsoluteTxPosition.create = function create(properties) { + return new AbsoluteTxPosition(properties); + }; + AbsoluteTxPosition.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.blockHeight != null && Object.hasOwnProperty.call(m, "blockHeight")) + w.uint32(8).uint64(m.blockHeight); + if (m.txIndex != null && Object.hasOwnProperty.call(m, "txIndex")) w.uint32(16).uint64(m.txIndex); + return w; + }; + AbsoluteTxPosition.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.AbsoluteTxPosition(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.blockHeight = r.uint64(); + break; + case 2: + m.txIndex = r.uint64(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return AbsoluteTxPosition; + })(); + v1beta1.Model = (function () { + function Model(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Model.prototype.key = $util.newBuffer([]); + Model.prototype.value = $util.newBuffer([]); + Model.create = function create(properties) { + return new Model(properties); + }; + Model.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.key != null && Object.hasOwnProperty.call(m, "key")) w.uint32(10).bytes(m.key); + if (m.value != null && Object.hasOwnProperty.call(m, "value")) w.uint32(18).bytes(m.value); + return w; + }; + Model.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmwasm.wasm.v1beta1.Model(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.key = r.bytes(); + break; + case 2: + m.value = r.bytes(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Model; + })(); + return v1beta1; + })(); + return wasm; + })(); + return cosmwasm; +})(); +exports.google = $root.google = (() => { + const google = {}; + google.api = (function () { + const api = {}; + api.Http = (function () { + function Http(p) { + this.rules = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Http.prototype.rules = $util.emptyArray; + Http.create = function create(properties) { + return new Http(properties); + }; + Http.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.rules != null && m.rules.length) { + for (var i = 0; i < m.rules.length; ++i) + $root.google.api.HttpRule.encode(m.rules[i], w.uint32(10).fork()).ldelim(); + } + return w; + }; + Http.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.api.Http(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.rules && m.rules.length)) m.rules = []; + m.rules.push($root.google.api.HttpRule.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Http; + })(); + api.HttpRule = (function () { + function HttpRule(p) { + this.additionalBindings = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + HttpRule.prototype.get = ""; + HttpRule.prototype.put = ""; + HttpRule.prototype.post = ""; + HttpRule.prototype["delete"] = ""; + HttpRule.prototype.patch = ""; + HttpRule.prototype.custom = null; + HttpRule.prototype.selector = ""; + HttpRule.prototype.body = ""; + HttpRule.prototype.additionalBindings = $util.emptyArray; + let $oneOfFields; + Object.defineProperty(HttpRule.prototype, "pattern", { + get: $util.oneOfGetter(($oneOfFields = ["get", "put", "post", "delete", "patch", "custom"])), + set: $util.oneOfSetter($oneOfFields), + }); + HttpRule.create = function create(properties) { + return new HttpRule(properties); + }; + HttpRule.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.selector != null && Object.hasOwnProperty.call(m, "selector")) w.uint32(10).string(m.selector); + if (m.get != null && Object.hasOwnProperty.call(m, "get")) w.uint32(18).string(m.get); + if (m.put != null && Object.hasOwnProperty.call(m, "put")) w.uint32(26).string(m.put); + if (m.post != null && Object.hasOwnProperty.call(m, "post")) w.uint32(34).string(m.post); + if (m["delete"] != null && Object.hasOwnProperty.call(m, "delete")) w.uint32(42).string(m["delete"]); + if (m.patch != null && Object.hasOwnProperty.call(m, "patch")) w.uint32(50).string(m.patch); + if (m.body != null && Object.hasOwnProperty.call(m, "body")) w.uint32(58).string(m.body); + if (m.custom != null && Object.hasOwnProperty.call(m, "custom")) + $root.google.api.CustomHttpPattern.encode(m.custom, w.uint32(66).fork()).ldelim(); + if (m.additionalBindings != null && m.additionalBindings.length) { + for (var i = 0; i < m.additionalBindings.length; ++i) + $root.google.api.HttpRule.encode(m.additionalBindings[i], w.uint32(90).fork()).ldelim(); + } + return w; + }; + HttpRule.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.api.HttpRule(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 2: + m.get = r.string(); + break; + case 3: + m.put = r.string(); + break; + case 4: + m.post = r.string(); + break; + case 5: + m["delete"] = r.string(); + break; + case 6: + m.patch = r.string(); + break; + case 8: + m.custom = $root.google.api.CustomHttpPattern.decode(r, r.uint32()); + break; + case 1: + m.selector = r.string(); + break; + case 7: + m.body = r.string(); + break; + case 11: + if (!(m.additionalBindings && m.additionalBindings.length)) m.additionalBindings = []; + m.additionalBindings.push($root.google.api.HttpRule.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return HttpRule; + })(); + api.CustomHttpPattern = (function () { + function CustomHttpPattern(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + CustomHttpPattern.prototype.kind = ""; + CustomHttpPattern.prototype.path = ""; + CustomHttpPattern.create = function create(properties) { + return new CustomHttpPattern(properties); + }; + CustomHttpPattern.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.kind != null && Object.hasOwnProperty.call(m, "kind")) w.uint32(10).string(m.kind); + if (m.path != null && Object.hasOwnProperty.call(m, "path")) w.uint32(18).string(m.path); + return w; + }; + CustomHttpPattern.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.api.CustomHttpPattern(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.kind = r.string(); + break; + case 2: + m.path = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return CustomHttpPattern; + })(); + return api; + })(); + google.protobuf = (function () { + const protobuf = {}; + protobuf.FileDescriptorSet = (function () { + function FileDescriptorSet(p) { + this.file = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + FileDescriptorSet.prototype.file = $util.emptyArray; + FileDescriptorSet.create = function create(properties) { + return new FileDescriptorSet(properties); + }; + FileDescriptorSet.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.file != null && m.file.length) { + for (var i = 0; i < m.file.length; ++i) + $root.google.protobuf.FileDescriptorProto.encode(m.file[i], w.uint32(10).fork()).ldelim(); + } + return w; + }; + FileDescriptorSet.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.FileDescriptorSet(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.file && m.file.length)) m.file = []; + m.file.push($root.google.protobuf.FileDescriptorProto.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return FileDescriptorSet; + })(); + protobuf.FileDescriptorProto = (function () { + function FileDescriptorProto(p) { + this.dependency = []; + this.publicDependency = []; + this.weakDependency = []; + this.messageType = []; + this.enumType = []; + this.service = []; + this.extension = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + FileDescriptorProto.prototype.name = ""; + FileDescriptorProto.prototype["package"] = ""; + FileDescriptorProto.prototype.dependency = $util.emptyArray; + FileDescriptorProto.prototype.publicDependency = $util.emptyArray; + FileDescriptorProto.prototype.weakDependency = $util.emptyArray; + FileDescriptorProto.prototype.messageType = $util.emptyArray; + FileDescriptorProto.prototype.enumType = $util.emptyArray; + FileDescriptorProto.prototype.service = $util.emptyArray; + FileDescriptorProto.prototype.extension = $util.emptyArray; + FileDescriptorProto.prototype.options = null; + FileDescriptorProto.prototype.sourceCodeInfo = null; + FileDescriptorProto.prototype.syntax = ""; + FileDescriptorProto.create = function create(properties) { + return new FileDescriptorProto(properties); + }; + FileDescriptorProto.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.name != null && Object.hasOwnProperty.call(m, "name")) w.uint32(10).string(m.name); + if (m["package"] != null && Object.hasOwnProperty.call(m, "package")) + w.uint32(18).string(m["package"]); + if (m.dependency != null && m.dependency.length) { + for (var i = 0; i < m.dependency.length; ++i) w.uint32(26).string(m.dependency[i]); + } + if (m.messageType != null && m.messageType.length) { + for (var i = 0; i < m.messageType.length; ++i) + $root.google.protobuf.DescriptorProto.encode(m.messageType[i], w.uint32(34).fork()).ldelim(); + } + if (m.enumType != null && m.enumType.length) { + for (var i = 0; i < m.enumType.length; ++i) + $root.google.protobuf.EnumDescriptorProto.encode(m.enumType[i], w.uint32(42).fork()).ldelim(); + } + if (m.service != null && m.service.length) { + for (var i = 0; i < m.service.length; ++i) + $root.google.protobuf.ServiceDescriptorProto.encode(m.service[i], w.uint32(50).fork()).ldelim(); + } + if (m.extension != null && m.extension.length) { + for (var i = 0; i < m.extension.length; ++i) + $root.google.protobuf.FieldDescriptorProto.encode(m.extension[i], w.uint32(58).fork()).ldelim(); + } + if (m.options != null && Object.hasOwnProperty.call(m, "options")) + $root.google.protobuf.FileOptions.encode(m.options, w.uint32(66).fork()).ldelim(); + if (m.sourceCodeInfo != null && Object.hasOwnProperty.call(m, "sourceCodeInfo")) + $root.google.protobuf.SourceCodeInfo.encode(m.sourceCodeInfo, w.uint32(74).fork()).ldelim(); + if (m.publicDependency != null && m.publicDependency.length) { + for (var i = 0; i < m.publicDependency.length; ++i) w.uint32(80).int32(m.publicDependency[i]); + } + if (m.weakDependency != null && m.weakDependency.length) { + for (var i = 0; i < m.weakDependency.length; ++i) w.uint32(88).int32(m.weakDependency[i]); + } + if (m.syntax != null && Object.hasOwnProperty.call(m, "syntax")) w.uint32(98).string(m.syntax); + return w; + }; + FileDescriptorProto.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.FileDescriptorProto(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.name = r.string(); + break; + case 2: + m["package"] = r.string(); + break; + case 3: + if (!(m.dependency && m.dependency.length)) m.dependency = []; + m.dependency.push(r.string()); + break; + case 10: + if (!(m.publicDependency && m.publicDependency.length)) m.publicDependency = []; + if ((t & 7) === 2) { + var c2 = r.uint32() + r.pos; + while (r.pos < c2) m.publicDependency.push(r.int32()); + } else m.publicDependency.push(r.int32()); + break; + case 11: + if (!(m.weakDependency && m.weakDependency.length)) m.weakDependency = []; + if ((t & 7) === 2) { + var c2 = r.uint32() + r.pos; + while (r.pos < c2) m.weakDependency.push(r.int32()); + } else m.weakDependency.push(r.int32()); + break; + case 4: + if (!(m.messageType && m.messageType.length)) m.messageType = []; + m.messageType.push($root.google.protobuf.DescriptorProto.decode(r, r.uint32())); + break; + case 5: + if (!(m.enumType && m.enumType.length)) m.enumType = []; + m.enumType.push($root.google.protobuf.EnumDescriptorProto.decode(r, r.uint32())); + break; + case 6: + if (!(m.service && m.service.length)) m.service = []; + m.service.push($root.google.protobuf.ServiceDescriptorProto.decode(r, r.uint32())); + break; + case 7: + if (!(m.extension && m.extension.length)) m.extension = []; + m.extension.push($root.google.protobuf.FieldDescriptorProto.decode(r, r.uint32())); + break; + case 8: + m.options = $root.google.protobuf.FileOptions.decode(r, r.uint32()); + break; + case 9: + m.sourceCodeInfo = $root.google.protobuf.SourceCodeInfo.decode(r, r.uint32()); + break; + case 12: + m.syntax = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return FileDescriptorProto; + })(); + protobuf.DescriptorProto = (function () { + function DescriptorProto(p) { + this.field = []; + this.extension = []; + this.nestedType = []; + this.enumType = []; + this.extensionRange = []; + this.oneofDecl = []; + this.reservedRange = []; + this.reservedName = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + DescriptorProto.prototype.name = ""; + DescriptorProto.prototype.field = $util.emptyArray; + DescriptorProto.prototype.extension = $util.emptyArray; + DescriptorProto.prototype.nestedType = $util.emptyArray; + DescriptorProto.prototype.enumType = $util.emptyArray; + DescriptorProto.prototype.extensionRange = $util.emptyArray; + DescriptorProto.prototype.oneofDecl = $util.emptyArray; + DescriptorProto.prototype.options = null; + DescriptorProto.prototype.reservedRange = $util.emptyArray; + DescriptorProto.prototype.reservedName = $util.emptyArray; + DescriptorProto.create = function create(properties) { + return new DescriptorProto(properties); + }; + DescriptorProto.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.name != null && Object.hasOwnProperty.call(m, "name")) w.uint32(10).string(m.name); + if (m.field != null && m.field.length) { + for (var i = 0; i < m.field.length; ++i) + $root.google.protobuf.FieldDescriptorProto.encode(m.field[i], w.uint32(18).fork()).ldelim(); + } + if (m.nestedType != null && m.nestedType.length) { + for (var i = 0; i < m.nestedType.length; ++i) + $root.google.protobuf.DescriptorProto.encode(m.nestedType[i], w.uint32(26).fork()).ldelim(); + } + if (m.enumType != null && m.enumType.length) { + for (var i = 0; i < m.enumType.length; ++i) + $root.google.protobuf.EnumDescriptorProto.encode(m.enumType[i], w.uint32(34).fork()).ldelim(); + } + if (m.extensionRange != null && m.extensionRange.length) { + for (var i = 0; i < m.extensionRange.length; ++i) + $root.google.protobuf.DescriptorProto.ExtensionRange.encode( + m.extensionRange[i], + w.uint32(42).fork(), + ).ldelim(); + } + if (m.extension != null && m.extension.length) { + for (var i = 0; i < m.extension.length; ++i) + $root.google.protobuf.FieldDescriptorProto.encode(m.extension[i], w.uint32(50).fork()).ldelim(); + } + if (m.options != null && Object.hasOwnProperty.call(m, "options")) + $root.google.protobuf.MessageOptions.encode(m.options, w.uint32(58).fork()).ldelim(); + if (m.oneofDecl != null && m.oneofDecl.length) { + for (var i = 0; i < m.oneofDecl.length; ++i) + $root.google.protobuf.OneofDescriptorProto.encode(m.oneofDecl[i], w.uint32(66).fork()).ldelim(); + } + if (m.reservedRange != null && m.reservedRange.length) { + for (var i = 0; i < m.reservedRange.length; ++i) + $root.google.protobuf.DescriptorProto.ReservedRange.encode( + m.reservedRange[i], + w.uint32(74).fork(), + ).ldelim(); + } + if (m.reservedName != null && m.reservedName.length) { + for (var i = 0; i < m.reservedName.length; ++i) w.uint32(82).string(m.reservedName[i]); + } + return w; + }; + DescriptorProto.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.DescriptorProto(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.name = r.string(); + break; + case 2: + if (!(m.field && m.field.length)) m.field = []; + m.field.push($root.google.protobuf.FieldDescriptorProto.decode(r, r.uint32())); + break; + case 6: + if (!(m.extension && m.extension.length)) m.extension = []; + m.extension.push($root.google.protobuf.FieldDescriptorProto.decode(r, r.uint32())); + break; + case 3: + if (!(m.nestedType && m.nestedType.length)) m.nestedType = []; + m.nestedType.push($root.google.protobuf.DescriptorProto.decode(r, r.uint32())); + break; + case 4: + if (!(m.enumType && m.enumType.length)) m.enumType = []; + m.enumType.push($root.google.protobuf.EnumDescriptorProto.decode(r, r.uint32())); + break; + case 5: + if (!(m.extensionRange && m.extensionRange.length)) m.extensionRange = []; + m.extensionRange.push( + $root.google.protobuf.DescriptorProto.ExtensionRange.decode(r, r.uint32()), + ); + break; + case 8: + if (!(m.oneofDecl && m.oneofDecl.length)) m.oneofDecl = []; + m.oneofDecl.push($root.google.protobuf.OneofDescriptorProto.decode(r, r.uint32())); + break; + case 7: + m.options = $root.google.protobuf.MessageOptions.decode(r, r.uint32()); + break; + case 9: + if (!(m.reservedRange && m.reservedRange.length)) m.reservedRange = []; + m.reservedRange.push($root.google.protobuf.DescriptorProto.ReservedRange.decode(r, r.uint32())); + break; + case 10: + if (!(m.reservedName && m.reservedName.length)) m.reservedName = []; + m.reservedName.push(r.string()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + DescriptorProto.ExtensionRange = (function () { + function ExtensionRange(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + ExtensionRange.prototype.start = 0; + ExtensionRange.prototype.end = 0; + ExtensionRange.create = function create(properties) { + return new ExtensionRange(properties); + }; + ExtensionRange.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.start != null && Object.hasOwnProperty.call(m, "start")) w.uint32(8).int32(m.start); + if (m.end != null && Object.hasOwnProperty.call(m, "end")) w.uint32(16).int32(m.end); + return w; + }; + ExtensionRange.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.DescriptorProto.ExtensionRange(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.start = r.int32(); + break; + case 2: + m.end = r.int32(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return ExtensionRange; + })(); + DescriptorProto.ReservedRange = (function () { + function ReservedRange(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + ReservedRange.prototype.start = 0; + ReservedRange.prototype.end = 0; + ReservedRange.create = function create(properties) { + return new ReservedRange(properties); + }; + ReservedRange.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.start != null && Object.hasOwnProperty.call(m, "start")) w.uint32(8).int32(m.start); + if (m.end != null && Object.hasOwnProperty.call(m, "end")) w.uint32(16).int32(m.end); + return w; + }; + ReservedRange.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.DescriptorProto.ReservedRange(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.start = r.int32(); + break; + case 2: + m.end = r.int32(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return ReservedRange; + })(); + return DescriptorProto; + })(); + protobuf.FieldDescriptorProto = (function () { + function FieldDescriptorProto(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + FieldDescriptorProto.prototype.name = ""; + FieldDescriptorProto.prototype.number = 0; + FieldDescriptorProto.prototype.label = 1; + FieldDescriptorProto.prototype.type = 1; + FieldDescriptorProto.prototype.typeName = ""; + FieldDescriptorProto.prototype.extendee = ""; + FieldDescriptorProto.prototype.defaultValue = ""; + FieldDescriptorProto.prototype.oneofIndex = 0; + FieldDescriptorProto.prototype.jsonName = ""; + FieldDescriptorProto.prototype.options = null; + FieldDescriptorProto.create = function create(properties) { + return new FieldDescriptorProto(properties); + }; + FieldDescriptorProto.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.name != null && Object.hasOwnProperty.call(m, "name")) w.uint32(10).string(m.name); + if (m.extendee != null && Object.hasOwnProperty.call(m, "extendee")) w.uint32(18).string(m.extendee); + if (m.number != null && Object.hasOwnProperty.call(m, "number")) w.uint32(24).int32(m.number); + if (m.label != null && Object.hasOwnProperty.call(m, "label")) w.uint32(32).int32(m.label); + if (m.type != null && Object.hasOwnProperty.call(m, "type")) w.uint32(40).int32(m.type); + if (m.typeName != null && Object.hasOwnProperty.call(m, "typeName")) w.uint32(50).string(m.typeName); + if (m.defaultValue != null && Object.hasOwnProperty.call(m, "defaultValue")) + w.uint32(58).string(m.defaultValue); + if (m.options != null && Object.hasOwnProperty.call(m, "options")) + $root.google.protobuf.FieldOptions.encode(m.options, w.uint32(66).fork()).ldelim(); + if (m.oneofIndex != null && Object.hasOwnProperty.call(m, "oneofIndex")) + w.uint32(72).int32(m.oneofIndex); + if (m.jsonName != null && Object.hasOwnProperty.call(m, "jsonName")) w.uint32(82).string(m.jsonName); + return w; + }; + FieldDescriptorProto.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.FieldDescriptorProto(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.name = r.string(); + break; + case 3: + m.number = r.int32(); + break; + case 4: + m.label = r.int32(); + break; + case 5: + m.type = r.int32(); + break; + case 6: + m.typeName = r.string(); + break; + case 2: + m.extendee = r.string(); + break; + case 7: + m.defaultValue = r.string(); + break; + case 9: + m.oneofIndex = r.int32(); + break; + case 10: + m.jsonName = r.string(); + break; + case 8: + m.options = $root.google.protobuf.FieldOptions.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + FieldDescriptorProto.Type = (function () { + const valuesById = {}, + values = Object.create(valuesById); + values[(valuesById[1] = "TYPE_DOUBLE")] = 1; + values[(valuesById[2] = "TYPE_FLOAT")] = 2; + values[(valuesById[3] = "TYPE_INT64")] = 3; + values[(valuesById[4] = "TYPE_UINT64")] = 4; + values[(valuesById[5] = "TYPE_INT32")] = 5; + values[(valuesById[6] = "TYPE_FIXED64")] = 6; + values[(valuesById[7] = "TYPE_FIXED32")] = 7; + values[(valuesById[8] = "TYPE_BOOL")] = 8; + values[(valuesById[9] = "TYPE_STRING")] = 9; + values[(valuesById[10] = "TYPE_GROUP")] = 10; + values[(valuesById[11] = "TYPE_MESSAGE")] = 11; + values[(valuesById[12] = "TYPE_BYTES")] = 12; + values[(valuesById[13] = "TYPE_UINT32")] = 13; + values[(valuesById[14] = "TYPE_ENUM")] = 14; + values[(valuesById[15] = "TYPE_SFIXED32")] = 15; + values[(valuesById[16] = "TYPE_SFIXED64")] = 16; + values[(valuesById[17] = "TYPE_SINT32")] = 17; + values[(valuesById[18] = "TYPE_SINT64")] = 18; + return values; + })(); + FieldDescriptorProto.Label = (function () { + const valuesById = {}, + values = Object.create(valuesById); + values[(valuesById[1] = "LABEL_OPTIONAL")] = 1; + values[(valuesById[2] = "LABEL_REQUIRED")] = 2; + values[(valuesById[3] = "LABEL_REPEATED")] = 3; + return values; + })(); + return FieldDescriptorProto; + })(); + protobuf.OneofDescriptorProto = (function () { + function OneofDescriptorProto(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + OneofDescriptorProto.prototype.name = ""; + OneofDescriptorProto.prototype.options = null; + OneofDescriptorProto.create = function create(properties) { + return new OneofDescriptorProto(properties); + }; + OneofDescriptorProto.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.name != null && Object.hasOwnProperty.call(m, "name")) w.uint32(10).string(m.name); + if (m.options != null && Object.hasOwnProperty.call(m, "options")) + $root.google.protobuf.OneofOptions.encode(m.options, w.uint32(18).fork()).ldelim(); + return w; + }; + OneofDescriptorProto.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.OneofDescriptorProto(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.name = r.string(); + break; + case 2: + m.options = $root.google.protobuf.OneofOptions.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return OneofDescriptorProto; + })(); + protobuf.EnumDescriptorProto = (function () { + function EnumDescriptorProto(p) { + this.value = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + EnumDescriptorProto.prototype.name = ""; + EnumDescriptorProto.prototype.value = $util.emptyArray; + EnumDescriptorProto.prototype.options = null; + EnumDescriptorProto.create = function create(properties) { + return new EnumDescriptorProto(properties); + }; + EnumDescriptorProto.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.name != null && Object.hasOwnProperty.call(m, "name")) w.uint32(10).string(m.name); + if (m.value != null && m.value.length) { + for (var i = 0; i < m.value.length; ++i) + $root.google.protobuf.EnumValueDescriptorProto.encode(m.value[i], w.uint32(18).fork()).ldelim(); + } + if (m.options != null && Object.hasOwnProperty.call(m, "options")) + $root.google.protobuf.EnumOptions.encode(m.options, w.uint32(26).fork()).ldelim(); + return w; + }; + EnumDescriptorProto.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.EnumDescriptorProto(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.name = r.string(); + break; + case 2: + if (!(m.value && m.value.length)) m.value = []; + m.value.push($root.google.protobuf.EnumValueDescriptorProto.decode(r, r.uint32())); + break; + case 3: + m.options = $root.google.protobuf.EnumOptions.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return EnumDescriptorProto; + })(); + protobuf.EnumValueDescriptorProto = (function () { + function EnumValueDescriptorProto(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + EnumValueDescriptorProto.prototype.name = ""; + EnumValueDescriptorProto.prototype.number = 0; + EnumValueDescriptorProto.prototype.options = null; + EnumValueDescriptorProto.create = function create(properties) { + return new EnumValueDescriptorProto(properties); + }; + EnumValueDescriptorProto.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.name != null && Object.hasOwnProperty.call(m, "name")) w.uint32(10).string(m.name); + if (m.number != null && Object.hasOwnProperty.call(m, "number")) w.uint32(16).int32(m.number); + if (m.options != null && Object.hasOwnProperty.call(m, "options")) + $root.google.protobuf.EnumValueOptions.encode(m.options, w.uint32(26).fork()).ldelim(); + return w; + }; + EnumValueDescriptorProto.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.EnumValueDescriptorProto(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.name = r.string(); + break; + case 2: + m.number = r.int32(); + break; + case 3: + m.options = $root.google.protobuf.EnumValueOptions.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return EnumValueDescriptorProto; + })(); + protobuf.ServiceDescriptorProto = (function () { + function ServiceDescriptorProto(p) { + this.method = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + ServiceDescriptorProto.prototype.name = ""; + ServiceDescriptorProto.prototype.method = $util.emptyArray; + ServiceDescriptorProto.prototype.options = null; + ServiceDescriptorProto.create = function create(properties) { + return new ServiceDescriptorProto(properties); + }; + ServiceDescriptorProto.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.name != null && Object.hasOwnProperty.call(m, "name")) w.uint32(10).string(m.name); + if (m.method != null && m.method.length) { + for (var i = 0; i < m.method.length; ++i) + $root.google.protobuf.MethodDescriptorProto.encode(m.method[i], w.uint32(18).fork()).ldelim(); + } + if (m.options != null && Object.hasOwnProperty.call(m, "options")) + $root.google.protobuf.ServiceOptions.encode(m.options, w.uint32(26).fork()).ldelim(); + return w; + }; + ServiceDescriptorProto.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.ServiceDescriptorProto(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.name = r.string(); + break; + case 2: + if (!(m.method && m.method.length)) m.method = []; + m.method.push($root.google.protobuf.MethodDescriptorProto.decode(r, r.uint32())); + break; + case 3: + m.options = $root.google.protobuf.ServiceOptions.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return ServiceDescriptorProto; + })(); + protobuf.MethodDescriptorProto = (function () { + function MethodDescriptorProto(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + MethodDescriptorProto.prototype.name = ""; + MethodDescriptorProto.prototype.inputType = ""; + MethodDescriptorProto.prototype.outputType = ""; + MethodDescriptorProto.prototype.options = null; + MethodDescriptorProto.prototype.clientStreaming = false; + MethodDescriptorProto.prototype.serverStreaming = false; + MethodDescriptorProto.create = function create(properties) { + return new MethodDescriptorProto(properties); + }; + MethodDescriptorProto.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.name != null && Object.hasOwnProperty.call(m, "name")) w.uint32(10).string(m.name); + if (m.inputType != null && Object.hasOwnProperty.call(m, "inputType")) + w.uint32(18).string(m.inputType); + if (m.outputType != null && Object.hasOwnProperty.call(m, "outputType")) + w.uint32(26).string(m.outputType); + if (m.options != null && Object.hasOwnProperty.call(m, "options")) + $root.google.protobuf.MethodOptions.encode(m.options, w.uint32(34).fork()).ldelim(); + if (m.clientStreaming != null && Object.hasOwnProperty.call(m, "clientStreaming")) + w.uint32(40).bool(m.clientStreaming); + if (m.serverStreaming != null && Object.hasOwnProperty.call(m, "serverStreaming")) + w.uint32(48).bool(m.serverStreaming); + return w; + }; + MethodDescriptorProto.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.MethodDescriptorProto(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.name = r.string(); + break; + case 2: + m.inputType = r.string(); + break; + case 3: + m.outputType = r.string(); + break; + case 4: + m.options = $root.google.protobuf.MethodOptions.decode(r, r.uint32()); + break; + case 5: + m.clientStreaming = r.bool(); + break; + case 6: + m.serverStreaming = r.bool(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MethodDescriptorProto; + })(); + protobuf.FileOptions = (function () { + function FileOptions(p) { + this.uninterpretedOption = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + FileOptions.prototype.javaPackage = ""; + FileOptions.prototype.javaOuterClassname = ""; + FileOptions.prototype.javaMultipleFiles = false; + FileOptions.prototype.javaGenerateEqualsAndHash = false; + FileOptions.prototype.javaStringCheckUtf8 = false; + FileOptions.prototype.optimizeFor = 1; + FileOptions.prototype.goPackage = ""; + FileOptions.prototype.ccGenericServices = false; + FileOptions.prototype.javaGenericServices = false; + FileOptions.prototype.pyGenericServices = false; + FileOptions.prototype.deprecated = false; + FileOptions.prototype.ccEnableArenas = false; + FileOptions.prototype.objcClassPrefix = ""; + FileOptions.prototype.csharpNamespace = ""; + FileOptions.prototype.uninterpretedOption = $util.emptyArray; + FileOptions.create = function create(properties) { + return new FileOptions(properties); + }; + FileOptions.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.javaPackage != null && Object.hasOwnProperty.call(m, "javaPackage")) + w.uint32(10).string(m.javaPackage); + if (m.javaOuterClassname != null && Object.hasOwnProperty.call(m, "javaOuterClassname")) + w.uint32(66).string(m.javaOuterClassname); + if (m.optimizeFor != null && Object.hasOwnProperty.call(m, "optimizeFor")) + w.uint32(72).int32(m.optimizeFor); + if (m.javaMultipleFiles != null && Object.hasOwnProperty.call(m, "javaMultipleFiles")) + w.uint32(80).bool(m.javaMultipleFiles); + if (m.goPackage != null && Object.hasOwnProperty.call(m, "goPackage")) + w.uint32(90).string(m.goPackage); + if (m.ccGenericServices != null && Object.hasOwnProperty.call(m, "ccGenericServices")) + w.uint32(128).bool(m.ccGenericServices); + if (m.javaGenericServices != null && Object.hasOwnProperty.call(m, "javaGenericServices")) + w.uint32(136).bool(m.javaGenericServices); + if (m.pyGenericServices != null && Object.hasOwnProperty.call(m, "pyGenericServices")) + w.uint32(144).bool(m.pyGenericServices); + if (m.javaGenerateEqualsAndHash != null && Object.hasOwnProperty.call(m, "javaGenerateEqualsAndHash")) + w.uint32(160).bool(m.javaGenerateEqualsAndHash); + if (m.deprecated != null && Object.hasOwnProperty.call(m, "deprecated")) + w.uint32(184).bool(m.deprecated); + if (m.javaStringCheckUtf8 != null && Object.hasOwnProperty.call(m, "javaStringCheckUtf8")) + w.uint32(216).bool(m.javaStringCheckUtf8); + if (m.ccEnableArenas != null && Object.hasOwnProperty.call(m, "ccEnableArenas")) + w.uint32(248).bool(m.ccEnableArenas); + if (m.objcClassPrefix != null && Object.hasOwnProperty.call(m, "objcClassPrefix")) + w.uint32(290).string(m.objcClassPrefix); + if (m.csharpNamespace != null && Object.hasOwnProperty.call(m, "csharpNamespace")) + w.uint32(298).string(m.csharpNamespace); + if (m.uninterpretedOption != null && m.uninterpretedOption.length) { + for (var i = 0; i < m.uninterpretedOption.length; ++i) + $root.google.protobuf.UninterpretedOption.encode( + m.uninterpretedOption[i], + w.uint32(7994).fork(), + ).ldelim(); + } + return w; + }; + FileOptions.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.FileOptions(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.javaPackage = r.string(); + break; + case 8: + m.javaOuterClassname = r.string(); + break; + case 10: + m.javaMultipleFiles = r.bool(); + break; + case 20: + m.javaGenerateEqualsAndHash = r.bool(); + break; + case 27: + m.javaStringCheckUtf8 = r.bool(); + break; + case 9: + m.optimizeFor = r.int32(); + break; + case 11: + m.goPackage = r.string(); + break; + case 16: + m.ccGenericServices = r.bool(); + break; + case 17: + m.javaGenericServices = r.bool(); + break; + case 18: + m.pyGenericServices = r.bool(); + break; + case 23: + m.deprecated = r.bool(); + break; + case 31: + m.ccEnableArenas = r.bool(); + break; + case 36: + m.objcClassPrefix = r.string(); + break; + case 37: + m.csharpNamespace = r.string(); + break; + case 999: + if (!(m.uninterpretedOption && m.uninterpretedOption.length)) m.uninterpretedOption = []; + m.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + FileOptions.OptimizeMode = (function () { + const valuesById = {}, + values = Object.create(valuesById); + values[(valuesById[1] = "SPEED")] = 1; + values[(valuesById[2] = "CODE_SIZE")] = 2; + values[(valuesById[3] = "LITE_RUNTIME")] = 3; + return values; + })(); + return FileOptions; + })(); + protobuf.MessageOptions = (function () { + function MessageOptions(p) { + this.uninterpretedOption = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + MessageOptions.prototype.messageSetWireFormat = false; + MessageOptions.prototype.noStandardDescriptorAccessor = false; + MessageOptions.prototype.deprecated = false; + MessageOptions.prototype.mapEntry = false; + MessageOptions.prototype.uninterpretedOption = $util.emptyArray; + MessageOptions.create = function create(properties) { + return new MessageOptions(properties); + }; + MessageOptions.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.messageSetWireFormat != null && Object.hasOwnProperty.call(m, "messageSetWireFormat")) + w.uint32(8).bool(m.messageSetWireFormat); + if ( + m.noStandardDescriptorAccessor != null && + Object.hasOwnProperty.call(m, "noStandardDescriptorAccessor") + ) + w.uint32(16).bool(m.noStandardDescriptorAccessor); + if (m.deprecated != null && Object.hasOwnProperty.call(m, "deprecated")) + w.uint32(24).bool(m.deprecated); + if (m.mapEntry != null && Object.hasOwnProperty.call(m, "mapEntry")) w.uint32(56).bool(m.mapEntry); + if (m.uninterpretedOption != null && m.uninterpretedOption.length) { + for (var i = 0; i < m.uninterpretedOption.length; ++i) + $root.google.protobuf.UninterpretedOption.encode( + m.uninterpretedOption[i], + w.uint32(7994).fork(), + ).ldelim(); + } + return w; + }; + MessageOptions.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.MessageOptions(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.messageSetWireFormat = r.bool(); + break; + case 2: + m.noStandardDescriptorAccessor = r.bool(); + break; + case 3: + m.deprecated = r.bool(); + break; + case 7: + m.mapEntry = r.bool(); + break; + case 999: + if (!(m.uninterpretedOption && m.uninterpretedOption.length)) m.uninterpretedOption = []; + m.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MessageOptions; + })(); + protobuf.FieldOptions = (function () { + function FieldOptions(p) { + this.uninterpretedOption = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + FieldOptions.prototype.ctype = 0; + FieldOptions.prototype.packed = false; + FieldOptions.prototype.jstype = 0; + FieldOptions.prototype.lazy = false; + FieldOptions.prototype.deprecated = false; + FieldOptions.prototype.weak = false; + FieldOptions.prototype.uninterpretedOption = $util.emptyArray; + FieldOptions.create = function create(properties) { + return new FieldOptions(properties); + }; + FieldOptions.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.ctype != null && Object.hasOwnProperty.call(m, "ctype")) w.uint32(8).int32(m.ctype); + if (m.packed != null && Object.hasOwnProperty.call(m, "packed")) w.uint32(16).bool(m.packed); + if (m.deprecated != null && Object.hasOwnProperty.call(m, "deprecated")) + w.uint32(24).bool(m.deprecated); + if (m.lazy != null && Object.hasOwnProperty.call(m, "lazy")) w.uint32(40).bool(m.lazy); + if (m.jstype != null && Object.hasOwnProperty.call(m, "jstype")) w.uint32(48).int32(m.jstype); + if (m.weak != null && Object.hasOwnProperty.call(m, "weak")) w.uint32(80).bool(m.weak); + if (m.uninterpretedOption != null && m.uninterpretedOption.length) { + for (var i = 0; i < m.uninterpretedOption.length; ++i) + $root.google.protobuf.UninterpretedOption.encode( + m.uninterpretedOption[i], + w.uint32(7994).fork(), + ).ldelim(); + } + return w; + }; + FieldOptions.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.FieldOptions(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.ctype = r.int32(); + break; + case 2: + m.packed = r.bool(); + break; + case 6: + m.jstype = r.int32(); + break; + case 5: + m.lazy = r.bool(); + break; + case 3: + m.deprecated = r.bool(); + break; + case 10: + m.weak = r.bool(); + break; + case 999: + if (!(m.uninterpretedOption && m.uninterpretedOption.length)) m.uninterpretedOption = []; + m.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + FieldOptions.CType = (function () { + const valuesById = {}, + values = Object.create(valuesById); + values[(valuesById[0] = "STRING")] = 0; + values[(valuesById[1] = "CORD")] = 1; + values[(valuesById[2] = "STRING_PIECE")] = 2; + return values; + })(); + FieldOptions.JSType = (function () { + const valuesById = {}, + values = Object.create(valuesById); + values[(valuesById[0] = "JS_NORMAL")] = 0; + values[(valuesById[1] = "JS_STRING")] = 1; + values[(valuesById[2] = "JS_NUMBER")] = 2; + return values; + })(); + return FieldOptions; + })(); + protobuf.OneofOptions = (function () { + function OneofOptions(p) { + this.uninterpretedOption = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + OneofOptions.prototype.uninterpretedOption = $util.emptyArray; + OneofOptions.create = function create(properties) { + return new OneofOptions(properties); + }; + OneofOptions.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.uninterpretedOption != null && m.uninterpretedOption.length) { + for (var i = 0; i < m.uninterpretedOption.length; ++i) + $root.google.protobuf.UninterpretedOption.encode( + m.uninterpretedOption[i], + w.uint32(7994).fork(), + ).ldelim(); + } + return w; + }; + OneofOptions.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.OneofOptions(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 999: + if (!(m.uninterpretedOption && m.uninterpretedOption.length)) m.uninterpretedOption = []; + m.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return OneofOptions; + })(); + protobuf.EnumOptions = (function () { + function EnumOptions(p) { + this.uninterpretedOption = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + EnumOptions.prototype.allowAlias = false; + EnumOptions.prototype.deprecated = false; + EnumOptions.prototype.uninterpretedOption = $util.emptyArray; + EnumOptions.create = function create(properties) { + return new EnumOptions(properties); + }; + EnumOptions.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.allowAlias != null && Object.hasOwnProperty.call(m, "allowAlias")) + w.uint32(16).bool(m.allowAlias); + if (m.deprecated != null && Object.hasOwnProperty.call(m, "deprecated")) + w.uint32(24).bool(m.deprecated); + if (m.uninterpretedOption != null && m.uninterpretedOption.length) { + for (var i = 0; i < m.uninterpretedOption.length; ++i) + $root.google.protobuf.UninterpretedOption.encode( + m.uninterpretedOption[i], + w.uint32(7994).fork(), + ).ldelim(); + } + return w; + }; + EnumOptions.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.EnumOptions(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 2: + m.allowAlias = r.bool(); + break; + case 3: + m.deprecated = r.bool(); + break; + case 999: + if (!(m.uninterpretedOption && m.uninterpretedOption.length)) m.uninterpretedOption = []; + m.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return EnumOptions; + })(); + protobuf.EnumValueOptions = (function () { + function EnumValueOptions(p) { + this.uninterpretedOption = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + EnumValueOptions.prototype.deprecated = false; + EnumValueOptions.prototype.uninterpretedOption = $util.emptyArray; + EnumValueOptions.create = function create(properties) { + return new EnumValueOptions(properties); + }; + EnumValueOptions.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.deprecated != null && Object.hasOwnProperty.call(m, "deprecated")) + w.uint32(8).bool(m.deprecated); + if (m.uninterpretedOption != null && m.uninterpretedOption.length) { + for (var i = 0; i < m.uninterpretedOption.length; ++i) + $root.google.protobuf.UninterpretedOption.encode( + m.uninterpretedOption[i], + w.uint32(7994).fork(), + ).ldelim(); + } + return w; + }; + EnumValueOptions.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.EnumValueOptions(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.deprecated = r.bool(); + break; + case 999: + if (!(m.uninterpretedOption && m.uninterpretedOption.length)) m.uninterpretedOption = []; + m.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return EnumValueOptions; + })(); + protobuf.ServiceOptions = (function () { + function ServiceOptions(p) { + this.uninterpretedOption = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + ServiceOptions.prototype.deprecated = false; + ServiceOptions.prototype.uninterpretedOption = $util.emptyArray; + ServiceOptions.create = function create(properties) { + return new ServiceOptions(properties); + }; + ServiceOptions.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.deprecated != null && Object.hasOwnProperty.call(m, "deprecated")) + w.uint32(264).bool(m.deprecated); + if (m.uninterpretedOption != null && m.uninterpretedOption.length) { + for (var i = 0; i < m.uninterpretedOption.length; ++i) + $root.google.protobuf.UninterpretedOption.encode( + m.uninterpretedOption[i], + w.uint32(7994).fork(), + ).ldelim(); + } + return w; + }; + ServiceOptions.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.ServiceOptions(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 33: + m.deprecated = r.bool(); + break; + case 999: + if (!(m.uninterpretedOption && m.uninterpretedOption.length)) m.uninterpretedOption = []; + m.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return ServiceOptions; + })(); + protobuf.MethodOptions = (function () { + function MethodOptions(p) { + this.uninterpretedOption = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + MethodOptions.prototype.deprecated = false; + MethodOptions.prototype.uninterpretedOption = $util.emptyArray; + MethodOptions.prototype[".google.api.http"] = null; + MethodOptions.create = function create(properties) { + return new MethodOptions(properties); + }; + MethodOptions.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.deprecated != null && Object.hasOwnProperty.call(m, "deprecated")) + w.uint32(264).bool(m.deprecated); + if (m.uninterpretedOption != null && m.uninterpretedOption.length) { + for (var i = 0; i < m.uninterpretedOption.length; ++i) + $root.google.protobuf.UninterpretedOption.encode( + m.uninterpretedOption[i], + w.uint32(7994).fork(), + ).ldelim(); + } + if (m[".google.api.http"] != null && Object.hasOwnProperty.call(m, ".google.api.http")) + $root.google.api.HttpRule.encode(m[".google.api.http"], w.uint32(578365826).fork()).ldelim(); + return w; + }; + MethodOptions.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.MethodOptions(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 33: + m.deprecated = r.bool(); + break; + case 999: + if (!(m.uninterpretedOption && m.uninterpretedOption.length)) m.uninterpretedOption = []; + m.uninterpretedOption.push($root.google.protobuf.UninterpretedOption.decode(r, r.uint32())); + break; + case 72295728: + m[".google.api.http"] = $root.google.api.HttpRule.decode(r, r.uint32()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return MethodOptions; + })(); + protobuf.UninterpretedOption = (function () { + function UninterpretedOption(p) { + this.name = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + UninterpretedOption.prototype.name = $util.emptyArray; + UninterpretedOption.prototype.identifierValue = ""; + UninterpretedOption.prototype.positiveIntValue = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + UninterpretedOption.prototype.negativeIntValue = $util.Long ? $util.Long.fromBits(0, 0, false) : 0; + UninterpretedOption.prototype.doubleValue = 0; + UninterpretedOption.prototype.stringValue = $util.newBuffer([]); + UninterpretedOption.prototype.aggregateValue = ""; + UninterpretedOption.create = function create(properties) { + return new UninterpretedOption(properties); + }; + UninterpretedOption.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.name != null && m.name.length) { + for (var i = 0; i < m.name.length; ++i) + $root.google.protobuf.UninterpretedOption.NamePart.encode( + m.name[i], + w.uint32(18).fork(), + ).ldelim(); + } + if (m.identifierValue != null && Object.hasOwnProperty.call(m, "identifierValue")) + w.uint32(26).string(m.identifierValue); + if (m.positiveIntValue != null && Object.hasOwnProperty.call(m, "positiveIntValue")) + w.uint32(32).uint64(m.positiveIntValue); + if (m.negativeIntValue != null && Object.hasOwnProperty.call(m, "negativeIntValue")) + w.uint32(40).int64(m.negativeIntValue); + if (m.doubleValue != null && Object.hasOwnProperty.call(m, "doubleValue")) + w.uint32(49).double(m.doubleValue); + if (m.stringValue != null && Object.hasOwnProperty.call(m, "stringValue")) + w.uint32(58).bytes(m.stringValue); + if (m.aggregateValue != null && Object.hasOwnProperty.call(m, "aggregateValue")) + w.uint32(66).string(m.aggregateValue); + return w; + }; + UninterpretedOption.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.UninterpretedOption(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 2: + if (!(m.name && m.name.length)) m.name = []; + m.name.push($root.google.protobuf.UninterpretedOption.NamePart.decode(r, r.uint32())); + break; + case 3: + m.identifierValue = r.string(); + break; + case 4: + m.positiveIntValue = r.uint64(); + break; + case 5: + m.negativeIntValue = r.int64(); + break; + case 6: + m.doubleValue = r.double(); + break; + case 7: + m.stringValue = r.bytes(); + break; + case 8: + m.aggregateValue = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + UninterpretedOption.NamePart = (function () { + function NamePart(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + NamePart.prototype.namePart = ""; + NamePart.prototype.isExtension = false; + NamePart.create = function create(properties) { + return new NamePart(properties); + }; + NamePart.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + w.uint32(10).string(m.namePart); + w.uint32(16).bool(m.isExtension); + return w; + }; + NamePart.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.UninterpretedOption.NamePart(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.namePart = r.string(); + break; + case 2: + m.isExtension = r.bool(); + break; + default: + r.skipType(t & 7); + break; + } + } + if (!m.hasOwnProperty("namePart")) + throw $util.ProtocolError("missing required 'namePart'", { instance: m }); + if (!m.hasOwnProperty("isExtension")) + throw $util.ProtocolError("missing required 'isExtension'", { instance: m }); + return m; + }; + return NamePart; + })(); + return UninterpretedOption; + })(); + protobuf.SourceCodeInfo = (function () { + function SourceCodeInfo(p) { + this.location = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + SourceCodeInfo.prototype.location = $util.emptyArray; + SourceCodeInfo.create = function create(properties) { + return new SourceCodeInfo(properties); + }; + SourceCodeInfo.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.location != null && m.location.length) { + for (var i = 0; i < m.location.length; ++i) + $root.google.protobuf.SourceCodeInfo.Location.encode(m.location[i], w.uint32(10).fork()).ldelim(); + } + return w; + }; + SourceCodeInfo.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.SourceCodeInfo(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.location && m.location.length)) m.location = []; + m.location.push($root.google.protobuf.SourceCodeInfo.Location.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + SourceCodeInfo.Location = (function () { + function Location(p) { + this.path = []; + this.span = []; + this.leadingDetachedComments = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Location.prototype.path = $util.emptyArray; + Location.prototype.span = $util.emptyArray; + Location.prototype.leadingComments = ""; + Location.prototype.trailingComments = ""; + Location.prototype.leadingDetachedComments = $util.emptyArray; + Location.create = function create(properties) { + return new Location(properties); + }; + Location.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.path != null && m.path.length) { + w.uint32(10).fork(); + for (var i = 0; i < m.path.length; ++i) w.int32(m.path[i]); + w.ldelim(); + } + if (m.span != null && m.span.length) { + w.uint32(18).fork(); + for (var i = 0; i < m.span.length; ++i) w.int32(m.span[i]); + w.ldelim(); + } + if (m.leadingComments != null && Object.hasOwnProperty.call(m, "leadingComments")) + w.uint32(26).string(m.leadingComments); + if (m.trailingComments != null && Object.hasOwnProperty.call(m, "trailingComments")) + w.uint32(34).string(m.trailingComments); + if (m.leadingDetachedComments != null && m.leadingDetachedComments.length) { + for (var i = 0; i < m.leadingDetachedComments.length; ++i) + w.uint32(50).string(m.leadingDetachedComments[i]); + } + return w; + }; + Location.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.SourceCodeInfo.Location(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.path && m.path.length)) m.path = []; + if ((t & 7) === 2) { + var c2 = r.uint32() + r.pos; + while (r.pos < c2) m.path.push(r.int32()); + } else m.path.push(r.int32()); + break; + case 2: + if (!(m.span && m.span.length)) m.span = []; + if ((t & 7) === 2) { + var c2 = r.uint32() + r.pos; + while (r.pos < c2) m.span.push(r.int32()); + } else m.span.push(r.int32()); + break; + case 3: + m.leadingComments = r.string(); + break; + case 4: + m.trailingComments = r.string(); + break; + case 6: + if (!(m.leadingDetachedComments && m.leadingDetachedComments.length)) + m.leadingDetachedComments = []; + m.leadingDetachedComments.push(r.string()); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Location; + })(); + return SourceCodeInfo; + })(); + protobuf.GeneratedCodeInfo = (function () { + function GeneratedCodeInfo(p) { + this.annotation = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + GeneratedCodeInfo.prototype.annotation = $util.emptyArray; + GeneratedCodeInfo.create = function create(properties) { + return new GeneratedCodeInfo(properties); + }; + GeneratedCodeInfo.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.annotation != null && m.annotation.length) { + for (var i = 0; i < m.annotation.length; ++i) + $root.google.protobuf.GeneratedCodeInfo.Annotation.encode( + m.annotation[i], + w.uint32(10).fork(), + ).ldelim(); + } + return w; + }; + GeneratedCodeInfo.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.GeneratedCodeInfo(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.annotation && m.annotation.length)) m.annotation = []; + m.annotation.push($root.google.protobuf.GeneratedCodeInfo.Annotation.decode(r, r.uint32())); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + GeneratedCodeInfo.Annotation = (function () { + function Annotation(p) { + this.path = []; + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Annotation.prototype.path = $util.emptyArray; + Annotation.prototype.sourceFile = ""; + Annotation.prototype.begin = 0; + Annotation.prototype.end = 0; + Annotation.create = function create(properties) { + return new Annotation(properties); + }; + Annotation.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.path != null && m.path.length) { + w.uint32(10).fork(); + for (var i = 0; i < m.path.length; ++i) w.int32(m.path[i]); + w.ldelim(); + } + if (m.sourceFile != null && Object.hasOwnProperty.call(m, "sourceFile")) + w.uint32(18).string(m.sourceFile); + if (m.begin != null && Object.hasOwnProperty.call(m, "begin")) w.uint32(24).int32(m.begin); + if (m.end != null && Object.hasOwnProperty.call(m, "end")) w.uint32(32).int32(m.end); + return w; + }; + Annotation.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.google.protobuf.GeneratedCodeInfo.Annotation(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + if (!(m.path && m.path.length)) m.path = []; + if ((t & 7) === 2) { + var c2 = r.uint32() + r.pos; + while (r.pos < c2) m.path.push(r.int32()); + } else m.path.push(r.int32()); + break; + case 2: + m.sourceFile = r.string(); + break; + case 3: + m.begin = r.int32(); + break; + case 4: + m.end = r.int32(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Annotation; + })(); + return GeneratedCodeInfo; + })(); + return protobuf; + })(); + return google; +})(); +exports.cosmos = $root.cosmos = (() => { + const cosmos = {}; + cosmos.base = (function () { + const base = {}; + base.v1beta1 = (function () { + const v1beta1 = {}; + v1beta1.Coin = (function () { + function Coin(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + Coin.prototype.denom = ""; + Coin.prototype.amount = ""; + Coin.create = function create(properties) { + return new Coin(properties); + }; + Coin.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.denom != null && Object.hasOwnProperty.call(m, "denom")) w.uint32(10).string(m.denom); + if (m.amount != null && Object.hasOwnProperty.call(m, "amount")) w.uint32(18).string(m.amount); + return w; + }; + Coin.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.base.v1beta1.Coin(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.denom = r.string(); + break; + case 2: + m.amount = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return Coin; + })(); + v1beta1.DecCoin = (function () { + function DecCoin(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + DecCoin.prototype.denom = ""; + DecCoin.prototype.amount = ""; + DecCoin.create = function create(properties) { + return new DecCoin(properties); + }; + DecCoin.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.denom != null && Object.hasOwnProperty.call(m, "denom")) w.uint32(10).string(m.denom); + if (m.amount != null && Object.hasOwnProperty.call(m, "amount")) w.uint32(18).string(m.amount); + return w; + }; + DecCoin.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.base.v1beta1.DecCoin(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.denom = r.string(); + break; + case 2: + m.amount = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return DecCoin; + })(); + v1beta1.IntProto = (function () { + function IntProto(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + IntProto.prototype.int = ""; + IntProto.create = function create(properties) { + return new IntProto(properties); + }; + IntProto.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.int != null && Object.hasOwnProperty.call(m, "int")) w.uint32(10).string(m.int); + return w; + }; + IntProto.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.base.v1beta1.IntProto(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.int = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return IntProto; + })(); + v1beta1.DecProto = (function () { + function DecProto(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + DecProto.prototype.dec = ""; + DecProto.create = function create(properties) { + return new DecProto(properties); + }; + DecProto.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.dec != null && Object.hasOwnProperty.call(m, "dec")) w.uint32(10).string(m.dec); + return w; + }; + DecProto.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.base.v1beta1.DecProto(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.dec = r.string(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return DecProto; + })(); + return v1beta1; + })(); + base.query = (function () { + const query = {}; + query.v1beta1 = (function () { + const v1beta1 = {}; + v1beta1.PageRequest = (function () { + function PageRequest(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + PageRequest.prototype.key = $util.newBuffer([]); + PageRequest.prototype.offset = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + PageRequest.prototype.limit = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + PageRequest.prototype.countTotal = false; + PageRequest.create = function create(properties) { + return new PageRequest(properties); + }; + PageRequest.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.key != null && Object.hasOwnProperty.call(m, "key")) w.uint32(10).bytes(m.key); + if (m.offset != null && Object.hasOwnProperty.call(m, "offset")) w.uint32(16).uint64(m.offset); + if (m.limit != null && Object.hasOwnProperty.call(m, "limit")) w.uint32(24).uint64(m.limit); + if (m.countTotal != null && Object.hasOwnProperty.call(m, "countTotal")) + w.uint32(32).bool(m.countTotal); + return w; + }; + PageRequest.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.base.query.v1beta1.PageRequest(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.key = r.bytes(); + break; + case 2: + m.offset = r.uint64(); + break; + case 3: + m.limit = r.uint64(); + break; + case 4: + m.countTotal = r.bool(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return PageRequest; + })(); + v1beta1.PageResponse = (function () { + function PageResponse(p) { + if (p) + for (var ks = Object.keys(p), i = 0; i < ks.length; ++i) + if (p[ks[i]] != null) this[ks[i]] = p[ks[i]]; + } + PageResponse.prototype.nextKey = $util.newBuffer([]); + PageResponse.prototype.total = $util.Long ? $util.Long.fromBits(0, 0, true) : 0; + PageResponse.create = function create(properties) { + return new PageResponse(properties); + }; + PageResponse.encode = function encode(m, w) { + if (!w) w = $Writer.create(); + if (m.nextKey != null && Object.hasOwnProperty.call(m, "nextKey")) w.uint32(10).bytes(m.nextKey); + if (m.total != null && Object.hasOwnProperty.call(m, "total")) w.uint32(16).uint64(m.total); + return w; + }; + PageResponse.decode = function decode(r, l) { + if (!(r instanceof $Reader)) r = $Reader.create(r); + var c = l === undefined ? r.len : r.pos + l, + m = new $root.cosmos.base.query.v1beta1.PageResponse(); + while (r.pos < c) { + var t = r.uint32(); + switch (t >>> 3) { + case 1: + m.nextKey = r.bytes(); + break; + case 2: + m.total = r.uint64(); + break; + default: + r.skipType(t & 7); + break; + } + } + return m; + }; + return PageResponse; + })(); + return v1beta1; + })(); + return query; + })(); + return base; + })(); + return cosmos; +})(); +module.exports = $root; diff --git a/packages/cosmwasm-stargate/src/codec/index.ts b/packages/cosmwasm-stargate/src/codec/index.ts new file mode 100644 index 00000000..c6204790 --- /dev/null +++ b/packages/cosmwasm-stargate/src/codec/index.ts @@ -0,0 +1,9 @@ +import Long from "long"; +import protobuf from "protobufjs/minimal"; + +// Ensure the protobuf module has a Long implementation, which otherwise only works +// in Node.js (see https://github.com/protobufjs/protobuf.js/issues/921#issuecomment-334925145) +protobuf.util.Long = Long; +protobuf.configure(); + +export { cosmwasm } from "./generated/codecimpl"; diff --git a/packages/cosmwasm-stargate/types/codec/generated/codecimpl.d.ts b/packages/cosmwasm-stargate/types/codec/generated/codecimpl.d.ts new file mode 100644 index 00000000..22d9bf39 --- /dev/null +++ b/packages/cosmwasm-stargate/types/codec/generated/codecimpl.d.ts @@ -0,0 +1,4435 @@ +import * as $protobuf from "protobufjs"; +/** Namespace cosmwasm. */ +export namespace cosmwasm { + /** Namespace wasm. */ + namespace wasm { + /** Namespace v1beta1. */ + namespace v1beta1 { + /** Properties of a MsgStoreCode. */ + interface IMsgStoreCode { + /** MsgStoreCode sender */ + sender?: string | null; + + /** MsgStoreCode wasmByteCode */ + wasmByteCode?: Uint8Array | null; + + /** MsgStoreCode source */ + source?: string | null; + + /** MsgStoreCode builder */ + builder?: string | null; + + /** MsgStoreCode instantiatePermission */ + instantiatePermission?: cosmwasm.wasm.v1beta1.IAccessConfig | null; + } + + /** Represents a MsgStoreCode. */ + class MsgStoreCode implements IMsgStoreCode { + /** + * Constructs a new MsgStoreCode. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IMsgStoreCode); + + /** MsgStoreCode sender. */ + public sender: string; + + /** MsgStoreCode wasmByteCode. */ + public wasmByteCode: Uint8Array; + + /** MsgStoreCode source. */ + public source: string; + + /** MsgStoreCode builder. */ + public builder: string; + + /** MsgStoreCode instantiatePermission. */ + public instantiatePermission?: cosmwasm.wasm.v1beta1.IAccessConfig | null; + + /** + * Creates a new MsgStoreCode instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgStoreCode instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IMsgStoreCode, + ): cosmwasm.wasm.v1beta1.MsgStoreCode; + + /** + * Encodes the specified MsgStoreCode message. Does not implicitly {@link cosmwasm.wasm.v1beta1.MsgStoreCode.verify|verify} messages. + * @param m MsgStoreCode message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmwasm.wasm.v1beta1.IMsgStoreCode, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgStoreCode message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgStoreCode + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.MsgStoreCode; + } + + /** Properties of a MsgInstantiateContract. */ + interface IMsgInstantiateContract { + /** MsgInstantiateContract sender */ + sender?: string | null; + + /** MsgInstantiateContract admin */ + admin?: string | null; + + /** MsgInstantiateContract codeId */ + codeId?: Long | null; + + /** MsgInstantiateContract label */ + label?: string | null; + + /** MsgInstantiateContract initMsg */ + initMsg?: Uint8Array | null; + + /** MsgInstantiateContract initFunds */ + initFunds?: cosmos.base.v1beta1.ICoin[] | null; + } + + /** Represents a MsgInstantiateContract. */ + class MsgInstantiateContract implements IMsgInstantiateContract { + /** + * Constructs a new MsgInstantiateContract. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IMsgInstantiateContract); + + /** MsgInstantiateContract sender. */ + public sender: string; + + /** MsgInstantiateContract admin. */ + public admin: string; + + /** MsgInstantiateContract codeId. */ + public codeId: Long; + + /** MsgInstantiateContract label. */ + public label: string; + + /** MsgInstantiateContract initMsg. */ + public initMsg: Uint8Array; + + /** MsgInstantiateContract initFunds. */ + public initFunds: cosmos.base.v1beta1.ICoin[]; + + /** + * Creates a new MsgInstantiateContract instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgInstantiateContract instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IMsgInstantiateContract, + ): cosmwasm.wasm.v1beta1.MsgInstantiateContract; + + /** + * Encodes the specified MsgInstantiateContract message. Does not implicitly {@link cosmwasm.wasm.v1beta1.MsgInstantiateContract.verify|verify} messages. + * @param m MsgInstantiateContract message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IMsgInstantiateContract, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a MsgInstantiateContract message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgInstantiateContract + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.MsgInstantiateContract; + } + + /** Properties of a MsgExecuteContract. */ + interface IMsgExecuteContract { + /** MsgExecuteContract sender */ + sender?: string | null; + + /** MsgExecuteContract contract */ + contract?: string | null; + + /** MsgExecuteContract msg */ + msg?: Uint8Array | null; + + /** MsgExecuteContract sentFunds */ + sentFunds?: cosmos.base.v1beta1.ICoin[] | null; + } + + /** Represents a MsgExecuteContract. */ + class MsgExecuteContract implements IMsgExecuteContract { + /** + * Constructs a new MsgExecuteContract. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IMsgExecuteContract); + + /** MsgExecuteContract sender. */ + public sender: string; + + /** MsgExecuteContract contract. */ + public contract: string; + + /** MsgExecuteContract msg. */ + public msg: Uint8Array; + + /** MsgExecuteContract sentFunds. */ + public sentFunds: cosmos.base.v1beta1.ICoin[]; + + /** + * Creates a new MsgExecuteContract instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgExecuteContract instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IMsgExecuteContract, + ): cosmwasm.wasm.v1beta1.MsgExecuteContract; + + /** + * Encodes the specified MsgExecuteContract message. Does not implicitly {@link cosmwasm.wasm.v1beta1.MsgExecuteContract.verify|verify} messages. + * @param m MsgExecuteContract message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IMsgExecuteContract, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a MsgExecuteContract message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgExecuteContract + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.MsgExecuteContract; + } + + /** Properties of a MsgMigrateContract. */ + interface IMsgMigrateContract { + /** MsgMigrateContract sender */ + sender?: string | null; + + /** MsgMigrateContract contract */ + contract?: string | null; + + /** MsgMigrateContract codeId */ + codeId?: Long | null; + + /** MsgMigrateContract migrateMsg */ + migrateMsg?: Uint8Array | null; + } + + /** Represents a MsgMigrateContract. */ + class MsgMigrateContract implements IMsgMigrateContract { + /** + * Constructs a new MsgMigrateContract. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IMsgMigrateContract); + + /** MsgMigrateContract sender. */ + public sender: string; + + /** MsgMigrateContract contract. */ + public contract: string; + + /** MsgMigrateContract codeId. */ + public codeId: Long; + + /** MsgMigrateContract migrateMsg. */ + public migrateMsg: Uint8Array; + + /** + * Creates a new MsgMigrateContract instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgMigrateContract instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IMsgMigrateContract, + ): cosmwasm.wasm.v1beta1.MsgMigrateContract; + + /** + * Encodes the specified MsgMigrateContract message. Does not implicitly {@link cosmwasm.wasm.v1beta1.MsgMigrateContract.verify|verify} messages. + * @param m MsgMigrateContract message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IMsgMigrateContract, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a MsgMigrateContract message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgMigrateContract + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.MsgMigrateContract; + } + + /** Properties of a MsgUpdateAdmin. */ + interface IMsgUpdateAdmin { + /** MsgUpdateAdmin sender */ + sender?: string | null; + + /** MsgUpdateAdmin newAdmin */ + newAdmin?: string | null; + + /** MsgUpdateAdmin contract */ + contract?: string | null; + } + + /** Represents a MsgUpdateAdmin. */ + class MsgUpdateAdmin implements IMsgUpdateAdmin { + /** + * Constructs a new MsgUpdateAdmin. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IMsgUpdateAdmin); + + /** MsgUpdateAdmin sender. */ + public sender: string; + + /** MsgUpdateAdmin newAdmin. */ + public newAdmin: string; + + /** MsgUpdateAdmin contract. */ + public contract: string; + + /** + * Creates a new MsgUpdateAdmin instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgUpdateAdmin instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IMsgUpdateAdmin, + ): cosmwasm.wasm.v1beta1.MsgUpdateAdmin; + + /** + * Encodes the specified MsgUpdateAdmin message. Does not implicitly {@link cosmwasm.wasm.v1beta1.MsgUpdateAdmin.verify|verify} messages. + * @param m MsgUpdateAdmin message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IMsgUpdateAdmin, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a MsgUpdateAdmin message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgUpdateAdmin + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.MsgUpdateAdmin; + } + + /** Properties of a MsgClearAdmin. */ + interface IMsgClearAdmin { + /** MsgClearAdmin sender */ + sender?: string | null; + + /** MsgClearAdmin contract */ + contract?: string | null; + } + + /** Represents a MsgClearAdmin. */ + class MsgClearAdmin implements IMsgClearAdmin { + /** + * Constructs a new MsgClearAdmin. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IMsgClearAdmin); + + /** MsgClearAdmin sender. */ + public sender: string; + + /** MsgClearAdmin contract. */ + public contract: string; + + /** + * Creates a new MsgClearAdmin instance using the specified properties. + * @param [properties] Properties to set + * @returns MsgClearAdmin instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IMsgClearAdmin, + ): cosmwasm.wasm.v1beta1.MsgClearAdmin; + + /** + * Encodes the specified MsgClearAdmin message. Does not implicitly {@link cosmwasm.wasm.v1beta1.MsgClearAdmin.verify|verify} messages. + * @param m MsgClearAdmin message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmwasm.wasm.v1beta1.IMsgClearAdmin, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MsgClearAdmin message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MsgClearAdmin + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.MsgClearAdmin; + } + + /** Represents a Query */ + class Query extends $protobuf.rpc.Service { + /** + * Constructs a new Query service. + * @param rpcImpl RPC implementation + * @param [requestDelimited=false] Whether requests are length-delimited + * @param [responseDelimited=false] Whether responses are length-delimited + */ + constructor(rpcImpl: $protobuf.RPCImpl, requestDelimited?: boolean, responseDelimited?: boolean); + + /** + * Creates new Query service using the specified rpc implementation. + * @param rpcImpl RPC implementation + * @param [requestDelimited=false] Whether requests are length-delimited + * @param [responseDelimited=false] Whether responses are length-delimited + * @returns RPC service. Useful where requests and/or responses are streamed. + */ + public static create( + rpcImpl: $protobuf.RPCImpl, + requestDelimited?: boolean, + responseDelimited?: boolean, + ): Query; + + /** + * Calls ContractInfo. + * @param request QueryContractInfoRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryContractInfoResponse + */ + public contractInfo( + request: cosmwasm.wasm.v1beta1.IQueryContractInfoRequest, + callback: cosmwasm.wasm.v1beta1.Query.ContractInfoCallback, + ): void; + + /** + * Calls ContractInfo. + * @param request QueryContractInfoRequest message or plain object + * @returns Promise + */ + public contractInfo( + request: cosmwasm.wasm.v1beta1.IQueryContractInfoRequest, + ): Promise; + + /** + * Calls ContractHistory. + * @param request QueryContractHistoryRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryContractHistoryResponse + */ + public contractHistory( + request: cosmwasm.wasm.v1beta1.IQueryContractHistoryRequest, + callback: cosmwasm.wasm.v1beta1.Query.ContractHistoryCallback, + ): void; + + /** + * Calls ContractHistory. + * @param request QueryContractHistoryRequest message or plain object + * @returns Promise + */ + public contractHistory( + request: cosmwasm.wasm.v1beta1.IQueryContractHistoryRequest, + ): Promise; + + /** + * Calls ContractsByCode. + * @param request QueryContractsByCodeRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryContractsByCodeResponse + */ + public contractsByCode( + request: cosmwasm.wasm.v1beta1.IQueryContractsByCodeRequest, + callback: cosmwasm.wasm.v1beta1.Query.ContractsByCodeCallback, + ): void; + + /** + * Calls ContractsByCode. + * @param request QueryContractsByCodeRequest message or plain object + * @returns Promise + */ + public contractsByCode( + request: cosmwasm.wasm.v1beta1.IQueryContractsByCodeRequest, + ): Promise; + + /** + * Calls AllContractState. + * @param request QueryAllContractStateRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryAllContractStateResponse + */ + public allContractState( + request: cosmwasm.wasm.v1beta1.IQueryAllContractStateRequest, + callback: cosmwasm.wasm.v1beta1.Query.AllContractStateCallback, + ): void; + + /** + * Calls AllContractState. + * @param request QueryAllContractStateRequest message or plain object + * @returns Promise + */ + public allContractState( + request: cosmwasm.wasm.v1beta1.IQueryAllContractStateRequest, + ): Promise; + + /** + * Calls RawContractState. + * @param request QueryRawContractStateRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryRawContractStateResponse + */ + public rawContractState( + request: cosmwasm.wasm.v1beta1.IQueryRawContractStateRequest, + callback: cosmwasm.wasm.v1beta1.Query.RawContractStateCallback, + ): void; + + /** + * Calls RawContractState. + * @param request QueryRawContractStateRequest message or plain object + * @returns Promise + */ + public rawContractState( + request: cosmwasm.wasm.v1beta1.IQueryRawContractStateRequest, + ): Promise; + + /** + * Calls SmartContractState. + * @param request QuerySmartContractStateRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QuerySmartContractStateResponse + */ + public smartContractState( + request: cosmwasm.wasm.v1beta1.IQuerySmartContractStateRequest, + callback: cosmwasm.wasm.v1beta1.Query.SmartContractStateCallback, + ): void; + + /** + * Calls SmartContractState. + * @param request QuerySmartContractStateRequest message or plain object + * @returns Promise + */ + public smartContractState( + request: cosmwasm.wasm.v1beta1.IQuerySmartContractStateRequest, + ): Promise; + + /** + * Calls Code. + * @param request QueryCodeRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryCodeResponse + */ + public code( + request: cosmwasm.wasm.v1beta1.IQueryCodeRequest, + callback: cosmwasm.wasm.v1beta1.Query.CodeCallback, + ): void; + + /** + * Calls Code. + * @param request QueryCodeRequest message or plain object + * @returns Promise + */ + public code( + request: cosmwasm.wasm.v1beta1.IQueryCodeRequest, + ): Promise; + + /** + * Calls Codes. + * @param request QueryCodesRequest message or plain object + * @param callback Node-style callback called with the error, if any, and QueryCodesResponse + */ + public codes( + request: cosmwasm.wasm.v1beta1.IQueryCodesRequest, + callback: cosmwasm.wasm.v1beta1.Query.CodesCallback, + ): void; + + /** + * Calls Codes. + * @param request QueryCodesRequest message or plain object + * @returns Promise + */ + public codes( + request: cosmwasm.wasm.v1beta1.IQueryCodesRequest, + ): Promise; + } + + namespace Query { + /** + * Callback as used by {@link cosmwasm.wasm.v1beta1.Query#contractInfo}. + * @param error Error, if any + * @param [response] QueryContractInfoResponse + */ + type ContractInfoCallback = ( + error: Error | null, + response?: cosmwasm.wasm.v1beta1.QueryContractInfoResponse, + ) => void; + + /** + * Callback as used by {@link cosmwasm.wasm.v1beta1.Query#contractHistory}. + * @param error Error, if any + * @param [response] QueryContractHistoryResponse + */ + type ContractHistoryCallback = ( + error: Error | null, + response?: cosmwasm.wasm.v1beta1.QueryContractHistoryResponse, + ) => void; + + /** + * Callback as used by {@link cosmwasm.wasm.v1beta1.Query#contractsByCode}. + * @param error Error, if any + * @param [response] QueryContractsByCodeResponse + */ + type ContractsByCodeCallback = ( + error: Error | null, + response?: cosmwasm.wasm.v1beta1.QueryContractsByCodeResponse, + ) => void; + + /** + * Callback as used by {@link cosmwasm.wasm.v1beta1.Query#allContractState}. + * @param error Error, if any + * @param [response] QueryAllContractStateResponse + */ + type AllContractStateCallback = ( + error: Error | null, + response?: cosmwasm.wasm.v1beta1.QueryAllContractStateResponse, + ) => void; + + /** + * Callback as used by {@link cosmwasm.wasm.v1beta1.Query#rawContractState}. + * @param error Error, if any + * @param [response] QueryRawContractStateResponse + */ + type RawContractStateCallback = ( + error: Error | null, + response?: cosmwasm.wasm.v1beta1.QueryRawContractStateResponse, + ) => void; + + /** + * Callback as used by {@link cosmwasm.wasm.v1beta1.Query#smartContractState}. + * @param error Error, if any + * @param [response] QuerySmartContractStateResponse + */ + type SmartContractStateCallback = ( + error: Error | null, + response?: cosmwasm.wasm.v1beta1.QuerySmartContractStateResponse, + ) => void; + + /** + * Callback as used by {@link cosmwasm.wasm.v1beta1.Query#code}. + * @param error Error, if any + * @param [response] QueryCodeResponse + */ + type CodeCallback = (error: Error | null, response?: cosmwasm.wasm.v1beta1.QueryCodeResponse) => void; + + /** + * Callback as used by {@link cosmwasm.wasm.v1beta1.Query#codes}. + * @param error Error, if any + * @param [response] QueryCodesResponse + */ + type CodesCallback = ( + error: Error | null, + response?: cosmwasm.wasm.v1beta1.QueryCodesResponse, + ) => void; + } + + /** Properties of a QueryContractInfoRequest. */ + interface IQueryContractInfoRequest { + /** QueryContractInfoRequest address */ + address?: string | null; + } + + /** Represents a QueryContractInfoRequest. */ + class QueryContractInfoRequest implements IQueryContractInfoRequest { + /** + * Constructs a new QueryContractInfoRequest. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryContractInfoRequest); + + /** QueryContractInfoRequest address. */ + public address: string; + + /** + * Creates a new QueryContractInfoRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryContractInfoRequest instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryContractInfoRequest, + ): cosmwasm.wasm.v1beta1.QueryContractInfoRequest; + + /** + * Encodes the specified QueryContractInfoRequest message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryContractInfoRequest.verify|verify} messages. + * @param m QueryContractInfoRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryContractInfoRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryContractInfoRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryContractInfoRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryContractInfoRequest; + } + + /** Properties of a QueryContractInfoResponse. */ + interface IQueryContractInfoResponse { + /** QueryContractInfoResponse address */ + address?: string | null; + + /** QueryContractInfoResponse contractInfo */ + contractInfo?: cosmwasm.wasm.v1beta1.IContractInfo | null; + } + + /** Represents a QueryContractInfoResponse. */ + class QueryContractInfoResponse implements IQueryContractInfoResponse { + /** + * Constructs a new QueryContractInfoResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryContractInfoResponse); + + /** QueryContractInfoResponse address. */ + public address: string; + + /** QueryContractInfoResponse contractInfo. */ + public contractInfo?: cosmwasm.wasm.v1beta1.IContractInfo | null; + + /** + * Creates a new QueryContractInfoResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryContractInfoResponse instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryContractInfoResponse, + ): cosmwasm.wasm.v1beta1.QueryContractInfoResponse; + + /** + * Encodes the specified QueryContractInfoResponse message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryContractInfoResponse.verify|verify} messages. + * @param m QueryContractInfoResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryContractInfoResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryContractInfoResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryContractInfoResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryContractInfoResponse; + } + + /** Properties of a QueryContractHistoryRequest. */ + interface IQueryContractHistoryRequest { + /** QueryContractHistoryRequest address */ + address?: string | null; + + /** QueryContractHistoryRequest pagination */ + pagination?: cosmos.base.query.v1beta1.IPageRequest | null; + } + + /** Represents a QueryContractHistoryRequest. */ + class QueryContractHistoryRequest implements IQueryContractHistoryRequest { + /** + * Constructs a new QueryContractHistoryRequest. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryContractHistoryRequest); + + /** QueryContractHistoryRequest address. */ + public address: string; + + /** QueryContractHistoryRequest pagination. */ + public pagination?: cosmos.base.query.v1beta1.IPageRequest | null; + + /** + * Creates a new QueryContractHistoryRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryContractHistoryRequest instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryContractHistoryRequest, + ): cosmwasm.wasm.v1beta1.QueryContractHistoryRequest; + + /** + * Encodes the specified QueryContractHistoryRequest message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryContractHistoryRequest.verify|verify} messages. + * @param m QueryContractHistoryRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryContractHistoryRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryContractHistoryRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryContractHistoryRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryContractHistoryRequest; + } + + /** Properties of a QueryContractHistoryResponse. */ + interface IQueryContractHistoryResponse { + /** QueryContractHistoryResponse entries */ + entries?: cosmwasm.wasm.v1beta1.IContractCodeHistoryEntry[] | null; + + /** QueryContractHistoryResponse pagination */ + pagination?: cosmos.base.query.v1beta1.IPageResponse | null; + } + + /** Represents a QueryContractHistoryResponse. */ + class QueryContractHistoryResponse implements IQueryContractHistoryResponse { + /** + * Constructs a new QueryContractHistoryResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryContractHistoryResponse); + + /** QueryContractHistoryResponse entries. */ + public entries: cosmwasm.wasm.v1beta1.IContractCodeHistoryEntry[]; + + /** QueryContractHistoryResponse pagination. */ + public pagination?: cosmos.base.query.v1beta1.IPageResponse | null; + + /** + * Creates a new QueryContractHistoryResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryContractHistoryResponse instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryContractHistoryResponse, + ): cosmwasm.wasm.v1beta1.QueryContractHistoryResponse; + + /** + * Encodes the specified QueryContractHistoryResponse message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryContractHistoryResponse.verify|verify} messages. + * @param m QueryContractHistoryResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryContractHistoryResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryContractHistoryResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryContractHistoryResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryContractHistoryResponse; + } + + /** Properties of a QueryContractsByCodeRequest. */ + interface IQueryContractsByCodeRequest { + /** QueryContractsByCodeRequest codeId */ + codeId?: Long | null; + + /** QueryContractsByCodeRequest pagination */ + pagination?: cosmos.base.query.v1beta1.IPageRequest | null; + } + + /** Represents a QueryContractsByCodeRequest. */ + class QueryContractsByCodeRequest implements IQueryContractsByCodeRequest { + /** + * Constructs a new QueryContractsByCodeRequest. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryContractsByCodeRequest); + + /** QueryContractsByCodeRequest codeId. */ + public codeId: Long; + + /** QueryContractsByCodeRequest pagination. */ + public pagination?: cosmos.base.query.v1beta1.IPageRequest | null; + + /** + * Creates a new QueryContractsByCodeRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryContractsByCodeRequest instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryContractsByCodeRequest, + ): cosmwasm.wasm.v1beta1.QueryContractsByCodeRequest; + + /** + * Encodes the specified QueryContractsByCodeRequest message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryContractsByCodeRequest.verify|verify} messages. + * @param m QueryContractsByCodeRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryContractsByCodeRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryContractsByCodeRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryContractsByCodeRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryContractsByCodeRequest; + } + + /** Properties of a ContractInfoWithAddress. */ + interface IContractInfoWithAddress { + /** ContractInfoWithAddress address */ + address?: string | null; + + /** ContractInfoWithAddress contractInfo */ + contractInfo?: cosmwasm.wasm.v1beta1.IContractInfo | null; + } + + /** Represents a ContractInfoWithAddress. */ + class ContractInfoWithAddress implements IContractInfoWithAddress { + /** + * Constructs a new ContractInfoWithAddress. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IContractInfoWithAddress); + + /** ContractInfoWithAddress address. */ + public address: string; + + /** ContractInfoWithAddress contractInfo. */ + public contractInfo?: cosmwasm.wasm.v1beta1.IContractInfo | null; + + /** + * Creates a new ContractInfoWithAddress instance using the specified properties. + * @param [properties] Properties to set + * @returns ContractInfoWithAddress instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IContractInfoWithAddress, + ): cosmwasm.wasm.v1beta1.ContractInfoWithAddress; + + /** + * Encodes the specified ContractInfoWithAddress message. Does not implicitly {@link cosmwasm.wasm.v1beta1.ContractInfoWithAddress.verify|verify} messages. + * @param m ContractInfoWithAddress message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IContractInfoWithAddress, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a ContractInfoWithAddress message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ContractInfoWithAddress + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.ContractInfoWithAddress; + } + + /** Properties of a QueryContractsByCodeResponse. */ + interface IQueryContractsByCodeResponse { + /** QueryContractsByCodeResponse contractInfos */ + contractInfos?: cosmwasm.wasm.v1beta1.IContractInfoWithAddress[] | null; + + /** QueryContractsByCodeResponse pagination */ + pagination?: cosmos.base.query.v1beta1.IPageResponse | null; + } + + /** Represents a QueryContractsByCodeResponse. */ + class QueryContractsByCodeResponse implements IQueryContractsByCodeResponse { + /** + * Constructs a new QueryContractsByCodeResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryContractsByCodeResponse); + + /** QueryContractsByCodeResponse contractInfos. */ + public contractInfos: cosmwasm.wasm.v1beta1.IContractInfoWithAddress[]; + + /** QueryContractsByCodeResponse pagination. */ + public pagination?: cosmos.base.query.v1beta1.IPageResponse | null; + + /** + * Creates a new QueryContractsByCodeResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryContractsByCodeResponse instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryContractsByCodeResponse, + ): cosmwasm.wasm.v1beta1.QueryContractsByCodeResponse; + + /** + * Encodes the specified QueryContractsByCodeResponse message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryContractsByCodeResponse.verify|verify} messages. + * @param m QueryContractsByCodeResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryContractsByCodeResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryContractsByCodeResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryContractsByCodeResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryContractsByCodeResponse; + } + + /** Properties of a QueryAllContractStateRequest. */ + interface IQueryAllContractStateRequest { + /** QueryAllContractStateRequest address */ + address?: string | null; + + /** QueryAllContractStateRequest pagination */ + pagination?: cosmos.base.query.v1beta1.IPageRequest | null; + } + + /** Represents a QueryAllContractStateRequest. */ + class QueryAllContractStateRequest implements IQueryAllContractStateRequest { + /** + * Constructs a new QueryAllContractStateRequest. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryAllContractStateRequest); + + /** QueryAllContractStateRequest address. */ + public address: string; + + /** QueryAllContractStateRequest pagination. */ + public pagination?: cosmos.base.query.v1beta1.IPageRequest | null; + + /** + * Creates a new QueryAllContractStateRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryAllContractStateRequest instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryAllContractStateRequest, + ): cosmwasm.wasm.v1beta1.QueryAllContractStateRequest; + + /** + * Encodes the specified QueryAllContractStateRequest message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryAllContractStateRequest.verify|verify} messages. + * @param m QueryAllContractStateRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryAllContractStateRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryAllContractStateRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryAllContractStateRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryAllContractStateRequest; + } + + /** Properties of a QueryAllContractStateResponse. */ + interface IQueryAllContractStateResponse { + /** QueryAllContractStateResponse models */ + models?: cosmwasm.wasm.v1beta1.IModel[] | null; + + /** QueryAllContractStateResponse pagination */ + pagination?: cosmos.base.query.v1beta1.IPageResponse | null; + } + + /** Represents a QueryAllContractStateResponse. */ + class QueryAllContractStateResponse implements IQueryAllContractStateResponse { + /** + * Constructs a new QueryAllContractStateResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryAllContractStateResponse); + + /** QueryAllContractStateResponse models. */ + public models: cosmwasm.wasm.v1beta1.IModel[]; + + /** QueryAllContractStateResponse pagination. */ + public pagination?: cosmos.base.query.v1beta1.IPageResponse | null; + + /** + * Creates a new QueryAllContractStateResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryAllContractStateResponse instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryAllContractStateResponse, + ): cosmwasm.wasm.v1beta1.QueryAllContractStateResponse; + + /** + * Encodes the specified QueryAllContractStateResponse message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryAllContractStateResponse.verify|verify} messages. + * @param m QueryAllContractStateResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryAllContractStateResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryAllContractStateResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryAllContractStateResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryAllContractStateResponse; + } + + /** Properties of a QueryRawContractStateRequest. */ + interface IQueryRawContractStateRequest { + /** QueryRawContractStateRequest address */ + address?: string | null; + + /** QueryRawContractStateRequest queryData */ + queryData?: Uint8Array | null; + } + + /** Represents a QueryRawContractStateRequest. */ + class QueryRawContractStateRequest implements IQueryRawContractStateRequest { + /** + * Constructs a new QueryRawContractStateRequest. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryRawContractStateRequest); + + /** QueryRawContractStateRequest address. */ + public address: string; + + /** QueryRawContractStateRequest queryData. */ + public queryData: Uint8Array; + + /** + * Creates a new QueryRawContractStateRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryRawContractStateRequest instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryRawContractStateRequest, + ): cosmwasm.wasm.v1beta1.QueryRawContractStateRequest; + + /** + * Encodes the specified QueryRawContractStateRequest message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryRawContractStateRequest.verify|verify} messages. + * @param m QueryRawContractStateRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryRawContractStateRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryRawContractStateRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryRawContractStateRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryRawContractStateRequest; + } + + /** Properties of a QueryRawContractStateResponse. */ + interface IQueryRawContractStateResponse { + /** QueryRawContractStateResponse data */ + data?: Uint8Array | null; + } + + /** Represents a QueryRawContractStateResponse. */ + class QueryRawContractStateResponse implements IQueryRawContractStateResponse { + /** + * Constructs a new QueryRawContractStateResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryRawContractStateResponse); + + /** QueryRawContractStateResponse data. */ + public data: Uint8Array; + + /** + * Creates a new QueryRawContractStateResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryRawContractStateResponse instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryRawContractStateResponse, + ): cosmwasm.wasm.v1beta1.QueryRawContractStateResponse; + + /** + * Encodes the specified QueryRawContractStateResponse message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryRawContractStateResponse.verify|verify} messages. + * @param m QueryRawContractStateResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryRawContractStateResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryRawContractStateResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryRawContractStateResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryRawContractStateResponse; + } + + /** Properties of a QuerySmartContractStateRequest. */ + interface IQuerySmartContractStateRequest { + /** QuerySmartContractStateRequest address */ + address?: string | null; + + /** QuerySmartContractStateRequest queryData */ + queryData?: Uint8Array | null; + } + + /** Represents a QuerySmartContractStateRequest. */ + class QuerySmartContractStateRequest implements IQuerySmartContractStateRequest { + /** + * Constructs a new QuerySmartContractStateRequest. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQuerySmartContractStateRequest); + + /** QuerySmartContractStateRequest address. */ + public address: string; + + /** QuerySmartContractStateRequest queryData. */ + public queryData: Uint8Array; + + /** + * Creates a new QuerySmartContractStateRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QuerySmartContractStateRequest instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQuerySmartContractStateRequest, + ): cosmwasm.wasm.v1beta1.QuerySmartContractStateRequest; + + /** + * Encodes the specified QuerySmartContractStateRequest message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QuerySmartContractStateRequest.verify|verify} messages. + * @param m QuerySmartContractStateRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQuerySmartContractStateRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QuerySmartContractStateRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QuerySmartContractStateRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QuerySmartContractStateRequest; + } + + /** Properties of a QuerySmartContractStateResponse. */ + interface IQuerySmartContractStateResponse { + /** QuerySmartContractStateResponse data */ + data?: Uint8Array | null; + } + + /** Represents a QuerySmartContractStateResponse. */ + class QuerySmartContractStateResponse implements IQuerySmartContractStateResponse { + /** + * Constructs a new QuerySmartContractStateResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQuerySmartContractStateResponse); + + /** QuerySmartContractStateResponse data. */ + public data: Uint8Array; + + /** + * Creates a new QuerySmartContractStateResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QuerySmartContractStateResponse instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQuerySmartContractStateResponse, + ): cosmwasm.wasm.v1beta1.QuerySmartContractStateResponse; + + /** + * Encodes the specified QuerySmartContractStateResponse message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QuerySmartContractStateResponse.verify|verify} messages. + * @param m QuerySmartContractStateResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQuerySmartContractStateResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QuerySmartContractStateResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QuerySmartContractStateResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QuerySmartContractStateResponse; + } + + /** Properties of a QueryCodeRequest. */ + interface IQueryCodeRequest { + /** QueryCodeRequest codeId */ + codeId?: Long | null; + } + + /** Represents a QueryCodeRequest. */ + class QueryCodeRequest implements IQueryCodeRequest { + /** + * Constructs a new QueryCodeRequest. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryCodeRequest); + + /** QueryCodeRequest codeId. */ + public codeId: Long; + + /** + * Creates a new QueryCodeRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryCodeRequest instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryCodeRequest, + ): cosmwasm.wasm.v1beta1.QueryCodeRequest; + + /** + * Encodes the specified QueryCodeRequest message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryCodeRequest.verify|verify} messages. + * @param m QueryCodeRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryCodeRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryCodeRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryCodeRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryCodeRequest; + } + + /** Properties of a CodeInfoResponse. */ + interface ICodeInfoResponse { + /** CodeInfoResponse codeId */ + codeId?: Long | null; + + /** CodeInfoResponse creator */ + creator?: string | null; + + /** CodeInfoResponse dataHash */ + dataHash?: Uint8Array | null; + + /** CodeInfoResponse source */ + source?: string | null; + + /** CodeInfoResponse builder */ + builder?: string | null; + } + + /** Represents a CodeInfoResponse. */ + class CodeInfoResponse implements ICodeInfoResponse { + /** + * Constructs a new CodeInfoResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.ICodeInfoResponse); + + /** CodeInfoResponse codeId. */ + public codeId: Long; + + /** CodeInfoResponse creator. */ + public creator: string; + + /** CodeInfoResponse dataHash. */ + public dataHash: Uint8Array; + + /** CodeInfoResponse source. */ + public source: string; + + /** CodeInfoResponse builder. */ + public builder: string; + + /** + * Creates a new CodeInfoResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns CodeInfoResponse instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.ICodeInfoResponse, + ): cosmwasm.wasm.v1beta1.CodeInfoResponse; + + /** + * Encodes the specified CodeInfoResponse message. Does not implicitly {@link cosmwasm.wasm.v1beta1.CodeInfoResponse.verify|verify} messages. + * @param m CodeInfoResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.ICodeInfoResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a CodeInfoResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns CodeInfoResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.CodeInfoResponse; + } + + /** Properties of a QueryCodeResponse. */ + interface IQueryCodeResponse { + /** QueryCodeResponse codeInfo */ + codeInfo?: cosmwasm.wasm.v1beta1.ICodeInfoResponse | null; + + /** QueryCodeResponse data */ + data?: Uint8Array | null; + } + + /** Represents a QueryCodeResponse. */ + class QueryCodeResponse implements IQueryCodeResponse { + /** + * Constructs a new QueryCodeResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryCodeResponse); + + /** QueryCodeResponse codeInfo. */ + public codeInfo?: cosmwasm.wasm.v1beta1.ICodeInfoResponse | null; + + /** QueryCodeResponse data. */ + public data: Uint8Array; + + /** + * Creates a new QueryCodeResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryCodeResponse instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryCodeResponse, + ): cosmwasm.wasm.v1beta1.QueryCodeResponse; + + /** + * Encodes the specified QueryCodeResponse message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryCodeResponse.verify|verify} messages. + * @param m QueryCodeResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryCodeResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryCodeResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryCodeResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryCodeResponse; + } + + /** Properties of a QueryCodesRequest. */ + interface IQueryCodesRequest { + /** QueryCodesRequest pagination */ + pagination?: cosmos.base.query.v1beta1.IPageRequest | null; + } + + /** Represents a QueryCodesRequest. */ + class QueryCodesRequest implements IQueryCodesRequest { + /** + * Constructs a new QueryCodesRequest. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryCodesRequest); + + /** QueryCodesRequest pagination. */ + public pagination?: cosmos.base.query.v1beta1.IPageRequest | null; + + /** + * Creates a new QueryCodesRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryCodesRequest instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryCodesRequest, + ): cosmwasm.wasm.v1beta1.QueryCodesRequest; + + /** + * Encodes the specified QueryCodesRequest message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryCodesRequest.verify|verify} messages. + * @param m QueryCodesRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryCodesRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryCodesRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryCodesRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryCodesRequest; + } + + /** Properties of a QueryCodesResponse. */ + interface IQueryCodesResponse { + /** QueryCodesResponse codeInfos */ + codeInfos?: cosmwasm.wasm.v1beta1.ICodeInfoResponse[] | null; + + /** QueryCodesResponse pagination */ + pagination?: cosmos.base.query.v1beta1.IPageResponse | null; + } + + /** Represents a QueryCodesResponse. */ + class QueryCodesResponse implements IQueryCodesResponse { + /** + * Constructs a new QueryCodesResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IQueryCodesResponse); + + /** QueryCodesResponse codeInfos. */ + public codeInfos: cosmwasm.wasm.v1beta1.ICodeInfoResponse[]; + + /** QueryCodesResponse pagination. */ + public pagination?: cosmos.base.query.v1beta1.IPageResponse | null; + + /** + * Creates a new QueryCodesResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns QueryCodesResponse instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IQueryCodesResponse, + ): cosmwasm.wasm.v1beta1.QueryCodesResponse; + + /** + * Encodes the specified QueryCodesResponse message. Does not implicitly {@link cosmwasm.wasm.v1beta1.QueryCodesResponse.verify|verify} messages. + * @param m QueryCodesResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IQueryCodesResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a QueryCodesResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns QueryCodesResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.QueryCodesResponse; + } + + /** AccessType enum. */ + enum AccessType { + ACCESS_TYPE_UNSPECIFIED = 0, + ACCESS_TYPE_NOBODY = 1, + ACCESS_TYPE_ONLY_ADDRESS = 2, + ACCESS_TYPE_EVERYBODY = 3, + } + + /** Properties of an AccessTypeParam. */ + interface IAccessTypeParam { + /** AccessTypeParam value */ + value?: cosmwasm.wasm.v1beta1.AccessType | null; + } + + /** Represents an AccessTypeParam. */ + class AccessTypeParam implements IAccessTypeParam { + /** + * Constructs a new AccessTypeParam. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IAccessTypeParam); + + /** AccessTypeParam value. */ + public value: cosmwasm.wasm.v1beta1.AccessType; + + /** + * Creates a new AccessTypeParam instance using the specified properties. + * @param [properties] Properties to set + * @returns AccessTypeParam instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IAccessTypeParam, + ): cosmwasm.wasm.v1beta1.AccessTypeParam; + + /** + * Encodes the specified AccessTypeParam message. Does not implicitly {@link cosmwasm.wasm.v1beta1.AccessTypeParam.verify|verify} messages. + * @param m AccessTypeParam message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IAccessTypeParam, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes an AccessTypeParam message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns AccessTypeParam + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.AccessTypeParam; + } + + /** Properties of an AccessConfig. */ + interface IAccessConfig { + /** AccessConfig permission */ + permission?: cosmwasm.wasm.v1beta1.AccessType | null; + + /** AccessConfig address */ + address?: string | null; + } + + /** Represents an AccessConfig. */ + class AccessConfig implements IAccessConfig { + /** + * Constructs a new AccessConfig. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IAccessConfig); + + /** AccessConfig permission. */ + public permission: cosmwasm.wasm.v1beta1.AccessType; + + /** AccessConfig address. */ + public address: string; + + /** + * Creates a new AccessConfig instance using the specified properties. + * @param [properties] Properties to set + * @returns AccessConfig instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IAccessConfig, + ): cosmwasm.wasm.v1beta1.AccessConfig; + + /** + * Encodes the specified AccessConfig message. Does not implicitly {@link cosmwasm.wasm.v1beta1.AccessConfig.verify|verify} messages. + * @param m AccessConfig message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmwasm.wasm.v1beta1.IAccessConfig, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an AccessConfig message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns AccessConfig + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.AccessConfig; + } + + /** Properties of a Params. */ + interface IParams { + /** Params codeUploadAccess */ + codeUploadAccess?: cosmwasm.wasm.v1beta1.IAccessConfig | null; + + /** Params instantiateDefaultPermission */ + instantiateDefaultPermission?: cosmwasm.wasm.v1beta1.AccessType | null; + + /** Params maxWasmCodeSize */ + maxWasmCodeSize?: Long | null; + } + + /** Represents a Params. */ + class Params implements IParams { + /** + * Constructs a new Params. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IParams); + + /** Params codeUploadAccess. */ + public codeUploadAccess?: cosmwasm.wasm.v1beta1.IAccessConfig | null; + + /** Params instantiateDefaultPermission. */ + public instantiateDefaultPermission: cosmwasm.wasm.v1beta1.AccessType; + + /** Params maxWasmCodeSize. */ + public maxWasmCodeSize: Long; + + /** + * Creates a new Params instance using the specified properties. + * @param [properties] Properties to set + * @returns Params instance + */ + public static create(properties?: cosmwasm.wasm.v1beta1.IParams): cosmwasm.wasm.v1beta1.Params; + + /** + * Encodes the specified Params message. Does not implicitly {@link cosmwasm.wasm.v1beta1.Params.verify|verify} messages. + * @param m Params message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmwasm.wasm.v1beta1.IParams, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Params message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Params + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmwasm.wasm.v1beta1.Params; + } + + /** Properties of a CodeInfo. */ + interface ICodeInfo { + /** CodeInfo codeHash */ + codeHash?: Uint8Array | null; + + /** CodeInfo creator */ + creator?: string | null; + + /** CodeInfo source */ + source?: string | null; + + /** CodeInfo builder */ + builder?: string | null; + + /** CodeInfo instantiateConfig */ + instantiateConfig?: cosmwasm.wasm.v1beta1.IAccessConfig | null; + } + + /** Represents a CodeInfo. */ + class CodeInfo implements ICodeInfo { + /** + * Constructs a new CodeInfo. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.ICodeInfo); + + /** CodeInfo codeHash. */ + public codeHash: Uint8Array; + + /** CodeInfo creator. */ + public creator: string; + + /** CodeInfo source. */ + public source: string; + + /** CodeInfo builder. */ + public builder: string; + + /** CodeInfo instantiateConfig. */ + public instantiateConfig?: cosmwasm.wasm.v1beta1.IAccessConfig | null; + + /** + * Creates a new CodeInfo instance using the specified properties. + * @param [properties] Properties to set + * @returns CodeInfo instance + */ + public static create(properties?: cosmwasm.wasm.v1beta1.ICodeInfo): cosmwasm.wasm.v1beta1.CodeInfo; + + /** + * Encodes the specified CodeInfo message. Does not implicitly {@link cosmwasm.wasm.v1beta1.CodeInfo.verify|verify} messages. + * @param m CodeInfo message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmwasm.wasm.v1beta1.ICodeInfo, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a CodeInfo message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns CodeInfo + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmwasm.wasm.v1beta1.CodeInfo; + } + + /** Properties of a ContractInfo. */ + interface IContractInfo { + /** ContractInfo codeId */ + codeId?: Long | null; + + /** ContractInfo creator */ + creator?: string | null; + + /** ContractInfo admin */ + admin?: string | null; + + /** ContractInfo label */ + label?: string | null; + + /** ContractInfo created */ + created?: cosmwasm.wasm.v1beta1.IAbsoluteTxPosition | null; + } + + /** Represents a ContractInfo. */ + class ContractInfo implements IContractInfo { + /** + * Constructs a new ContractInfo. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IContractInfo); + + /** ContractInfo codeId. */ + public codeId: Long; + + /** ContractInfo creator. */ + public creator: string; + + /** ContractInfo admin. */ + public admin: string; + + /** ContractInfo label. */ + public label: string; + + /** ContractInfo created. */ + public created?: cosmwasm.wasm.v1beta1.IAbsoluteTxPosition | null; + + /** + * Creates a new ContractInfo instance using the specified properties. + * @param [properties] Properties to set + * @returns ContractInfo instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IContractInfo, + ): cosmwasm.wasm.v1beta1.ContractInfo; + + /** + * Encodes the specified ContractInfo message. Does not implicitly {@link cosmwasm.wasm.v1beta1.ContractInfo.verify|verify} messages. + * @param m ContractInfo message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmwasm.wasm.v1beta1.IContractInfo, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a ContractInfo message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ContractInfo + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.ContractInfo; + } + + /** ContractCodeHistoryOperationType enum. */ + enum ContractCodeHistoryOperationType { + CONTRACT_CODE_HISTORY_OPERATION_TYPE_UNSPECIFIED = 0, + CONTRACT_CODE_HISTORY_OPERATION_TYPE_INIT = 1, + CONTRACT_CODE_HISTORY_OPERATION_TYPE_MIGRATE = 2, + CONTRACT_CODE_HISTORY_OPERATION_TYPE_GENESIS = 3, + } + + /** Properties of a ContractCodeHistoryEntry. */ + interface IContractCodeHistoryEntry { + /** ContractCodeHistoryEntry operation */ + operation?: cosmwasm.wasm.v1beta1.ContractCodeHistoryOperationType | null; + + /** ContractCodeHistoryEntry codeId */ + codeId?: Long | null; + + /** ContractCodeHistoryEntry updated */ + updated?: cosmwasm.wasm.v1beta1.IAbsoluteTxPosition | null; + + /** ContractCodeHistoryEntry msg */ + msg?: Uint8Array | null; + } + + /** Represents a ContractCodeHistoryEntry. */ + class ContractCodeHistoryEntry implements IContractCodeHistoryEntry { + /** + * Constructs a new ContractCodeHistoryEntry. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IContractCodeHistoryEntry); + + /** ContractCodeHistoryEntry operation. */ + public operation: cosmwasm.wasm.v1beta1.ContractCodeHistoryOperationType; + + /** ContractCodeHistoryEntry codeId. */ + public codeId: Long; + + /** ContractCodeHistoryEntry updated. */ + public updated?: cosmwasm.wasm.v1beta1.IAbsoluteTxPosition | null; + + /** ContractCodeHistoryEntry msg. */ + public msg: Uint8Array; + + /** + * Creates a new ContractCodeHistoryEntry instance using the specified properties. + * @param [properties] Properties to set + * @returns ContractCodeHistoryEntry instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IContractCodeHistoryEntry, + ): cosmwasm.wasm.v1beta1.ContractCodeHistoryEntry; + + /** + * Encodes the specified ContractCodeHistoryEntry message. Does not implicitly {@link cosmwasm.wasm.v1beta1.ContractCodeHistoryEntry.verify|verify} messages. + * @param m ContractCodeHistoryEntry message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IContractCodeHistoryEntry, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a ContractCodeHistoryEntry message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ContractCodeHistoryEntry + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.ContractCodeHistoryEntry; + } + + /** Properties of an AbsoluteTxPosition. */ + interface IAbsoluteTxPosition { + /** AbsoluteTxPosition blockHeight */ + blockHeight?: Long | null; + + /** AbsoluteTxPosition txIndex */ + txIndex?: Long | null; + } + + /** Represents an AbsoluteTxPosition. */ + class AbsoluteTxPosition implements IAbsoluteTxPosition { + /** + * Constructs a new AbsoluteTxPosition. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IAbsoluteTxPosition); + + /** AbsoluteTxPosition blockHeight. */ + public blockHeight: Long; + + /** AbsoluteTxPosition txIndex. */ + public txIndex: Long; + + /** + * Creates a new AbsoluteTxPosition instance using the specified properties. + * @param [properties] Properties to set + * @returns AbsoluteTxPosition instance + */ + public static create( + properties?: cosmwasm.wasm.v1beta1.IAbsoluteTxPosition, + ): cosmwasm.wasm.v1beta1.AbsoluteTxPosition; + + /** + * Encodes the specified AbsoluteTxPosition message. Does not implicitly {@link cosmwasm.wasm.v1beta1.AbsoluteTxPosition.verify|verify} messages. + * @param m AbsoluteTxPosition message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmwasm.wasm.v1beta1.IAbsoluteTxPosition, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes an AbsoluteTxPosition message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns AbsoluteTxPosition + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmwasm.wasm.v1beta1.AbsoluteTxPosition; + } + + /** Properties of a Model. */ + interface IModel { + /** Model key */ + key?: Uint8Array | null; + + /** Model value */ + value?: Uint8Array | null; + } + + /** Represents a Model. */ + class Model implements IModel { + /** + * Constructs a new Model. + * @param [p] Properties to set + */ + constructor(p?: cosmwasm.wasm.v1beta1.IModel); + + /** Model key. */ + public key: Uint8Array; + + /** Model value. */ + public value: Uint8Array; + + /** + * Creates a new Model instance using the specified properties. + * @param [properties] Properties to set + * @returns Model instance + */ + public static create(properties?: cosmwasm.wasm.v1beta1.IModel): cosmwasm.wasm.v1beta1.Model; + + /** + * Encodes the specified Model message. Does not implicitly {@link cosmwasm.wasm.v1beta1.Model.verify|verify} messages. + * @param m Model message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmwasm.wasm.v1beta1.IModel, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Model message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Model + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmwasm.wasm.v1beta1.Model; + } + } + } +} + +/** Namespace google. */ +export namespace google { + /** Namespace api. */ + namespace api { + /** Properties of a Http. */ + interface IHttp { + /** Http rules */ + rules?: google.api.IHttpRule[] | null; + } + + /** Represents a Http. */ + class Http implements IHttp { + /** + * Constructs a new Http. + * @param [p] Properties to set + */ + constructor(p?: google.api.IHttp); + + /** Http rules. */ + public rules: google.api.IHttpRule[]; + + /** + * Creates a new Http instance using the specified properties. + * @param [properties] Properties to set + * @returns Http instance + */ + public static create(properties?: google.api.IHttp): google.api.Http; + + /** + * Encodes the specified Http message. Does not implicitly {@link google.api.Http.verify|verify} messages. + * @param m Http message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.api.IHttp, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Http message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Http + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.api.Http; + } + + /** Properties of a HttpRule. */ + interface IHttpRule { + /** HttpRule get */ + get?: string | null; + + /** HttpRule put */ + put?: string | null; + + /** HttpRule post */ + post?: string | null; + + /** HttpRule delete */ + delete?: string | null; + + /** HttpRule patch */ + patch?: string | null; + + /** HttpRule custom */ + custom?: google.api.ICustomHttpPattern | null; + + /** HttpRule selector */ + selector?: string | null; + + /** HttpRule body */ + body?: string | null; + + /** HttpRule additionalBindings */ + additionalBindings?: google.api.IHttpRule[] | null; + } + + /** Represents a HttpRule. */ + class HttpRule implements IHttpRule { + /** + * Constructs a new HttpRule. + * @param [p] Properties to set + */ + constructor(p?: google.api.IHttpRule); + + /** HttpRule get. */ + public get: string; + + /** HttpRule put. */ + public put: string; + + /** HttpRule post. */ + public post: string; + + /** HttpRule delete. */ + public delete: string; + + /** HttpRule patch. */ + public patch: string; + + /** HttpRule custom. */ + public custom?: google.api.ICustomHttpPattern | null; + + /** HttpRule selector. */ + public selector: string; + + /** HttpRule body. */ + public body: string; + + /** HttpRule additionalBindings. */ + public additionalBindings: google.api.IHttpRule[]; + + /** HttpRule pattern. */ + public pattern?: "get" | "put" | "post" | "delete" | "patch" | "custom"; + + /** + * Creates a new HttpRule instance using the specified properties. + * @param [properties] Properties to set + * @returns HttpRule instance + */ + public static create(properties?: google.api.IHttpRule): google.api.HttpRule; + + /** + * Encodes the specified HttpRule message. Does not implicitly {@link google.api.HttpRule.verify|verify} messages. + * @param m HttpRule message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.api.IHttpRule, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a HttpRule message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns HttpRule + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.api.HttpRule; + } + + /** Properties of a CustomHttpPattern. */ + interface ICustomHttpPattern { + /** CustomHttpPattern kind */ + kind?: string | null; + + /** CustomHttpPattern path */ + path?: string | null; + } + + /** Represents a CustomHttpPattern. */ + class CustomHttpPattern implements ICustomHttpPattern { + /** + * Constructs a new CustomHttpPattern. + * @param [p] Properties to set + */ + constructor(p?: google.api.ICustomHttpPattern); + + /** CustomHttpPattern kind. */ + public kind: string; + + /** CustomHttpPattern path. */ + public path: string; + + /** + * Creates a new CustomHttpPattern instance using the specified properties. + * @param [properties] Properties to set + * @returns CustomHttpPattern instance + */ + public static create(properties?: google.api.ICustomHttpPattern): google.api.CustomHttpPattern; + + /** + * Encodes the specified CustomHttpPattern message. Does not implicitly {@link google.api.CustomHttpPattern.verify|verify} messages. + * @param m CustomHttpPattern message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.api.ICustomHttpPattern, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a CustomHttpPattern message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns CustomHttpPattern + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.api.CustomHttpPattern; + } + } + + /** Namespace protobuf. */ + namespace protobuf { + /** Properties of a FileDescriptorSet. */ + interface IFileDescriptorSet { + /** FileDescriptorSet file */ + file?: google.protobuf.IFileDescriptorProto[] | null; + } + + /** Represents a FileDescriptorSet. */ + class FileDescriptorSet implements IFileDescriptorSet { + /** + * Constructs a new FileDescriptorSet. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IFileDescriptorSet); + + /** FileDescriptorSet file. */ + public file: google.protobuf.IFileDescriptorProto[]; + + /** + * Creates a new FileDescriptorSet instance using the specified properties. + * @param [properties] Properties to set + * @returns FileDescriptorSet instance + */ + public static create( + properties?: google.protobuf.IFileDescriptorSet, + ): google.protobuf.FileDescriptorSet; + + /** + * Encodes the specified FileDescriptorSet message. Does not implicitly {@link google.protobuf.FileDescriptorSet.verify|verify} messages. + * @param m FileDescriptorSet message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IFileDescriptorSet, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a FileDescriptorSet message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns FileDescriptorSet + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.FileDescriptorSet; + } + + /** Properties of a FileDescriptorProto. */ + interface IFileDescriptorProto { + /** FileDescriptorProto name */ + name?: string | null; + + /** FileDescriptorProto package */ + package?: string | null; + + /** FileDescriptorProto dependency */ + dependency?: string[] | null; + + /** FileDescriptorProto publicDependency */ + publicDependency?: number[] | null; + + /** FileDescriptorProto weakDependency */ + weakDependency?: number[] | null; + + /** FileDescriptorProto messageType */ + messageType?: google.protobuf.IDescriptorProto[] | null; + + /** FileDescriptorProto enumType */ + enumType?: google.protobuf.IEnumDescriptorProto[] | null; + + /** FileDescriptorProto service */ + service?: google.protobuf.IServiceDescriptorProto[] | null; + + /** FileDescriptorProto extension */ + extension?: google.protobuf.IFieldDescriptorProto[] | null; + + /** FileDescriptorProto options */ + options?: google.protobuf.IFileOptions | null; + + /** FileDescriptorProto sourceCodeInfo */ + sourceCodeInfo?: google.protobuf.ISourceCodeInfo | null; + + /** FileDescriptorProto syntax */ + syntax?: string | null; + } + + /** Represents a FileDescriptorProto. */ + class FileDescriptorProto implements IFileDescriptorProto { + /** + * Constructs a new FileDescriptorProto. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IFileDescriptorProto); + + /** FileDescriptorProto name. */ + public name: string; + + /** FileDescriptorProto package. */ + public package: string; + + /** FileDescriptorProto dependency. */ + public dependency: string[]; + + /** FileDescriptorProto publicDependency. */ + public publicDependency: number[]; + + /** FileDescriptorProto weakDependency. */ + public weakDependency: number[]; + + /** FileDescriptorProto messageType. */ + public messageType: google.protobuf.IDescriptorProto[]; + + /** FileDescriptorProto enumType. */ + public enumType: google.protobuf.IEnumDescriptorProto[]; + + /** FileDescriptorProto service. */ + public service: google.protobuf.IServiceDescriptorProto[]; + + /** FileDescriptorProto extension. */ + public extension: google.protobuf.IFieldDescriptorProto[]; + + /** FileDescriptorProto options. */ + public options?: google.protobuf.IFileOptions | null; + + /** FileDescriptorProto sourceCodeInfo. */ + public sourceCodeInfo?: google.protobuf.ISourceCodeInfo | null; + + /** FileDescriptorProto syntax. */ + public syntax: string; + + /** + * Creates a new FileDescriptorProto instance using the specified properties. + * @param [properties] Properties to set + * @returns FileDescriptorProto instance + */ + public static create( + properties?: google.protobuf.IFileDescriptorProto, + ): google.protobuf.FileDescriptorProto; + + /** + * Encodes the specified FileDescriptorProto message. Does not implicitly {@link google.protobuf.FileDescriptorProto.verify|verify} messages. + * @param m FileDescriptorProto message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IFileDescriptorProto, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a FileDescriptorProto message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns FileDescriptorProto + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.FileDescriptorProto; + } + + /** Properties of a DescriptorProto. */ + interface IDescriptorProto { + /** DescriptorProto name */ + name?: string | null; + + /** DescriptorProto field */ + field?: google.protobuf.IFieldDescriptorProto[] | null; + + /** DescriptorProto extension */ + extension?: google.protobuf.IFieldDescriptorProto[] | null; + + /** DescriptorProto nestedType */ + nestedType?: google.protobuf.IDescriptorProto[] | null; + + /** DescriptorProto enumType */ + enumType?: google.protobuf.IEnumDescriptorProto[] | null; + + /** DescriptorProto extensionRange */ + extensionRange?: google.protobuf.DescriptorProto.IExtensionRange[] | null; + + /** DescriptorProto oneofDecl */ + oneofDecl?: google.protobuf.IOneofDescriptorProto[] | null; + + /** DescriptorProto options */ + options?: google.protobuf.IMessageOptions | null; + + /** DescriptorProto reservedRange */ + reservedRange?: google.protobuf.DescriptorProto.IReservedRange[] | null; + + /** DescriptorProto reservedName */ + reservedName?: string[] | null; + } + + /** Represents a DescriptorProto. */ + class DescriptorProto implements IDescriptorProto { + /** + * Constructs a new DescriptorProto. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IDescriptorProto); + + /** DescriptorProto name. */ + public name: string; + + /** DescriptorProto field. */ + public field: google.protobuf.IFieldDescriptorProto[]; + + /** DescriptorProto extension. */ + public extension: google.protobuf.IFieldDescriptorProto[]; + + /** DescriptorProto nestedType. */ + public nestedType: google.protobuf.IDescriptorProto[]; + + /** DescriptorProto enumType. */ + public enumType: google.protobuf.IEnumDescriptorProto[]; + + /** DescriptorProto extensionRange. */ + public extensionRange: google.protobuf.DescriptorProto.IExtensionRange[]; + + /** DescriptorProto oneofDecl. */ + public oneofDecl: google.protobuf.IOneofDescriptorProto[]; + + /** DescriptorProto options. */ + public options?: google.protobuf.IMessageOptions | null; + + /** DescriptorProto reservedRange. */ + public reservedRange: google.protobuf.DescriptorProto.IReservedRange[]; + + /** DescriptorProto reservedName. */ + public reservedName: string[]; + + /** + * Creates a new DescriptorProto instance using the specified properties. + * @param [properties] Properties to set + * @returns DescriptorProto instance + */ + public static create(properties?: google.protobuf.IDescriptorProto): google.protobuf.DescriptorProto; + + /** + * Encodes the specified DescriptorProto message. Does not implicitly {@link google.protobuf.DescriptorProto.verify|verify} messages. + * @param m DescriptorProto message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IDescriptorProto, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a DescriptorProto message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns DescriptorProto + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.DescriptorProto; + } + + namespace DescriptorProto { + /** Properties of an ExtensionRange. */ + interface IExtensionRange { + /** ExtensionRange start */ + start?: number | null; + + /** ExtensionRange end */ + end?: number | null; + } + + /** Represents an ExtensionRange. */ + class ExtensionRange implements IExtensionRange { + /** + * Constructs a new ExtensionRange. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.DescriptorProto.IExtensionRange); + + /** ExtensionRange start. */ + public start: number; + + /** ExtensionRange end. */ + public end: number; + + /** + * Creates a new ExtensionRange instance using the specified properties. + * @param [properties] Properties to set + * @returns ExtensionRange instance + */ + public static create( + properties?: google.protobuf.DescriptorProto.IExtensionRange, + ): google.protobuf.DescriptorProto.ExtensionRange; + + /** + * Encodes the specified ExtensionRange message. Does not implicitly {@link google.protobuf.DescriptorProto.ExtensionRange.verify|verify} messages. + * @param m ExtensionRange message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: google.protobuf.DescriptorProto.IExtensionRange, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes an ExtensionRange message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ExtensionRange + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): google.protobuf.DescriptorProto.ExtensionRange; + } + + /** Properties of a ReservedRange. */ + interface IReservedRange { + /** ReservedRange start */ + start?: number | null; + + /** ReservedRange end */ + end?: number | null; + } + + /** Represents a ReservedRange. */ + class ReservedRange implements IReservedRange { + /** + * Constructs a new ReservedRange. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.DescriptorProto.IReservedRange); + + /** ReservedRange start. */ + public start: number; + + /** ReservedRange end. */ + public end: number; + + /** + * Creates a new ReservedRange instance using the specified properties. + * @param [properties] Properties to set + * @returns ReservedRange instance + */ + public static create( + properties?: google.protobuf.DescriptorProto.IReservedRange, + ): google.protobuf.DescriptorProto.ReservedRange; + + /** + * Encodes the specified ReservedRange message. Does not implicitly {@link google.protobuf.DescriptorProto.ReservedRange.verify|verify} messages. + * @param m ReservedRange message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: google.protobuf.DescriptorProto.IReservedRange, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a ReservedRange message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ReservedRange + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): google.protobuf.DescriptorProto.ReservedRange; + } + } + + /** Properties of a FieldDescriptorProto. */ + interface IFieldDescriptorProto { + /** FieldDescriptorProto name */ + name?: string | null; + + /** FieldDescriptorProto number */ + number?: number | null; + + /** FieldDescriptorProto label */ + label?: google.protobuf.FieldDescriptorProto.Label | null; + + /** FieldDescriptorProto type */ + type?: google.protobuf.FieldDescriptorProto.Type | null; + + /** FieldDescriptorProto typeName */ + typeName?: string | null; + + /** FieldDescriptorProto extendee */ + extendee?: string | null; + + /** FieldDescriptorProto defaultValue */ + defaultValue?: string | null; + + /** FieldDescriptorProto oneofIndex */ + oneofIndex?: number | null; + + /** FieldDescriptorProto jsonName */ + jsonName?: string | null; + + /** FieldDescriptorProto options */ + options?: google.protobuf.IFieldOptions | null; + } + + /** Represents a FieldDescriptorProto. */ + class FieldDescriptorProto implements IFieldDescriptorProto { + /** + * Constructs a new FieldDescriptorProto. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IFieldDescriptorProto); + + /** FieldDescriptorProto name. */ + public name: string; + + /** FieldDescriptorProto number. */ + public number: number; + + /** FieldDescriptorProto label. */ + public label: google.protobuf.FieldDescriptorProto.Label; + + /** FieldDescriptorProto type. */ + public type: google.protobuf.FieldDescriptorProto.Type; + + /** FieldDescriptorProto typeName. */ + public typeName: string; + + /** FieldDescriptorProto extendee. */ + public extendee: string; + + /** FieldDescriptorProto defaultValue. */ + public defaultValue: string; + + /** FieldDescriptorProto oneofIndex. */ + public oneofIndex: number; + + /** FieldDescriptorProto jsonName. */ + public jsonName: string; + + /** FieldDescriptorProto options. */ + public options?: google.protobuf.IFieldOptions | null; + + /** + * Creates a new FieldDescriptorProto instance using the specified properties. + * @param [properties] Properties to set + * @returns FieldDescriptorProto instance + */ + public static create( + properties?: google.protobuf.IFieldDescriptorProto, + ): google.protobuf.FieldDescriptorProto; + + /** + * Encodes the specified FieldDescriptorProto message. Does not implicitly {@link google.protobuf.FieldDescriptorProto.verify|verify} messages. + * @param m FieldDescriptorProto message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IFieldDescriptorProto, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a FieldDescriptorProto message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns FieldDescriptorProto + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): google.protobuf.FieldDescriptorProto; + } + + namespace FieldDescriptorProto { + /** Type enum. */ + enum Type { + TYPE_DOUBLE = 1, + TYPE_FLOAT = 2, + TYPE_INT64 = 3, + TYPE_UINT64 = 4, + TYPE_INT32 = 5, + TYPE_FIXED64 = 6, + TYPE_FIXED32 = 7, + TYPE_BOOL = 8, + TYPE_STRING = 9, + TYPE_GROUP = 10, + TYPE_MESSAGE = 11, + TYPE_BYTES = 12, + TYPE_UINT32 = 13, + TYPE_ENUM = 14, + TYPE_SFIXED32 = 15, + TYPE_SFIXED64 = 16, + TYPE_SINT32 = 17, + TYPE_SINT64 = 18, + } + + /** Label enum. */ + enum Label { + LABEL_OPTIONAL = 1, + LABEL_REQUIRED = 2, + LABEL_REPEATED = 3, + } + } + + /** Properties of an OneofDescriptorProto. */ + interface IOneofDescriptorProto { + /** OneofDescriptorProto name */ + name?: string | null; + + /** OneofDescriptorProto options */ + options?: google.protobuf.IOneofOptions | null; + } + + /** Represents an OneofDescriptorProto. */ + class OneofDescriptorProto implements IOneofDescriptorProto { + /** + * Constructs a new OneofDescriptorProto. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IOneofDescriptorProto); + + /** OneofDescriptorProto name. */ + public name: string; + + /** OneofDescriptorProto options. */ + public options?: google.protobuf.IOneofOptions | null; + + /** + * Creates a new OneofDescriptorProto instance using the specified properties. + * @param [properties] Properties to set + * @returns OneofDescriptorProto instance + */ + public static create( + properties?: google.protobuf.IOneofDescriptorProto, + ): google.protobuf.OneofDescriptorProto; + + /** + * Encodes the specified OneofDescriptorProto message. Does not implicitly {@link google.protobuf.OneofDescriptorProto.verify|verify} messages. + * @param m OneofDescriptorProto message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IOneofDescriptorProto, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an OneofDescriptorProto message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns OneofDescriptorProto + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): google.protobuf.OneofDescriptorProto; + } + + /** Properties of an EnumDescriptorProto. */ + interface IEnumDescriptorProto { + /** EnumDescriptorProto name */ + name?: string | null; + + /** EnumDescriptorProto value */ + value?: google.protobuf.IEnumValueDescriptorProto[] | null; + + /** EnumDescriptorProto options */ + options?: google.protobuf.IEnumOptions | null; + } + + /** Represents an EnumDescriptorProto. */ + class EnumDescriptorProto implements IEnumDescriptorProto { + /** + * Constructs a new EnumDescriptorProto. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IEnumDescriptorProto); + + /** EnumDescriptorProto name. */ + public name: string; + + /** EnumDescriptorProto value. */ + public value: google.protobuf.IEnumValueDescriptorProto[]; + + /** EnumDescriptorProto options. */ + public options?: google.protobuf.IEnumOptions | null; + + /** + * Creates a new EnumDescriptorProto instance using the specified properties. + * @param [properties] Properties to set + * @returns EnumDescriptorProto instance + */ + public static create( + properties?: google.protobuf.IEnumDescriptorProto, + ): google.protobuf.EnumDescriptorProto; + + /** + * Encodes the specified EnumDescriptorProto message. Does not implicitly {@link google.protobuf.EnumDescriptorProto.verify|verify} messages. + * @param m EnumDescriptorProto message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IEnumDescriptorProto, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an EnumDescriptorProto message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns EnumDescriptorProto + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.EnumDescriptorProto; + } + + /** Properties of an EnumValueDescriptorProto. */ + interface IEnumValueDescriptorProto { + /** EnumValueDescriptorProto name */ + name?: string | null; + + /** EnumValueDescriptorProto number */ + number?: number | null; + + /** EnumValueDescriptorProto options */ + options?: google.protobuf.IEnumValueOptions | null; + } + + /** Represents an EnumValueDescriptorProto. */ + class EnumValueDescriptorProto implements IEnumValueDescriptorProto { + /** + * Constructs a new EnumValueDescriptorProto. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IEnumValueDescriptorProto); + + /** EnumValueDescriptorProto name. */ + public name: string; + + /** EnumValueDescriptorProto number. */ + public number: number; + + /** EnumValueDescriptorProto options. */ + public options?: google.protobuf.IEnumValueOptions | null; + + /** + * Creates a new EnumValueDescriptorProto instance using the specified properties. + * @param [properties] Properties to set + * @returns EnumValueDescriptorProto instance + */ + public static create( + properties?: google.protobuf.IEnumValueDescriptorProto, + ): google.protobuf.EnumValueDescriptorProto; + + /** + * Encodes the specified EnumValueDescriptorProto message. Does not implicitly {@link google.protobuf.EnumValueDescriptorProto.verify|verify} messages. + * @param m EnumValueDescriptorProto message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: google.protobuf.IEnumValueDescriptorProto, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes an EnumValueDescriptorProto message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns EnumValueDescriptorProto + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): google.protobuf.EnumValueDescriptorProto; + } + + /** Properties of a ServiceDescriptorProto. */ + interface IServiceDescriptorProto { + /** ServiceDescriptorProto name */ + name?: string | null; + + /** ServiceDescriptorProto method */ + method?: google.protobuf.IMethodDescriptorProto[] | null; + + /** ServiceDescriptorProto options */ + options?: google.protobuf.IServiceOptions | null; + } + + /** Represents a ServiceDescriptorProto. */ + class ServiceDescriptorProto implements IServiceDescriptorProto { + /** + * Constructs a new ServiceDescriptorProto. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IServiceDescriptorProto); + + /** ServiceDescriptorProto name. */ + public name: string; + + /** ServiceDescriptorProto method. */ + public method: google.protobuf.IMethodDescriptorProto[]; + + /** ServiceDescriptorProto options. */ + public options?: google.protobuf.IServiceOptions | null; + + /** + * Creates a new ServiceDescriptorProto instance using the specified properties. + * @param [properties] Properties to set + * @returns ServiceDescriptorProto instance + */ + public static create( + properties?: google.protobuf.IServiceDescriptorProto, + ): google.protobuf.ServiceDescriptorProto; + + /** + * Encodes the specified ServiceDescriptorProto message. Does not implicitly {@link google.protobuf.ServiceDescriptorProto.verify|verify} messages. + * @param m ServiceDescriptorProto message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: google.protobuf.IServiceDescriptorProto, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a ServiceDescriptorProto message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ServiceDescriptorProto + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): google.protobuf.ServiceDescriptorProto; + } + + /** Properties of a MethodDescriptorProto. */ + interface IMethodDescriptorProto { + /** MethodDescriptorProto name */ + name?: string | null; + + /** MethodDescriptorProto inputType */ + inputType?: string | null; + + /** MethodDescriptorProto outputType */ + outputType?: string | null; + + /** MethodDescriptorProto options */ + options?: google.protobuf.IMethodOptions | null; + + /** MethodDescriptorProto clientStreaming */ + clientStreaming?: boolean | null; + + /** MethodDescriptorProto serverStreaming */ + serverStreaming?: boolean | null; + } + + /** Represents a MethodDescriptorProto. */ + class MethodDescriptorProto implements IMethodDescriptorProto { + /** + * Constructs a new MethodDescriptorProto. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IMethodDescriptorProto); + + /** MethodDescriptorProto name. */ + public name: string; + + /** MethodDescriptorProto inputType. */ + public inputType: string; + + /** MethodDescriptorProto outputType. */ + public outputType: string; + + /** MethodDescriptorProto options. */ + public options?: google.protobuf.IMethodOptions | null; + + /** MethodDescriptorProto clientStreaming. */ + public clientStreaming: boolean; + + /** MethodDescriptorProto serverStreaming. */ + public serverStreaming: boolean; + + /** + * Creates a new MethodDescriptorProto instance using the specified properties. + * @param [properties] Properties to set + * @returns MethodDescriptorProto instance + */ + public static create( + properties?: google.protobuf.IMethodDescriptorProto, + ): google.protobuf.MethodDescriptorProto; + + /** + * Encodes the specified MethodDescriptorProto message. Does not implicitly {@link google.protobuf.MethodDescriptorProto.verify|verify} messages. + * @param m MethodDescriptorProto message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IMethodDescriptorProto, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MethodDescriptorProto message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MethodDescriptorProto + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): google.protobuf.MethodDescriptorProto; + } + + /** Properties of a FileOptions. */ + interface IFileOptions { + /** FileOptions javaPackage */ + javaPackage?: string | null; + + /** FileOptions javaOuterClassname */ + javaOuterClassname?: string | null; + + /** FileOptions javaMultipleFiles */ + javaMultipleFiles?: boolean | null; + + /** FileOptions javaGenerateEqualsAndHash */ + javaGenerateEqualsAndHash?: boolean | null; + + /** FileOptions javaStringCheckUtf8 */ + javaStringCheckUtf8?: boolean | null; + + /** FileOptions optimizeFor */ + optimizeFor?: google.protobuf.FileOptions.OptimizeMode | null; + + /** FileOptions goPackage */ + goPackage?: string | null; + + /** FileOptions ccGenericServices */ + ccGenericServices?: boolean | null; + + /** FileOptions javaGenericServices */ + javaGenericServices?: boolean | null; + + /** FileOptions pyGenericServices */ + pyGenericServices?: boolean | null; + + /** FileOptions deprecated */ + deprecated?: boolean | null; + + /** FileOptions ccEnableArenas */ + ccEnableArenas?: boolean | null; + + /** FileOptions objcClassPrefix */ + objcClassPrefix?: string | null; + + /** FileOptions csharpNamespace */ + csharpNamespace?: string | null; + + /** FileOptions uninterpretedOption */ + uninterpretedOption?: google.protobuf.IUninterpretedOption[] | null; + } + + /** Represents a FileOptions. */ + class FileOptions implements IFileOptions { + /** + * Constructs a new FileOptions. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IFileOptions); + + /** FileOptions javaPackage. */ + public javaPackage: string; + + /** FileOptions javaOuterClassname. */ + public javaOuterClassname: string; + + /** FileOptions javaMultipleFiles. */ + public javaMultipleFiles: boolean; + + /** FileOptions javaGenerateEqualsAndHash. */ + public javaGenerateEqualsAndHash: boolean; + + /** FileOptions javaStringCheckUtf8. */ + public javaStringCheckUtf8: boolean; + + /** FileOptions optimizeFor. */ + public optimizeFor: google.protobuf.FileOptions.OptimizeMode; + + /** FileOptions goPackage. */ + public goPackage: string; + + /** FileOptions ccGenericServices. */ + public ccGenericServices: boolean; + + /** FileOptions javaGenericServices. */ + public javaGenericServices: boolean; + + /** FileOptions pyGenericServices. */ + public pyGenericServices: boolean; + + /** FileOptions deprecated. */ + public deprecated: boolean; + + /** FileOptions ccEnableArenas. */ + public ccEnableArenas: boolean; + + /** FileOptions objcClassPrefix. */ + public objcClassPrefix: string; + + /** FileOptions csharpNamespace. */ + public csharpNamespace: string; + + /** FileOptions uninterpretedOption. */ + public uninterpretedOption: google.protobuf.IUninterpretedOption[]; + + /** + * Creates a new FileOptions instance using the specified properties. + * @param [properties] Properties to set + * @returns FileOptions instance + */ + public static create(properties?: google.protobuf.IFileOptions): google.protobuf.FileOptions; + + /** + * Encodes the specified FileOptions message. Does not implicitly {@link google.protobuf.FileOptions.verify|verify} messages. + * @param m FileOptions message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IFileOptions, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a FileOptions message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns FileOptions + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.FileOptions; + } + + namespace FileOptions { + /** OptimizeMode enum. */ + enum OptimizeMode { + SPEED = 1, + CODE_SIZE = 2, + LITE_RUNTIME = 3, + } + } + + /** Properties of a MessageOptions. */ + interface IMessageOptions { + /** MessageOptions messageSetWireFormat */ + messageSetWireFormat?: boolean | null; + + /** MessageOptions noStandardDescriptorAccessor */ + noStandardDescriptorAccessor?: boolean | null; + + /** MessageOptions deprecated */ + deprecated?: boolean | null; + + /** MessageOptions mapEntry */ + mapEntry?: boolean | null; + + /** MessageOptions uninterpretedOption */ + uninterpretedOption?: google.protobuf.IUninterpretedOption[] | null; + } + + /** Represents a MessageOptions. */ + class MessageOptions implements IMessageOptions { + /** + * Constructs a new MessageOptions. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IMessageOptions); + + /** MessageOptions messageSetWireFormat. */ + public messageSetWireFormat: boolean; + + /** MessageOptions noStandardDescriptorAccessor. */ + public noStandardDescriptorAccessor: boolean; + + /** MessageOptions deprecated. */ + public deprecated: boolean; + + /** MessageOptions mapEntry. */ + public mapEntry: boolean; + + /** MessageOptions uninterpretedOption. */ + public uninterpretedOption: google.protobuf.IUninterpretedOption[]; + + /** + * Creates a new MessageOptions instance using the specified properties. + * @param [properties] Properties to set + * @returns MessageOptions instance + */ + public static create(properties?: google.protobuf.IMessageOptions): google.protobuf.MessageOptions; + + /** + * Encodes the specified MessageOptions message. Does not implicitly {@link google.protobuf.MessageOptions.verify|verify} messages. + * @param m MessageOptions message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IMessageOptions, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MessageOptions message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MessageOptions + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.MessageOptions; + } + + /** Properties of a FieldOptions. */ + interface IFieldOptions { + /** FieldOptions ctype */ + ctype?: google.protobuf.FieldOptions.CType | null; + + /** FieldOptions packed */ + packed?: boolean | null; + + /** FieldOptions jstype */ + jstype?: google.protobuf.FieldOptions.JSType | null; + + /** FieldOptions lazy */ + lazy?: boolean | null; + + /** FieldOptions deprecated */ + deprecated?: boolean | null; + + /** FieldOptions weak */ + weak?: boolean | null; + + /** FieldOptions uninterpretedOption */ + uninterpretedOption?: google.protobuf.IUninterpretedOption[] | null; + } + + /** Represents a FieldOptions. */ + class FieldOptions implements IFieldOptions { + /** + * Constructs a new FieldOptions. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IFieldOptions); + + /** FieldOptions ctype. */ + public ctype: google.protobuf.FieldOptions.CType; + + /** FieldOptions packed. */ + public packed: boolean; + + /** FieldOptions jstype. */ + public jstype: google.protobuf.FieldOptions.JSType; + + /** FieldOptions lazy. */ + public lazy: boolean; + + /** FieldOptions deprecated. */ + public deprecated: boolean; + + /** FieldOptions weak. */ + public weak: boolean; + + /** FieldOptions uninterpretedOption. */ + public uninterpretedOption: google.protobuf.IUninterpretedOption[]; + + /** + * Creates a new FieldOptions instance using the specified properties. + * @param [properties] Properties to set + * @returns FieldOptions instance + */ + public static create(properties?: google.protobuf.IFieldOptions): google.protobuf.FieldOptions; + + /** + * Encodes the specified FieldOptions message. Does not implicitly {@link google.protobuf.FieldOptions.verify|verify} messages. + * @param m FieldOptions message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IFieldOptions, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a FieldOptions message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns FieldOptions + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.FieldOptions; + } + + namespace FieldOptions { + /** CType enum. */ + enum CType { + STRING = 0, + CORD = 1, + STRING_PIECE = 2, + } + + /** JSType enum. */ + enum JSType { + JS_NORMAL = 0, + JS_STRING = 1, + JS_NUMBER = 2, + } + } + + /** Properties of an OneofOptions. */ + interface IOneofOptions { + /** OneofOptions uninterpretedOption */ + uninterpretedOption?: google.protobuf.IUninterpretedOption[] | null; + } + + /** Represents an OneofOptions. */ + class OneofOptions implements IOneofOptions { + /** + * Constructs a new OneofOptions. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IOneofOptions); + + /** OneofOptions uninterpretedOption. */ + public uninterpretedOption: google.protobuf.IUninterpretedOption[]; + + /** + * Creates a new OneofOptions instance using the specified properties. + * @param [properties] Properties to set + * @returns OneofOptions instance + */ + public static create(properties?: google.protobuf.IOneofOptions): google.protobuf.OneofOptions; + + /** + * Encodes the specified OneofOptions message. Does not implicitly {@link google.protobuf.OneofOptions.verify|verify} messages. + * @param m OneofOptions message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IOneofOptions, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an OneofOptions message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns OneofOptions + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.OneofOptions; + } + + /** Properties of an EnumOptions. */ + interface IEnumOptions { + /** EnumOptions allowAlias */ + allowAlias?: boolean | null; + + /** EnumOptions deprecated */ + deprecated?: boolean | null; + + /** EnumOptions uninterpretedOption */ + uninterpretedOption?: google.protobuf.IUninterpretedOption[] | null; + } + + /** Represents an EnumOptions. */ + class EnumOptions implements IEnumOptions { + /** + * Constructs a new EnumOptions. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IEnumOptions); + + /** EnumOptions allowAlias. */ + public allowAlias: boolean; + + /** EnumOptions deprecated. */ + public deprecated: boolean; + + /** EnumOptions uninterpretedOption. */ + public uninterpretedOption: google.protobuf.IUninterpretedOption[]; + + /** + * Creates a new EnumOptions instance using the specified properties. + * @param [properties] Properties to set + * @returns EnumOptions instance + */ + public static create(properties?: google.protobuf.IEnumOptions): google.protobuf.EnumOptions; + + /** + * Encodes the specified EnumOptions message. Does not implicitly {@link google.protobuf.EnumOptions.verify|verify} messages. + * @param m EnumOptions message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IEnumOptions, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an EnumOptions message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns EnumOptions + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.EnumOptions; + } + + /** Properties of an EnumValueOptions. */ + interface IEnumValueOptions { + /** EnumValueOptions deprecated */ + deprecated?: boolean | null; + + /** EnumValueOptions uninterpretedOption */ + uninterpretedOption?: google.protobuf.IUninterpretedOption[] | null; + } + + /** Represents an EnumValueOptions. */ + class EnumValueOptions implements IEnumValueOptions { + /** + * Constructs a new EnumValueOptions. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IEnumValueOptions); + + /** EnumValueOptions deprecated. */ + public deprecated: boolean; + + /** EnumValueOptions uninterpretedOption. */ + public uninterpretedOption: google.protobuf.IUninterpretedOption[]; + + /** + * Creates a new EnumValueOptions instance using the specified properties. + * @param [properties] Properties to set + * @returns EnumValueOptions instance + */ + public static create(properties?: google.protobuf.IEnumValueOptions): google.protobuf.EnumValueOptions; + + /** + * Encodes the specified EnumValueOptions message. Does not implicitly {@link google.protobuf.EnumValueOptions.verify|verify} messages. + * @param m EnumValueOptions message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IEnumValueOptions, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an EnumValueOptions message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns EnumValueOptions + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.EnumValueOptions; + } + + /** Properties of a ServiceOptions. */ + interface IServiceOptions { + /** ServiceOptions deprecated */ + deprecated?: boolean | null; + + /** ServiceOptions uninterpretedOption */ + uninterpretedOption?: google.protobuf.IUninterpretedOption[] | null; + } + + /** Represents a ServiceOptions. */ + class ServiceOptions implements IServiceOptions { + /** + * Constructs a new ServiceOptions. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IServiceOptions); + + /** ServiceOptions deprecated. */ + public deprecated: boolean; + + /** ServiceOptions uninterpretedOption. */ + public uninterpretedOption: google.protobuf.IUninterpretedOption[]; + + /** + * Creates a new ServiceOptions instance using the specified properties. + * @param [properties] Properties to set + * @returns ServiceOptions instance + */ + public static create(properties?: google.protobuf.IServiceOptions): google.protobuf.ServiceOptions; + + /** + * Encodes the specified ServiceOptions message. Does not implicitly {@link google.protobuf.ServiceOptions.verify|verify} messages. + * @param m ServiceOptions message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IServiceOptions, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a ServiceOptions message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns ServiceOptions + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.ServiceOptions; + } + + /** Properties of a MethodOptions. */ + interface IMethodOptions { + /** MethodOptions deprecated */ + deprecated?: boolean | null; + + /** MethodOptions uninterpretedOption */ + uninterpretedOption?: google.protobuf.IUninterpretedOption[] | null; + + /** MethodOptions .google.api.http */ + ".google.api.http"?: google.api.IHttpRule | null; + } + + /** Represents a MethodOptions. */ + class MethodOptions implements IMethodOptions { + /** + * Constructs a new MethodOptions. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IMethodOptions); + + /** MethodOptions deprecated. */ + public deprecated: boolean; + + /** MethodOptions uninterpretedOption. */ + public uninterpretedOption: google.protobuf.IUninterpretedOption[]; + + /** + * Creates a new MethodOptions instance using the specified properties. + * @param [properties] Properties to set + * @returns MethodOptions instance + */ + public static create(properties?: google.protobuf.IMethodOptions): google.protobuf.MethodOptions; + + /** + * Encodes the specified MethodOptions message. Does not implicitly {@link google.protobuf.MethodOptions.verify|verify} messages. + * @param m MethodOptions message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IMethodOptions, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a MethodOptions message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns MethodOptions + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.MethodOptions; + } + + /** Properties of an UninterpretedOption. */ + interface IUninterpretedOption { + /** UninterpretedOption name */ + name?: google.protobuf.UninterpretedOption.INamePart[] | null; + + /** UninterpretedOption identifierValue */ + identifierValue?: string | null; + + /** UninterpretedOption positiveIntValue */ + positiveIntValue?: Long | null; + + /** UninterpretedOption negativeIntValue */ + negativeIntValue?: Long | null; + + /** UninterpretedOption doubleValue */ + doubleValue?: number | null; + + /** UninterpretedOption stringValue */ + stringValue?: Uint8Array | null; + + /** UninterpretedOption aggregateValue */ + aggregateValue?: string | null; + } + + /** Represents an UninterpretedOption. */ + class UninterpretedOption implements IUninterpretedOption { + /** + * Constructs a new UninterpretedOption. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IUninterpretedOption); + + /** UninterpretedOption name. */ + public name: google.protobuf.UninterpretedOption.INamePart[]; + + /** UninterpretedOption identifierValue. */ + public identifierValue: string; + + /** UninterpretedOption positiveIntValue. */ + public positiveIntValue: Long; + + /** UninterpretedOption negativeIntValue. */ + public negativeIntValue: Long; + + /** UninterpretedOption doubleValue. */ + public doubleValue: number; + + /** UninterpretedOption stringValue. */ + public stringValue: Uint8Array; + + /** UninterpretedOption aggregateValue. */ + public aggregateValue: string; + + /** + * Creates a new UninterpretedOption instance using the specified properties. + * @param [properties] Properties to set + * @returns UninterpretedOption instance + */ + public static create( + properties?: google.protobuf.IUninterpretedOption, + ): google.protobuf.UninterpretedOption; + + /** + * Encodes the specified UninterpretedOption message. Does not implicitly {@link google.protobuf.UninterpretedOption.verify|verify} messages. + * @param m UninterpretedOption message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IUninterpretedOption, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an UninterpretedOption message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns UninterpretedOption + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.UninterpretedOption; + } + + namespace UninterpretedOption { + /** Properties of a NamePart. */ + interface INamePart { + /** NamePart namePart */ + namePart: string; + + /** NamePart isExtension */ + isExtension: boolean; + } + + /** Represents a NamePart. */ + class NamePart implements INamePart { + /** + * Constructs a new NamePart. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.UninterpretedOption.INamePart); + + /** NamePart namePart. */ + public namePart: string; + + /** NamePart isExtension. */ + public isExtension: boolean; + + /** + * Creates a new NamePart instance using the specified properties. + * @param [properties] Properties to set + * @returns NamePart instance + */ + public static create( + properties?: google.protobuf.UninterpretedOption.INamePart, + ): google.protobuf.UninterpretedOption.NamePart; + + /** + * Encodes the specified NamePart message. Does not implicitly {@link google.protobuf.UninterpretedOption.NamePart.verify|verify} messages. + * @param m NamePart message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: google.protobuf.UninterpretedOption.INamePart, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a NamePart message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns NamePart + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): google.protobuf.UninterpretedOption.NamePart; + } + } + + /** Properties of a SourceCodeInfo. */ + interface ISourceCodeInfo { + /** SourceCodeInfo location */ + location?: google.protobuf.SourceCodeInfo.ILocation[] | null; + } + + /** Represents a SourceCodeInfo. */ + class SourceCodeInfo implements ISourceCodeInfo { + /** + * Constructs a new SourceCodeInfo. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.ISourceCodeInfo); + + /** SourceCodeInfo location. */ + public location: google.protobuf.SourceCodeInfo.ILocation[]; + + /** + * Creates a new SourceCodeInfo instance using the specified properties. + * @param [properties] Properties to set + * @returns SourceCodeInfo instance + */ + public static create(properties?: google.protobuf.ISourceCodeInfo): google.protobuf.SourceCodeInfo; + + /** + * Encodes the specified SourceCodeInfo message. Does not implicitly {@link google.protobuf.SourceCodeInfo.verify|verify} messages. + * @param m SourceCodeInfo message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.ISourceCodeInfo, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a SourceCodeInfo message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns SourceCodeInfo + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.SourceCodeInfo; + } + + namespace SourceCodeInfo { + /** Properties of a Location. */ + interface ILocation { + /** Location path */ + path?: number[] | null; + + /** Location span */ + span?: number[] | null; + + /** Location leadingComments */ + leadingComments?: string | null; + + /** Location trailingComments */ + trailingComments?: string | null; + + /** Location leadingDetachedComments */ + leadingDetachedComments?: string[] | null; + } + + /** Represents a Location. */ + class Location implements ILocation { + /** + * Constructs a new Location. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.SourceCodeInfo.ILocation); + + /** Location path. */ + public path: number[]; + + /** Location span. */ + public span: number[]; + + /** Location leadingComments. */ + public leadingComments: string; + + /** Location trailingComments. */ + public trailingComments: string; + + /** Location leadingDetachedComments. */ + public leadingDetachedComments: string[]; + + /** + * Creates a new Location instance using the specified properties. + * @param [properties] Properties to set + * @returns Location instance + */ + public static create( + properties?: google.protobuf.SourceCodeInfo.ILocation, + ): google.protobuf.SourceCodeInfo.Location; + + /** + * Encodes the specified Location message. Does not implicitly {@link google.protobuf.SourceCodeInfo.Location.verify|verify} messages. + * @param m Location message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: google.protobuf.SourceCodeInfo.ILocation, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a Location message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Location + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): google.protobuf.SourceCodeInfo.Location; + } + } + + /** Properties of a GeneratedCodeInfo. */ + interface IGeneratedCodeInfo { + /** GeneratedCodeInfo annotation */ + annotation?: google.protobuf.GeneratedCodeInfo.IAnnotation[] | null; + } + + /** Represents a GeneratedCodeInfo. */ + class GeneratedCodeInfo implements IGeneratedCodeInfo { + /** + * Constructs a new GeneratedCodeInfo. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.IGeneratedCodeInfo); + + /** GeneratedCodeInfo annotation. */ + public annotation: google.protobuf.GeneratedCodeInfo.IAnnotation[]; + + /** + * Creates a new GeneratedCodeInfo instance using the specified properties. + * @param [properties] Properties to set + * @returns GeneratedCodeInfo instance + */ + public static create( + properties?: google.protobuf.IGeneratedCodeInfo, + ): google.protobuf.GeneratedCodeInfo; + + /** + * Encodes the specified GeneratedCodeInfo message. Does not implicitly {@link google.protobuf.GeneratedCodeInfo.verify|verify} messages. + * @param m GeneratedCodeInfo message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: google.protobuf.IGeneratedCodeInfo, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a GeneratedCodeInfo message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns GeneratedCodeInfo + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): google.protobuf.GeneratedCodeInfo; + } + + namespace GeneratedCodeInfo { + /** Properties of an Annotation. */ + interface IAnnotation { + /** Annotation path */ + path?: number[] | null; + + /** Annotation sourceFile */ + sourceFile?: string | null; + + /** Annotation begin */ + begin?: number | null; + + /** Annotation end */ + end?: number | null; + } + + /** Represents an Annotation. */ + class Annotation implements IAnnotation { + /** + * Constructs a new Annotation. + * @param [p] Properties to set + */ + constructor(p?: google.protobuf.GeneratedCodeInfo.IAnnotation); + + /** Annotation path. */ + public path: number[]; + + /** Annotation sourceFile. */ + public sourceFile: string; + + /** Annotation begin. */ + public begin: number; + + /** Annotation end. */ + public end: number; + + /** + * Creates a new Annotation instance using the specified properties. + * @param [properties] Properties to set + * @returns Annotation instance + */ + public static create( + properties?: google.protobuf.GeneratedCodeInfo.IAnnotation, + ): google.protobuf.GeneratedCodeInfo.Annotation; + + /** + * Encodes the specified Annotation message. Does not implicitly {@link google.protobuf.GeneratedCodeInfo.Annotation.verify|verify} messages. + * @param m Annotation message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: google.protobuf.GeneratedCodeInfo.IAnnotation, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes an Annotation message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Annotation + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): google.protobuf.GeneratedCodeInfo.Annotation; + } + } + } +} + +/** Namespace cosmos. */ +export namespace cosmos { + /** Namespace base. */ + namespace base { + /** Namespace v1beta1. */ + namespace v1beta1 { + /** Properties of a Coin. */ + interface ICoin { + /** Coin denom */ + denom?: string | null; + + /** Coin amount */ + amount?: string | null; + } + + /** Represents a Coin. */ + class Coin implements ICoin { + /** + * Constructs a new Coin. + * @param [p] Properties to set + */ + constructor(p?: cosmos.base.v1beta1.ICoin); + + /** Coin denom. */ + public denom: string; + + /** Coin amount. */ + public amount: string; + + /** + * Creates a new Coin instance using the specified properties. + * @param [properties] Properties to set + * @returns Coin instance + */ + public static create(properties?: cosmos.base.v1beta1.ICoin): cosmos.base.v1beta1.Coin; + + /** + * Encodes the specified Coin message. Does not implicitly {@link cosmos.base.v1beta1.Coin.verify|verify} messages. + * @param m Coin message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.base.v1beta1.ICoin, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a Coin message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns Coin + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.base.v1beta1.Coin; + } + + /** Properties of a DecCoin. */ + interface IDecCoin { + /** DecCoin denom */ + denom?: string | null; + + /** DecCoin amount */ + amount?: string | null; + } + + /** Represents a DecCoin. */ + class DecCoin implements IDecCoin { + /** + * Constructs a new DecCoin. + * @param [p] Properties to set + */ + constructor(p?: cosmos.base.v1beta1.IDecCoin); + + /** DecCoin denom. */ + public denom: string; + + /** DecCoin amount. */ + public amount: string; + + /** + * Creates a new DecCoin instance using the specified properties. + * @param [properties] Properties to set + * @returns DecCoin instance + */ + public static create(properties?: cosmos.base.v1beta1.IDecCoin): cosmos.base.v1beta1.DecCoin; + + /** + * Encodes the specified DecCoin message. Does not implicitly {@link cosmos.base.v1beta1.DecCoin.verify|verify} messages. + * @param m DecCoin message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.base.v1beta1.IDecCoin, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a DecCoin message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns DecCoin + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.base.v1beta1.DecCoin; + } + + /** Properties of an IntProto. */ + interface IIntProto { + /** IntProto int */ + int?: string | null; + } + + /** Represents an IntProto. */ + class IntProto implements IIntProto { + /** + * Constructs a new IntProto. + * @param [p] Properties to set + */ + constructor(p?: cosmos.base.v1beta1.IIntProto); + + /** IntProto int. */ + public int: string; + + /** + * Creates a new IntProto instance using the specified properties. + * @param [properties] Properties to set + * @returns IntProto instance + */ + public static create(properties?: cosmos.base.v1beta1.IIntProto): cosmos.base.v1beta1.IntProto; + + /** + * Encodes the specified IntProto message. Does not implicitly {@link cosmos.base.v1beta1.IntProto.verify|verify} messages. + * @param m IntProto message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.base.v1beta1.IIntProto, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes an IntProto message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns IntProto + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.base.v1beta1.IntProto; + } + + /** Properties of a DecProto. */ + interface IDecProto { + /** DecProto dec */ + dec?: string | null; + } + + /** Represents a DecProto. */ + class DecProto implements IDecProto { + /** + * Constructs a new DecProto. + * @param [p] Properties to set + */ + constructor(p?: cosmos.base.v1beta1.IDecProto); + + /** DecProto dec. */ + public dec: string; + + /** + * Creates a new DecProto instance using the specified properties. + * @param [properties] Properties to set + * @returns DecProto instance + */ + public static create(properties?: cosmos.base.v1beta1.IDecProto): cosmos.base.v1beta1.DecProto; + + /** + * Encodes the specified DecProto message. Does not implicitly {@link cosmos.base.v1beta1.DecProto.verify|verify} messages. + * @param m DecProto message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode(m: cosmos.base.v1beta1.IDecProto, w?: $protobuf.Writer): $protobuf.Writer; + + /** + * Decodes a DecProto message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns DecProto + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode(r: $protobuf.Reader | Uint8Array, l?: number): cosmos.base.v1beta1.DecProto; + } + } + + /** Namespace query. */ + namespace query { + /** Namespace v1beta1. */ + namespace v1beta1 { + /** Properties of a PageRequest. */ + interface IPageRequest { + /** PageRequest key */ + key?: Uint8Array | null; + + /** PageRequest offset */ + offset?: Long | null; + + /** PageRequest limit */ + limit?: Long | null; + + /** PageRequest countTotal */ + countTotal?: boolean | null; + } + + /** Represents a PageRequest. */ + class PageRequest implements IPageRequest { + /** + * Constructs a new PageRequest. + * @param [p] Properties to set + */ + constructor(p?: cosmos.base.query.v1beta1.IPageRequest); + + /** PageRequest key. */ + public key: Uint8Array; + + /** PageRequest offset. */ + public offset: Long; + + /** PageRequest limit. */ + public limit: Long; + + /** PageRequest countTotal. */ + public countTotal: boolean; + + /** + * Creates a new PageRequest instance using the specified properties. + * @param [properties] Properties to set + * @returns PageRequest instance + */ + public static create( + properties?: cosmos.base.query.v1beta1.IPageRequest, + ): cosmos.base.query.v1beta1.PageRequest; + + /** + * Encodes the specified PageRequest message. Does not implicitly {@link cosmos.base.query.v1beta1.PageRequest.verify|verify} messages. + * @param m PageRequest message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.base.query.v1beta1.IPageRequest, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a PageRequest message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns PageRequest + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.base.query.v1beta1.PageRequest; + } + + /** Properties of a PageResponse. */ + interface IPageResponse { + /** PageResponse nextKey */ + nextKey?: Uint8Array | null; + + /** PageResponse total */ + total?: Long | null; + } + + /** Represents a PageResponse. */ + class PageResponse implements IPageResponse { + /** + * Constructs a new PageResponse. + * @param [p] Properties to set + */ + constructor(p?: cosmos.base.query.v1beta1.IPageResponse); + + /** PageResponse nextKey. */ + public nextKey: Uint8Array; + + /** PageResponse total. */ + public total: Long; + + /** + * Creates a new PageResponse instance using the specified properties. + * @param [properties] Properties to set + * @returns PageResponse instance + */ + public static create( + properties?: cosmos.base.query.v1beta1.IPageResponse, + ): cosmos.base.query.v1beta1.PageResponse; + + /** + * Encodes the specified PageResponse message. Does not implicitly {@link cosmos.base.query.v1beta1.PageResponse.verify|verify} messages. + * @param m PageResponse message or plain object to encode + * @param [w] Writer to encode to + * @returns Writer + */ + public static encode( + m: cosmos.base.query.v1beta1.IPageResponse, + w?: $protobuf.Writer, + ): $protobuf.Writer; + + /** + * Decodes a PageResponse message from the specified reader or buffer. + * @param r Reader or buffer to decode from + * @param [l] Message length if known beforehand + * @returns PageResponse + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + public static decode( + r: $protobuf.Reader | Uint8Array, + l?: number, + ): cosmos.base.query.v1beta1.PageResponse; + } + } + } + } +} diff --git a/packages/cosmwasm-stargate/types/codec/index.d.ts b/packages/cosmwasm-stargate/types/codec/index.d.ts new file mode 100644 index 00000000..7cc01b17 --- /dev/null +++ b/packages/cosmwasm-stargate/types/codec/index.d.ts @@ -0,0 +1 @@ +export { cosmwasm } from "./generated/codecimpl"; From aa2b61bd3b4637b4b5585de513ff61672ff6089f Mon Sep 17 00:00:00 2001 From: willclarktech Date: Wed, 9 Dec 2020 12:38:20 +0000 Subject: [PATCH 12/33] cosmwasm-stargate: Add CosmWasmClient --- .../cosmwasm-stargate/src/cosmwasmclient.ts | 342 ++++++++++++++++++ .../types/cosmwasmclient.d.ts | 62 ++++ 2 files changed, 404 insertions(+) create mode 100644 packages/cosmwasm-stargate/src/cosmwasmclient.ts create mode 100644 packages/cosmwasm-stargate/types/cosmwasmclient.d.ts diff --git a/packages/cosmwasm-stargate/src/cosmwasmclient.ts b/packages/cosmwasm-stargate/src/cosmwasmclient.ts new file mode 100644 index 00000000..870c2554 --- /dev/null +++ b/packages/cosmwasm-stargate/src/cosmwasmclient.ts @@ -0,0 +1,342 @@ +/* eslint-disable @typescript-eslint/naming-convention */ +import { Code, CodeDetails, Contract, ContractCodeHistoryEntry, JsonObject } from "@cosmjs/cosmwasm"; +import { fromAscii, toHex } from "@cosmjs/encoding"; +import { + Block, + Coin, + isSearchByHeightQuery, + isSearchByIdQuery, + isSearchBySentFromOrToQuery, + isSearchByTagsQuery, + SearchTxFilter, + SearchTxQuery, +} from "@cosmjs/launchpad"; +import { Uint53 } from "@cosmjs/math"; +import { + Account, + accountFromProto, + AuthExtension, + BankExtension, + BroadcastTxResponse, + codec, + coinFromProto, + IndexedTx, + QueryClient, + SequenceResponse, + setupAuthExtension, + setupBankExtension, +} from "@cosmjs/stargate"; +import { + adaptor34, + broadcastTxCommitSuccess, + Client as TendermintClient, + QueryString, +} from "@cosmjs/tendermint-rpc"; +import { assert } from "@cosmjs/utils"; + +import { cosmwasm } from "./codec"; +import { setupWasmExtension, WasmExtension } from "./queries"; + +type ICodeInfoResponse = cosmwasm.wasm.v1beta1.ICodeInfoResponse; +type ContractCodeHistoryOperationType = cosmwasm.wasm.v1beta1.ContractCodeHistoryOperationType; + +const { TxMsgData } = codec.cosmos.base.abci.v1beta1; +const { ContractCodeHistoryOperationType } = cosmwasm.wasm.v1beta1; + +/** Use for testing only */ +export interface PrivateCosmWasmClient { + readonly tmClient: TendermintClient; + readonly queryClient: QueryClient & AuthExtension & BankExtension & WasmExtension; +} + +export class CosmWasmClient { + private readonly tmClient: TendermintClient; + private readonly queryClient: QueryClient & AuthExtension & BankExtension & WasmExtension; + private readonly codesCache = new Map(); + private chainId: string | undefined; + + public static async connect(endpoint: string): Promise { + const tmClient = await TendermintClient.connect(endpoint, adaptor34); + return new CosmWasmClient(tmClient); + } + + protected constructor(tmClient: TendermintClient) { + this.tmClient = tmClient; + this.queryClient = QueryClient.withExtensions( + tmClient, + setupAuthExtension, + setupBankExtension, + setupWasmExtension, + ); + } + + public async getChainId(): Promise { + if (!this.chainId) { + const response = await this.tmClient.status(); + const chainId = response.nodeInfo.network; + if (!chainId) throw new Error("Chain ID must not be empty"); + this.chainId = chainId; + } + + return this.chainId; + } + + public async getHeight(): Promise { + const status = await this.tmClient.status(); + return status.syncInfo.latestBlockHeight; + } + + public async getAccount(searchAddress: string): Promise { + const account = await this.queryClient.auth.account(searchAddress); + return account ? accountFromProto(account) : null; + } + + public async getSequence(address: string): Promise { + const account = await this.getAccount(address); + if (account) { + return { + accountNumber: account.accountNumber, + sequence: account.sequence, + }; + } else { + return null; + } + } + + public async getBlock(height?: number): Promise { + const response = await this.tmClient.block(height); + return { + id: toHex(response.blockId.hash).toUpperCase(), + header: { + version: { + block: new Uint53(response.block.header.version.block).toString(), + app: new Uint53(response.block.header.version.app).toString(), + }, + height: response.block.header.height, + chainId: response.block.header.chainId, + time: response.block.header.time.toISOString(), + }, + txs: response.block.txs, + }; + } + + public async getBalance(address: string, searchDenom: string): Promise { + const balance = await this.queryClient.bank.balance(address, searchDenom); + return balance ? coinFromProto(balance) : null; + } + + public async searchTx(query: SearchTxQuery, filter: SearchTxFilter = {}): Promise { + const minHeight = filter.minHeight || 0; + const maxHeight = filter.maxHeight || Number.MAX_SAFE_INTEGER; + + if (maxHeight < minHeight) return []; // optional optimization + + let txs: readonly IndexedTx[]; + + if (isSearchByIdQuery(query)) { + txs = await this.txsQuery(`tx.hash='${query.id}'`); + } else if (isSearchByHeightQuery(query)) { + txs = + query.height >= minHeight && query.height <= maxHeight + ? await this.txsQuery(`tx.height=${query.height}`) + : []; + } else if (isSearchBySentFromOrToQuery(query)) { + throw new Error( + "This type of search query is not yet implemented. See https://github.com/cosmos/cosmjs/issues/533.", + ); + } else if (isSearchByTagsQuery(query)) { + throw new Error( + "This type of search query is not yet implemented. See https://github.com/cosmos/cosmjs/issues/532.", + ); + } else { + throw new Error("Unknown query type"); + } + + const filtered = txs.filter((tx) => tx.height >= minHeight && tx.height <= maxHeight); + return filtered; + } + + public disconnect(): void { + this.tmClient.disconnect(); + } + + public async broadcastTx(tx: Uint8Array): Promise { + const response = await this.tmClient.broadcastTxCommit({ tx }); + if (broadcastTxCommitSuccess(response)) { + return { + height: response.height, + transactionHash: toHex(response.hash).toUpperCase(), + rawLog: response.deliverTx?.log, + data: response.deliverTx?.data ? TxMsgData.decode(response.deliverTx?.data).data : undefined, + }; + } + return response.checkTx.code !== 0 + ? { + height: response.height, + code: response.checkTx.code, + transactionHash: toHex(response.hash).toUpperCase(), + rawLog: response.checkTx.log, + data: response.checkTx.data ? TxMsgData.decode(response.checkTx.data).data : undefined, + } + : { + height: response.height, + code: response.deliverTx?.code, + transactionHash: toHex(response.hash).toUpperCase(), + rawLog: response.deliverTx?.log, + data: response.deliverTx?.data ? TxMsgData.decode(response.deliverTx?.data).data : undefined, + }; + } + + public async getCodes(): Promise { + const { codeInfos } = await this.queryClient.unverified.wasm.listCodeInfo(); + return (codeInfos || []).map( + (entry: ICodeInfoResponse): Code => { + assert(entry.creator && entry.codeId && entry.dataHash, "entry incomplete"); + return { + id: entry.codeId.toNumber(), + creator: entry.creator, + checksum: toHex(entry.dataHash), + source: entry.source || undefined, + builder: entry.builder || undefined, + }; + }, + ); + } + + public async getCodeDetails(codeId: number): Promise { + const cached = this.codesCache.get(codeId); + if (cached) return cached; + + const { codeInfo, data } = await this.queryClient.unverified.wasm.getCode(codeId); + assert( + codeInfo && codeInfo.codeId && codeInfo.creator && codeInfo.dataHash && data, + "codeInfo missing or incomplete", + ); + const codeDetails: CodeDetails = { + id: codeInfo.codeId.toNumber(), + creator: codeInfo.creator, + checksum: toHex(codeInfo.dataHash), + source: codeInfo.source || undefined, + builder: codeInfo.builder || undefined, + data: data, + }; + this.codesCache.set(codeId, codeDetails); + return codeDetails; + } + + public async getContracts(codeId: number): Promise { + const { contractInfos } = await this.queryClient.unverified.wasm.listContractsByCodeId(codeId); + return (contractInfos || []).map( + ({ address, contractInfo }): Contract => { + assert(address, "address missing"); + assert( + contractInfo && contractInfo.codeId && contractInfo.creator && contractInfo.label, + "contractInfo missing or incomplete", + ); + return { + address: address, + codeId: contractInfo.codeId.toNumber(), + creator: contractInfo.creator, + admin: contractInfo.admin || undefined, + label: contractInfo.label, + }; + }, + ); + } + + /** + * Throws an error if no contract was found at the address + */ + public async getContract(address: string): Promise { + const { + address: retrievedAddress, + contractInfo, + } = await this.queryClient.unverified.wasm.getContractInfo(address); + if (!contractInfo) throw new Error(`No contract found at address "${address}"`); + assert(retrievedAddress, "address missing"); + assert(contractInfo.codeId && contractInfo.creator && contractInfo.label, "contractInfo incomplete"); + return { + address: retrievedAddress, + codeId: contractInfo.codeId.toNumber(), + creator: contractInfo.creator, + admin: contractInfo.admin || undefined, + label: contractInfo.label, + }; + } + + /** + * Throws an error if no contract was found at the address + */ + public async getContractCodeHistory(address: string): Promise { + const result = await this.queryClient.unverified.wasm.getContractCodeHistory(address); + if (!result) throw new Error(`No contract history found for address "${address}"`); + const operations: Record = { + [ContractCodeHistoryOperationType.CONTRACT_CODE_HISTORY_OPERATION_TYPE_INIT]: "Init", + [ContractCodeHistoryOperationType.CONTRACT_CODE_HISTORY_OPERATION_TYPE_GENESIS]: "Genesis", + [ContractCodeHistoryOperationType.CONTRACT_CODE_HISTORY_OPERATION_TYPE_MIGRATE]: "Migrate", + }; + return (result.entries || []).map( + (entry): ContractCodeHistoryEntry => { + assert(entry.operation && entry.codeId && entry.msg); + return { + operation: operations[entry.operation], + codeId: entry.codeId.toNumber(), + msg: JSON.parse(fromAscii(entry.msg)), + }; + }, + ); + } + + /** + * Returns the data at the key if present (raw contract dependent storage data) + * or null if no data at this key. + * + * Promise is rejected when contract does not exist. + */ + public async queryContractRaw(address: string, key: Uint8Array): Promise { + // just test contract existence + await this.getContract(address); + + const { data } = await this.queryClient.unverified.wasm.queryContractRaw(address, key); + return data ?? null; + } + + /** + * Makes a smart query on the contract, returns the parsed JSON document. + * + * Promise is rejected when contract does not exist. + * Promise is rejected for invalid query format. + * Promise is rejected for invalid response format. + */ + public async queryContractSmart(address: string, queryMsg: Record): Promise { + try { + return await this.queryClient.unverified.wasm.queryContractSmart(address, queryMsg); + } catch (error) { + if (error instanceof Error) { + if (error.message.startsWith("not found: contract")) { + throw new Error(`No contract found at address "${address}"`); + } else { + throw error; + } + } else { + throw error; + } + } + } + + private async txsQuery(query: string): Promise { + const params = { + query: query as QueryString, + }; + const results = await this.tmClient.txSearchAll(params); + return results.txs.map((tx) => { + return { + height: tx.height, + hash: toHex(tx.hash).toUpperCase(), + code: tx.result.code, + rawLog: tx.result.log || "", + tx: tx.tx, + }; + }); + } +} diff --git a/packages/cosmwasm-stargate/types/cosmwasmclient.d.ts b/packages/cosmwasm-stargate/types/cosmwasmclient.d.ts new file mode 100644 index 00000000..9630ed1c --- /dev/null +++ b/packages/cosmwasm-stargate/types/cosmwasmclient.d.ts @@ -0,0 +1,62 @@ +import { Code, CodeDetails, Contract, ContractCodeHistoryEntry, JsonObject } from "@cosmjs/cosmwasm"; +import { Block, Coin, SearchTxFilter, SearchTxQuery } from "@cosmjs/launchpad"; +import { + Account, + AuthExtension, + BankExtension, + BroadcastTxResponse, + IndexedTx, + QueryClient, + SequenceResponse, +} from "@cosmjs/stargate"; +import { Client as TendermintClient } from "@cosmjs/tendermint-rpc"; +import { WasmExtension } from "./queries"; +/** Use for testing only */ +export interface PrivateCosmWasmClient { + readonly tmClient: TendermintClient; + readonly queryClient: QueryClient & AuthExtension & BankExtension & WasmExtension; +} +export declare class CosmWasmClient { + private readonly tmClient; + private readonly queryClient; + private readonly codesCache; + private chainId; + static connect(endpoint: string): Promise; + protected constructor(tmClient: TendermintClient); + getChainId(): Promise; + getHeight(): Promise; + getAccount(searchAddress: string): Promise; + getSequence(address: string): Promise; + getBlock(height?: number): Promise; + getBalance(address: string, searchDenom: string): Promise; + searchTx(query: SearchTxQuery, filter?: SearchTxFilter): Promise; + disconnect(): void; + broadcastTx(tx: Uint8Array): Promise; + getCodes(): Promise; + getCodeDetails(codeId: number): Promise; + getContracts(codeId: number): Promise; + /** + * Throws an error if no contract was found at the address + */ + getContract(address: string): Promise; + /** + * Throws an error if no contract was found at the address + */ + getContractCodeHistory(address: string): Promise; + /** + * Returns the data at the key if present (raw contract dependent storage data) + * or null if no data at this key. + * + * Promise is rejected when contract does not exist. + */ + queryContractRaw(address: string, key: Uint8Array): Promise; + /** + * Makes a smart query on the contract, returns the parsed JSON document. + * + * Promise is rejected when contract does not exist. + * Promise is rejected for invalid query format. + * Promise is rejected for invalid response format. + */ + queryContractSmart(address: string, queryMsg: Record): Promise; + private txsQuery; +} From 479768beb303f0efcbc951cba4f4fa3a9be8dec7 Mon Sep 17 00:00:00 2001 From: willclarktech Date: Wed, 9 Dec 2020 12:38:55 +0000 Subject: [PATCH 13/33] cosmwasm-stargate: Add wasm queries --- .../cosmwasm-stargate/src/queries/index.ts | 1 + .../cosmwasm-stargate/src/queries/wasm.ts | 125 ++++++++++++++++++ .../types/queries/index.d.ts | 1 + .../cosmwasm-stargate/types/queries/wasm.d.ts | 64 +++++++++ 4 files changed, 191 insertions(+) create mode 100644 packages/cosmwasm-stargate/src/queries/index.ts create mode 100644 packages/cosmwasm-stargate/src/queries/wasm.ts create mode 100644 packages/cosmwasm-stargate/types/queries/index.d.ts create mode 100644 packages/cosmwasm-stargate/types/queries/wasm.d.ts diff --git a/packages/cosmwasm-stargate/src/queries/index.ts b/packages/cosmwasm-stargate/src/queries/index.ts new file mode 100644 index 00000000..c0692523 --- /dev/null +++ b/packages/cosmwasm-stargate/src/queries/index.ts @@ -0,0 +1 @@ +export { setupWasmExtension, WasmExtension } from "./wasm"; diff --git a/packages/cosmwasm-stargate/src/queries/wasm.ts b/packages/cosmwasm-stargate/src/queries/wasm.ts new file mode 100644 index 00000000..40dc6728 --- /dev/null +++ b/packages/cosmwasm-stargate/src/queries/wasm.ts @@ -0,0 +1,125 @@ +/* eslint-disable @typescript-eslint/naming-convention */ +import { toAscii } from "@cosmjs/encoding"; +import { QueryClient } from "@cosmjs/stargate"; +import Long from "long"; + +import { cosmwasm } from "../codec"; + +type IQueryAllContractStateResponse = cosmwasm.wasm.v1beta1.IQueryAllContractStateResponse; +type IQueryCodesResponse = cosmwasm.wasm.v1beta1.IQueryCodesResponse; +type IQueryCodeResponse = cosmwasm.wasm.v1beta1.IQueryCodeResponse; +type IQueryContractHistoryResponse = cosmwasm.wasm.v1beta1.IQueryContractHistoryResponse; +type IQueryContractInfoResponse = cosmwasm.wasm.v1beta1.IQueryContractInfoResponse; +type IQueryContractsByCodeResponse = cosmwasm.wasm.v1beta1.IQueryContractsByCodeResponse; +type IQueryRawContractStateResponse = cosmwasm.wasm.v1beta1.IQueryRawContractStateResponse; +type IQuerySmartContractStateResponse = cosmwasm.wasm.v1beta1.IQuerySmartContractStateResponse; + +const { Query } = cosmwasm.wasm.v1beta1; + +export interface WasmExtension { + readonly unverified: { + readonly wasm: { + readonly listCodeInfo: (paginationKey?: Uint8Array) => Promise; + /** + * Downloads the original wasm bytecode by code ID. + * + * Throws an error if no code with this id + */ + readonly getCode: (id: number) => Promise; + readonly listContractsByCodeId: ( + id: number, + paginationKey?: Uint8Array, + ) => Promise; + /** + * Returns null when contract was not found at this address. + */ + readonly getContractInfo: (address: string) => Promise; + /** + * Returns null when contract history was not found for this address. + */ + readonly getContractCodeHistory: ( + address: string, + paginationKey?: Uint8Array, + ) => Promise; + /** + * Returns all contract state. + * This is an empty array if no such contract, or contract has no data. + */ + readonly getAllContractState: ( + address: string, + paginationKey?: Uint8Array, + ) => Promise; + /** + * Returns the data at the key if present (unknown decoded json), + * or null if no data at this (contract address, key) pair + */ + readonly queryContractRaw: ( + address: string, + key: Uint8Array, + ) => Promise; + /** + * Makes a smart query on the contract and parses the response as JSON. + * Throws error if no such contract exists, the query format is invalid or the response is invalid. + */ + readonly queryContractSmart: ( + address: string, + query: Record, + ) => Promise; + }; + }; +} + +export function setupWasmExtension(base: QueryClient): WasmExtension { + const queryService = Query.create((method: any, requestData, callback) => { + const path = `/cosmwasm.wasm.v1beta1.Query/${method.name}`; + base + .queryUnverified(path, requestData) + .then((response) => callback(null, response)) + .catch((error) => callback(error)); + }); + return { + unverified: { + wasm: { + listCodeInfo: async (paginationKey?: Uint8Array) => { + const request = paginationKey ? { pagination: { key: paginationKey } } : {}; + return queryService.codes(request); + }, + getCode: async (id: number) => { + const request = { codeId: Long.fromNumber(id) }; + return queryService.code(request); + }, + listContractsByCodeId: async (id: number, paginationKey?: Uint8Array) => { + const pagination = paginationKey ? { pagination: { key: paginationKey } } : {}; + const request = { ...pagination, codeId: Long.fromNumber(id) }; + return queryService.contractsByCode(request); + }, + getContractInfo: async (address: string) => { + const request = { address: address }; + return queryService.contractInfo(request); + }, + + getContractCodeHistory: async (address: string, paginationKey?: Uint8Array) => { + const pagination = paginationKey ? { pagination: { key: paginationKey } } : {}; + const request = { ...pagination, address: address }; + return queryService.contractHistory(request); + }, + + getAllContractState: async (address: string, paginationKey?: Uint8Array) => { + const pagination = paginationKey ? { pagination: { key: paginationKey } } : {}; + const request = { ...pagination, address: address }; + return queryService.allContractState(request); + }, + + queryContractRaw: async (address: string, key: Uint8Array) => { + const request = { address: address, queryData: key }; + return queryService.rawContractState(request); + }, + + queryContractSmart: async (address: string, query: Record) => { + const request = { address: address, queryData: toAscii(JSON.stringify(query)) }; + return queryService.smartContractState(request); + }, + }, + }, + }; +} diff --git a/packages/cosmwasm-stargate/types/queries/index.d.ts b/packages/cosmwasm-stargate/types/queries/index.d.ts new file mode 100644 index 00000000..c0692523 --- /dev/null +++ b/packages/cosmwasm-stargate/types/queries/index.d.ts @@ -0,0 +1 @@ +export { setupWasmExtension, WasmExtension } from "./wasm"; diff --git a/packages/cosmwasm-stargate/types/queries/wasm.d.ts b/packages/cosmwasm-stargate/types/queries/wasm.d.ts new file mode 100644 index 00000000..3b6c1249 --- /dev/null +++ b/packages/cosmwasm-stargate/types/queries/wasm.d.ts @@ -0,0 +1,64 @@ +import { QueryClient } from "@cosmjs/stargate"; +import { cosmwasm } from "../codec"; +declare type IQueryAllContractStateResponse = cosmwasm.wasm.v1beta1.IQueryAllContractStateResponse; +declare type IQueryCodesResponse = cosmwasm.wasm.v1beta1.IQueryCodesResponse; +declare type IQueryCodeResponse = cosmwasm.wasm.v1beta1.IQueryCodeResponse; +declare type IQueryContractHistoryResponse = cosmwasm.wasm.v1beta1.IQueryContractHistoryResponse; +declare type IQueryContractInfoResponse = cosmwasm.wasm.v1beta1.IQueryContractInfoResponse; +declare type IQueryContractsByCodeResponse = cosmwasm.wasm.v1beta1.IQueryContractsByCodeResponse; +declare type IQueryRawContractStateResponse = cosmwasm.wasm.v1beta1.IQueryRawContractStateResponse; +declare type IQuerySmartContractStateResponse = cosmwasm.wasm.v1beta1.IQuerySmartContractStateResponse; +export interface WasmExtension { + readonly unverified: { + readonly wasm: { + readonly listCodeInfo: (paginationKey?: Uint8Array) => Promise; + /** + * Downloads the original wasm bytecode by code ID. + * + * Throws an error if no code with this id + */ + readonly getCode: (id: number) => Promise; + readonly listContractsByCodeId: ( + id: number, + paginationKey?: Uint8Array, + ) => Promise; + /** + * Returns null when contract was not found at this address. + */ + readonly getContractInfo: (address: string) => Promise; + /** + * Returns null when contract history was not found for this address. + */ + readonly getContractCodeHistory: ( + address: string, + paginationKey?: Uint8Array, + ) => Promise; + /** + * Returns all contract state. + * This is an empty array if no such contract, or contract has no data. + */ + readonly getAllContractState: ( + address: string, + paginationKey?: Uint8Array, + ) => Promise; + /** + * Returns the data at the key if present (unknown decoded json), + * or null if no data at this (contract address, key) pair + */ + readonly queryContractRaw: ( + address: string, + key: Uint8Array, + ) => Promise; + /** + * Makes a smart query on the contract and parses the response as JSON. + * Throws error if no such contract exists, the query format is invalid or the response is invalid. + */ + readonly queryContractSmart: ( + address: string, + query: Record, + ) => Promise; + }; + }; +} +export declare function setupWasmExtension(base: QueryClient): WasmExtension; +export {}; From 4b60663033003538ba0546d6f2b6580ef0205bfb Mon Sep 17 00:00:00 2001 From: willclarktech Date: Wed, 9 Dec 2020 12:39:15 +0000 Subject: [PATCH 14/33] cosmwasm-stargate: Add SigningCosmWasmClient --- .../src/signingcosmwasmclient.ts | 404 ++++++++++++++++++ .../types/signingcosmwasmclient.d.ts | 81 ++++ 2 files changed, 485 insertions(+) create mode 100644 packages/cosmwasm-stargate/src/signingcosmwasmclient.ts create mode 100644 packages/cosmwasm-stargate/types/signingcosmwasmclient.d.ts diff --git a/packages/cosmwasm-stargate/src/signingcosmwasmclient.ts b/packages/cosmwasm-stargate/src/signingcosmwasmclient.ts new file mode 100644 index 00000000..f310147b --- /dev/null +++ b/packages/cosmwasm-stargate/src/signingcosmwasmclient.ts @@ -0,0 +1,404 @@ +/* eslint-disable @typescript-eslint/naming-convention */ +import { + ChangeAdminResult, + CosmWasmFeeTable, + ExecuteResult, + InstantiateOptions, + InstantiateResult, + isValidBuilder, + MigrateResult, + UploadMeta, + UploadResult, +} from "@cosmjs/cosmwasm"; +import { sha256 } from "@cosmjs/crypto"; +import { fromBase64, toAscii, toHex } from "@cosmjs/encoding"; +import { + AccountData, + buildFeeTable, + Coin, + CosmosFeeTable, + encodeSecp256k1Pubkey, + GasLimits, + GasPrice, + logs, + makeSignDoc as makeSignDocAmino, + StdFee, +} from "@cosmjs/launchpad"; +import { Int53, Uint53 } from "@cosmjs/math"; +import { + EncodeObject, + encodePubkey, + isOfflineDirectSigner, + makeAuthInfoBytes, + makeSignDoc, + OfflineSigner, + Registry, +} from "@cosmjs/proto-signing"; +import { + BroadcastTxFailure, + BroadcastTxResponse, + codec, + getMsgType, + getMsgTypeUrl, + isBroadcastTxFailure, + parseRawLog, +} from "@cosmjs/stargate"; +import { adaptor34, Client as TendermintClient } from "@cosmjs/tendermint-rpc"; +import Long from "long"; +import pako from "pako"; + +import { cosmwasm } from "./codec"; +import { CosmWasmClient } from "./cosmwasmclient"; + +const { TxRaw } = codec.cosmos.tx.v1beta1; +const { SignMode } = codec.cosmos.tx.signing.v1beta1; +const { + MsgClearAdmin, + MsgExecuteContract, + MsgInstantiateContract, + MsgMigrateContract, + MsgStoreCode, + MsgUpdateAdmin, +} = cosmwasm.wasm.v1beta1; + +function prepareBuilder(builder: string | undefined): string { + if (builder === undefined) { + return ""; // normalization needed by backend + } else { + if (!isValidBuilder(builder)) throw new Error("The builder (Docker Hub image with tag) is not valid"); + return builder; + } +} + +const defaultGasPrice = GasPrice.fromString("0.025ucosm"); +const defaultGasLimits: GasLimits = { + upload: 1_500_000, + init: 500_000, + migrate: 200_000, + exec: 200_000, + send: 80_000, + changeAdmin: 80_000, +}; + +function createBroadcastTxErrorMessage(result: BroadcastTxFailure): string { + return `Error when broadcasting tx ${result.transactionHash} at height ${result.height}. Code: ${result.code}; Raw log: ${result.rawLog}`; +} + +function createDefaultRegistry(): Registry { + return new Registry([ + ["/cosmwasm.wasm.v1beta1.MsgClearAdmin", MsgClearAdmin], + ["/cosmwasm.wasm.v1beta1.MsgExecuteContract", MsgExecuteContract], + ["/cosmwasm.wasm.v1beta1.MsgMigrateContract", MsgMigrateContract], + ["/cosmwasm.wasm.v1beta1.MsgStoreCode", MsgStoreCode], + ["/cosmwasm.wasm.v1beta1.MsgInstantiateContract", MsgInstantiateContract], + ["/cosmwasm.wasm.v1beta1.MsgUpdateAdmin", MsgUpdateAdmin], + ]); +} + +export interface SigningCosmWasmClientOptions { + readonly registry?: Registry; + readonly gasPrice?: GasPrice; + readonly gasLimits?: GasLimits; +} + +/** Use for testing only */ +export interface PrivateSigningCosmWasmClient { + readonly fees: CosmWasmFeeTable; +} + +export class SigningCosmWasmClient extends CosmWasmClient { + private readonly fees: CosmosFeeTable; + private readonly registry: Registry; + private readonly signer: OfflineSigner; + + public static async connectWithWallet( + endpoint: string, + signer: OfflineSigner, + options: SigningCosmWasmClientOptions = {}, + ): Promise { + const tmClient = await TendermintClient.connect(endpoint, adaptor34); + return new SigningCosmWasmClient(tmClient, signer, options); + } + + private constructor( + tmClient: TendermintClient, + signer: OfflineSigner, + options: SigningCosmWasmClientOptions, + ) { + super(tmClient); + const { + registry = createDefaultRegistry(), + gasPrice = defaultGasPrice, + gasLimits = defaultGasLimits, + } = options; + this.fees = buildFeeTable(gasPrice, defaultGasLimits, gasLimits); + this.registry = registry; + this.signer = signer; + } + + /** Uploads code and returns a receipt, including the code ID */ + public async upload( + senderAddress: string, + wasmCode: Uint8Array, + meta: UploadMeta = {}, + memo = "", + ): Promise { + const source = meta.source || ""; + const builder = prepareBuilder(meta.builder); + const compressed = pako.gzip(wasmCode, { level: 9 }); + const storeCodeMsg = { + typeUrl: "/cosmwasm.wasm.v1beta1.MsgStoreCode", + value: MsgStoreCode.create({ + sender: senderAddress, + wasmByteCode: compressed, + source: source, + builder: builder, + }), + }; + + const result = await this.signAndBroadcast(senderAddress, [storeCodeMsg], this.fees.upload, memo); + if (isBroadcastTxFailure(result)) { + throw new Error(createBroadcastTxErrorMessage(result)); + } + const parsedLogs = parseRawLog(result.rawLog); + const codeIdAttr = logs.findAttribute(parsedLogs, "message", "code_id"); + return { + originalSize: wasmCode.length, + originalChecksum: toHex(sha256(wasmCode)), + compressedSize: compressed.length, + compressedChecksum: toHex(sha256(compressed)), + codeId: Number.parseInt(codeIdAttr.value, 10), + logs: parsedLogs, + transactionHash: result.transactionHash, + }; + } + + public async instantiate( + senderAddress: string, + codeId: number, + initMsg: Record, + label: string, + options: InstantiateOptions = {}, + ): Promise { + const instantiateMsg = { + typeUrl: "/cosmwasm.wasm.v1beta1.MsgInstantiateContract", + value: MsgInstantiateContract.create({ + sender: senderAddress, + codeId: Long.fromString(new Uint53(codeId).toString()), + label: label, + initMsg: toAscii(JSON.stringify(initMsg)), + initFunds: [...(options.transferAmount || [])], + admin: options.admin, + }), + }; + const result = await this.signAndBroadcast(senderAddress, [instantiateMsg], this.fees.init, options.memo); + if (isBroadcastTxFailure(result)) { + throw new Error(createBroadcastTxErrorMessage(result)); + } + const parsedLogs = parseRawLog(result.rawLog); + const contractAddressAttr = logs.findAttribute(parsedLogs, "message", "contract_address"); + return { + contractAddress: contractAddressAttr.value, + logs: parsedLogs, + transactionHash: result.transactionHash, + }; + } + + public async updateAdmin( + senderAddress: string, + contractAddress: string, + newAdmin: string, + memo = "", + ): Promise { + const updateAdminMsg = { + typeUrl: "/cosmwasm.wasm.v1beta1.MsgUpdateAdmin", + value: MsgUpdateAdmin.create({ + sender: senderAddress, + contract: contractAddress, + newAdmin: newAdmin, + }), + }; + const result = await this.signAndBroadcast(senderAddress, [updateAdminMsg], this.fees.changeAdmin, memo); + if (isBroadcastTxFailure(result)) { + throw new Error(createBroadcastTxErrorMessage(result)); + } + return { + logs: parseRawLog(result.rawLog), + transactionHash: result.transactionHash, + }; + } + + public async clearAdmin( + senderAddress: string, + contractAddress: string, + memo = "", + ): Promise { + const clearAdminMsg = { + typeUrl: "/cosmwasm.wasm.v1beta1.MsgClearAdmin", + value: MsgClearAdmin.create({ + sender: senderAddress, + contract: contractAddress, + }), + }; + const result = await this.signAndBroadcast(senderAddress, [clearAdminMsg], this.fees.changeAdmin, memo); + if (isBroadcastTxFailure(result)) { + throw new Error(createBroadcastTxErrorMessage(result)); + } + return { + logs: parseRawLog(result.rawLog), + transactionHash: result.transactionHash, + }; + } + + public async migrate( + senderAddress: string, + contractAddress: string, + codeId: number, + migrateMsg: Record, + memo = "", + ): Promise { + const msg = { + typeUrl: "/cosmwasm.wasm.v1beta1.MsgMigrateContract", + value: MsgMigrateContract.create({ + sender: senderAddress, + contract: contractAddress, + codeId: Long.fromString(new Uint53(codeId).toString()), + migrateMsg: toAscii(JSON.stringify(migrateMsg)), + }), + }; + const result = await this.signAndBroadcast(senderAddress, [msg], this.fees.migrate, memo); + if (isBroadcastTxFailure(result)) { + throw new Error(createBroadcastTxErrorMessage(result)); + } + return { + logs: parseRawLog(result.rawLog), + transactionHash: result.transactionHash, + }; + } + + public async execute( + senderAddress: string, + contractAddress: string, + handleMsg: Record, + memo = "", + transferAmount?: readonly Coin[], + ): Promise { + const executeMsg = { + typeUrl: "/cosmwasm.wasm.v1beta1.MsgExecuteContract", + value: MsgExecuteContract.create({ + sender: senderAddress, + contract: contractAddress, + msg: toAscii(JSON.stringify(handleMsg)), + sentFunds: [...(transferAmount || [])], + }), + }; + const result = await this.signAndBroadcast(senderAddress, [executeMsg], this.fees.exec, memo); + if (isBroadcastTxFailure(result)) { + throw new Error(createBroadcastTxErrorMessage(result)); + } + return { + logs: parseRawLog(result.rawLog), + transactionHash: result.transactionHash, + }; + } + + public async sendTokens( + senderAddress: string, + recipientAddress: string, + transferAmount: readonly Coin[], + memo = "", + ): Promise { + const sendMsg = { + typeUrl: "/cosmos.bank.v1beta1.MsgSend", + value: { + fromAddress: senderAddress, + toAddress: recipientAddress, + amount: transferAmount, + }, + }; + return this.signAndBroadcast(senderAddress, [sendMsg], this.fees.send, memo); + } + + public async signAndBroadcast( + address: string, + messages: readonly EncodeObject[], + fee: StdFee, + memo = "", + ): Promise { + const accountFromSigner = (await this.signer.getAccounts()).find( + (account: AccountData) => account.address === address, + ); + if (!accountFromSigner) { + throw new Error("Failed to retrieve account from signer"); + } + const pubkey = encodeSecp256k1Pubkey(accountFromSigner.pubkey); + const accountFromChain = await this.getAccount(address); + if (!accountFromChain) { + throw new Error("Account not found"); + } + const { accountNumber, sequence } = accountFromChain; + if (!pubkey) { + throw new Error("Pubkey not known"); + } + const chainId = await this.getChainId(); + const pubkeyAny = encodePubkey(pubkey); + const txBody = { + messages: messages, + memo: memo, + }; + const txBodyBytes = this.registry.encode({ + typeUrl: "/cosmos.tx.v1beta1.TxBody", + value: txBody, + }); + const gasLimit = Int53.fromString(fee.gas).toNumber(); + + if (isOfflineDirectSigner(this.signer)) { + const authInfoBytes = makeAuthInfoBytes([pubkeyAny], fee.amount, gasLimit, sequence); + const signDoc = makeSignDoc(txBodyBytes, authInfoBytes, chainId, accountNumber); + const { signature, signed } = await this.signer.signDirect(address, signDoc); + const txRaw = TxRaw.create({ + bodyBytes: signed.bodyBytes, + authInfoBytes: signed.authInfoBytes, + signatures: [fromBase64(signature.signature)], + }); + const signedTx = Uint8Array.from(TxRaw.encode(txRaw).finish()); + return this.broadcastTx(signedTx); + } + + // Amino signer + const signMode = SignMode.SIGN_MODE_LEGACY_AMINO_JSON; + const msgs = messages.map((msg) => ({ + type: getMsgType(msg.typeUrl), + value: msg.value, + })); + const signDoc = makeSignDocAmino(msgs, fee, chainId, memo, accountNumber, sequence); + const { signature, signed } = await this.signer.signAmino(address, signDoc); + const signedTxBody = { + messages: signed.msgs.map((msg) => ({ + typeUrl: getMsgTypeUrl(msg.type), + value: msg.value, + })), + memo: signed.memo, + }; + const signedTxBodyBytes = this.registry.encode({ + typeUrl: "/cosmos.tx.v1beta1.TxBody", + value: signedTxBody, + }); + const signedGasLimit = Int53.fromString(signed.fee.gas).toNumber(); + const signedSequence = Int53.fromString(signed.sequence).toNumber(); + const signedAuthInfoBytes = makeAuthInfoBytes( + [pubkeyAny], + signed.fee.amount, + signedGasLimit, + signedSequence, + signMode, + ); + const txRaw = TxRaw.create({ + bodyBytes: signedTxBodyBytes, + authInfoBytes: signedAuthInfoBytes, + signatures: [fromBase64(signature.signature)], + }); + const signedTx = Uint8Array.from(TxRaw.encode(txRaw).finish()); + return this.broadcastTx(signedTx); + } +} diff --git a/packages/cosmwasm-stargate/types/signingcosmwasmclient.d.ts b/packages/cosmwasm-stargate/types/signingcosmwasmclient.d.ts new file mode 100644 index 00000000..1b7cc383 --- /dev/null +++ b/packages/cosmwasm-stargate/types/signingcosmwasmclient.d.ts @@ -0,0 +1,81 @@ +import { + ChangeAdminResult, + CosmWasmFeeTable, + ExecuteResult, + InstantiateOptions, + InstantiateResult, + MigrateResult, + UploadMeta, + UploadResult, +} from "@cosmjs/cosmwasm"; +import { Coin, CosmosFeeTable, GasLimits, GasPrice, StdFee } from "@cosmjs/launchpad"; +import { EncodeObject, OfflineSigner, Registry } from "@cosmjs/proto-signing"; +import { BroadcastTxResponse } from "@cosmjs/stargate"; +import { CosmWasmClient } from "./cosmwasmclient"; +export interface SigningCosmWasmClientOptions { + readonly registry?: Registry; + readonly gasPrice?: GasPrice; + readonly gasLimits?: GasLimits; +} +/** Use for testing only */ +export interface PrivateSigningCosmWasmClient { + readonly fees: CosmWasmFeeTable; +} +export declare class SigningCosmWasmClient extends CosmWasmClient { + private readonly fees; + private readonly registry; + private readonly signer; + static connectWithWallet( + endpoint: string, + signer: OfflineSigner, + options?: SigningCosmWasmClientOptions, + ): Promise; + private constructor(); + /** Uploads code and returns a receipt, including the code ID */ + upload( + senderAddress: string, + wasmCode: Uint8Array, + meta?: UploadMeta, + memo?: string, + ): Promise; + instantiate( + senderAddress: string, + codeId: number, + initMsg: Record, + label: string, + options?: InstantiateOptions, + ): Promise; + updateAdmin( + senderAddress: string, + contractAddress: string, + newAdmin: string, + memo?: string, + ): Promise; + clearAdmin(senderAddress: string, contractAddress: string, memo?: string): Promise; + migrate( + senderAddress: string, + contractAddress: string, + codeId: number, + migrateMsg: Record, + memo?: string, + ): Promise; + execute( + senderAddress: string, + contractAddress: string, + handleMsg: Record, + memo?: string, + transferAmount?: readonly Coin[], + ): Promise; + sendTokens( + senderAddress: string, + recipientAddress: string, + transferAmount: readonly Coin[], + memo?: string, + ): Promise; + signAndBroadcast( + address: string, + messages: readonly EncodeObject[], + fee: StdFee, + memo?: string, + ): Promise; +} From 9055623d26f7d015777ceb8d2d19c5cd64dc4f10 Mon Sep 17 00:00:00 2001 From: willclarktech Date: Wed, 9 Dec 2020 12:39:39 +0000 Subject: [PATCH 15/33] cosmwasm-stargate: Add index.ts --- packages/cosmwasm-stargate/src/index.ts | 3 +++ packages/cosmwasm-stargate/types/index.d.ts | 3 +++ 2 files changed, 6 insertions(+) create mode 100644 packages/cosmwasm-stargate/src/index.ts create mode 100644 packages/cosmwasm-stargate/types/index.d.ts diff --git a/packages/cosmwasm-stargate/src/index.ts b/packages/cosmwasm-stargate/src/index.ts new file mode 100644 index 00000000..46bf2155 --- /dev/null +++ b/packages/cosmwasm-stargate/src/index.ts @@ -0,0 +1,3 @@ +export * as codec from "./codec"; +export { CosmWasmClient } from "./cosmwasmclient"; +export { SigningCosmWasmClient, SigningCosmWasmClientOptions } from "./signingcosmwasmclient"; diff --git a/packages/cosmwasm-stargate/types/index.d.ts b/packages/cosmwasm-stargate/types/index.d.ts new file mode 100644 index 00000000..46bf2155 --- /dev/null +++ b/packages/cosmwasm-stargate/types/index.d.ts @@ -0,0 +1,3 @@ +export * as codec from "./codec"; +export { CosmWasmClient } from "./cosmwasmclient"; +export { SigningCosmWasmClient, SigningCosmWasmClientOptions } from "./signingcosmwasmclient"; From 9e48836439cdaafefe2daa8889f7ed74581f747b Mon Sep 17 00:00:00 2001 From: willclarktech Date: Wed, 9 Dec 2020 12:40:04 +0000 Subject: [PATCH 16/33] cosmwasm-stargate: Add test utils and data --- .../src/testdata/contract.json | 4 + .../cosmwasm-stargate/src/testutils.spec.ts | 302 ++++++++++++++++++ 2 files changed, 306 insertions(+) create mode 100644 packages/cosmwasm-stargate/src/testdata/contract.json create mode 100644 packages/cosmwasm-stargate/src/testutils.spec.ts diff --git a/packages/cosmwasm-stargate/src/testdata/contract.json b/packages/cosmwasm-stargate/src/testdata/contract.json new file mode 100644 index 00000000..05aaa05f --- /dev/null +++ b/packages/cosmwasm-stargate/src/testdata/contract.json @@ -0,0 +1,4 @@ +{ + "// source": "https://github.com/CosmWasm/cosmwasm/releases/download/v0.12.0/hackatom.wasm", + "data": "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" +} diff --git a/packages/cosmwasm-stargate/src/testutils.spec.ts b/packages/cosmwasm-stargate/src/testutils.spec.ts new file mode 100644 index 00000000..5f630021 --- /dev/null +++ b/packages/cosmwasm-stargate/src/testutils.spec.ts @@ -0,0 +1,302 @@ +/* eslint-disable @typescript-eslint/naming-convention */ +import { Bip39, EnglishMnemonic, Random, Secp256k1, Slip10, Slip10Curve } from "@cosmjs/crypto"; +import { Bech32, fromBase64 } from "@cosmjs/encoding"; +import { + AminoSignResponse, + coins, + makeCosmoshubPath, + Secp256k1HdWallet, + StdSignDoc, +} from "@cosmjs/launchpad"; +import { DirectSecp256k1HdWallet, DirectSignResponse, makeAuthInfoBytes } from "@cosmjs/proto-signing"; +import { + AuthExtension, + BankExtension, + codec, + QueryClient, + setupAuthExtension, + setupBankExtension, +} from "@cosmjs/stargate"; +import { adaptor34, Client as TendermintClient } from "@cosmjs/tendermint-rpc"; + +import { setupWasmExtension, WasmExtension } from "./queries"; +import hackatom from "./testdata/contract.json"; + +type ISignDoc = codec.cosmos.tx.v1beta1.ISignDoc; +const { AuthInfo, TxBody } = codec.cosmos.tx.v1beta1; +const { SignMode } = codec.cosmos.tx.signing.v1beta1; + +/** An internal testing type. SigningCosmWasmClient has a similar but different interface */ +export interface ContractUploadInstructions { + /** The wasm bytecode */ + readonly data: Uint8Array; + readonly source?: string; + readonly builder?: string; +} + +export const wasmd = { + blockTime: 1_000, // ms + chainId: "testing", + endpoint: "http://localhost:26659", + prefix: "wasm", + validator: { + address: "wasmvaloper1m4vhsgne6u74ff78vf0tvkjq3q4hjf9vjfrmy2", + }, +}; + +export function getHackatom(): ContractUploadInstructions { + return { + data: fromBase64(hackatom.data), + source: "https://crates.io/api/v1/crates/hackatom/not-yet-released/download", + builder: "cosmwasm/rust-optimizer:0.9.1", + }; +} + +export function makeRandomAddress(): string { + return Bech32.encode("wasm", Random.getBytes(20)); +} + +export const tendermintIdMatcher = /^[0-9A-F]{64}$/; +/** @see https://rgxdb.com/r/1NUN74O6 */ +export const base64Matcher = /^(?:[a-zA-Z0-9+/]{4})*(?:|(?:[a-zA-Z0-9+/]{3}=)|(?:[a-zA-Z0-9+/]{2}==)|(?:[a-zA-Z0-9+/]{1}===))$/; +// https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki#bech32 +export const bech32AddressMatcher = /^[\x21-\x7e]{1,83}1[02-9ac-hj-np-z]{38}$/; + +export const alice = { + mnemonic: "enlist hip relief stomach skate base shallow young switch frequent cry park", + pubkey0: { + type: "tendermint/PubKeySecp256k1", + value: "A9cXhWb8ZpqCzkA8dQCPV29KdeRLV3rUYxrkHudLbQtS", + }, + address0: "wasm14qemq0vw6y3gc3u3e0aty2e764u4gs5lndxgyk", + address1: "wasm1hhg2rlu9jscacku2wwckws7932qqqu8xm5ca8y", + address2: "wasm1xv9tklw7d82sezh9haa573wufgy59vmwnxhnsl", + address3: "wasm17yg9mssjenmc3jkqth6ulcwj9cxujrxxg9nmzk", + address4: "wasm1f7j7ryulwjfe9ljplvhtcaxa6wqgula3nh873j", +}; + +/** Unused account */ +export const unused = { + pubkey: { + type: "tendermint/PubKeySecp256k1", + value: "ArkCaFUJ/IH+vKBmNRCdUVl3mCAhbopk9jjW4Ko4OfRQ", + }, + address: "wasm1cjsxept9rkggzxztslae9ndgpdyt240842kpxh", + accountNumber: 16, + sequence: 0, +}; + +export const validator = { + /** From first gentx's auth_info.signer_infos in scripts/wasmd/template/.wasmd/config/genesis.json */ + pubkey: { + type: "tendermint/PubKeySecp256k1", + value: "AsYCD9IZsnY3BhSrR3k7mf5iaJD0KkQdwqzLLl9PT+05", + }, + /** delegator_address from /cosmos.staking.v1beta1.MsgCreateValidator in scripts/wasmd/template/.wasmd/config/genesis.json */ + delegatorAddress: "wasm1m4vhsgne6u74ff78vf0tvkjq3q4hjf9v84k82s", + /** validator_address from /cosmos.staking.v1beta1.MsgCreateValidator in scripts/wasmd/template/.wasmd/config/genesis.json */ + validatorAddress: "wasmvaloper1m4vhsgne6u74ff78vf0tvkjq3q4hjf9vjfrmy2", + accountNumber: 0, + sequence: 1, +}; + +/** Deployed as part of scripts/wasmd/init.sh */ +export const deployedHackatom = { + codeId: 1, + source: "https://crates.io/api/v1/crates/hackatom/not-yet-released/download", + builder: "cosmwasm/rust-optimizer:0.9.1", + checksum: "3defc33a41f58c71d38b176d521c411d8e74d26403fde7660486930c7579a016", + instances: [ + { + beneficiary: alice.address0, + address: "wasm18vd8fpwxzck93qlwghaj6arh4p7c5n89k7fvsl", + label: "From deploy_hackatom.js (0)", + }, + { + beneficiary: alice.address1, + address: "wasm1hqrdl6wstt8qzshwc6mrumpjk9338k0lffu40x", + label: "From deploy_hackatom.js (1)", + }, + { + beneficiary: alice.address2, + address: "wasm18r5szma8hm93pvx6lwpjwyxruw27e0k5kjkyan", + label: "From deploy_hackatom.js (2)", + }, + ], +}; + +// /** Deployed as part of scripts/wasmd/init.sh */ +// export const deployedErc20 = { +// codeId: 2, +// source: "https://crates.io/api/v1/crates/cw-erc20/0.7.0/download", +// builder: "cosmwasm/rust-optimizer:0.10.4", +// checksum: "d04368320ad55089384adb171aaea39e43d710d7608829adba0300ed30aa2988", +// instances: [ +// // TODO: Update this address +// "cosmos1vjecguu37pmd577339wrdp208ddzymkudc46zj", // HASH +// // TODO: Update this address +// "cosmos1ym5m5dw7pttft5w430nxx6uat8f84ck4algmhg", // ISA +// // TODO: Update this address +// "cosmos1gv07846a3867ezn3uqkk082c5ftke7hpllcu8q", // JADE +// ], +// }; + +// /** Deployed as part of scripts/wasmd/init.sh */ +// export const deployedCw3 = { +// codeId: 3, +// source: "https://crates.io/api/v1/crates/cw3-fixed-multisig/0.3.1/download", +// builder: "cosmwasm/rust-optimizer:0.10.4", +// instances: [ +// // TODO: Update this address +// "cosmos1xqeym28j9xgv0p93pwwt6qcxf9tdvf9zddufdw", // Multisig (1/3) +// // TODO: Update this address +// "cosmos1jka38ckju8cpjap00jf9xdvdyttz9caujtd6t5", // Multisig (2/3) +// // TODO: Update this address +// "cosmos12dnl585uxzddjw9hw4ca694f054shgpgr4zg80", // Multisig (uneven weights) +// ], +// }; + +// /** Deployed as part of scripts/wasmd/init.sh */ +// export const deployedCw1 = { +// codeId: 4, +// source: "https://crates.io/api/v1/crates/cw1-subkeys/0.3.1/download", +// builder: "cosmwasm/rust-optimizer:0.10.4", +// // TODO: Update this address +// instances: ["cosmos1vs2vuks65rq7xj78mwtvn7vvnm2gn7ad5me0d2"], +// }; + +export function wasmdEnabled(): boolean { + return !!process.env.WASMD_ENABLED; +} + +export function pendingWithoutWasmd(): void { + if (!wasmdEnabled()) { + return pending("Set WASMD_ENABLED to enable Wasmd-based tests"); + } +} + +// export function erc20Enabled(): boolean { +// return !!process.env.ERC20_ENABLED; +// } + +// export function pendingWithoutErc20(): void { +// if (!erc20Enabled()) { +// return pending("Set ERC20_ENABLED to enable ERC20-based tests"); +// } +// } + +// export function cw3Enabled(): boolean { +// return !!process.env.CW3_ENABLED; +// } + +// export function pendingWithoutCw3(): void { +// if (!cw3Enabled()) { +// return pending("Set CW3_ENABLED to enable CW3-based tests"); +// } +// } + +// export function cw1Enabled(): boolean { +// return !!process.env.CW1_ENABLED; +// } + +// export function pendingWithoutCw1(): void { +// if (!cw1Enabled()) { +// return pending("Set CW1_ENABLED to enable CW1-based tests"); +// } +// } + +/** Returns first element. Throws if array has a different length than 1. */ +export function fromOneElementArray(elements: ArrayLike): T { + if (elements.length !== 1) throw new Error(`Expected exactly one element but got ${elements.length}`); + return elements[0]; +} + +export async function makeWasmClient( + endpoint: string, +): Promise { + const tmClient = await TendermintClient.connect(endpoint, adaptor34); + return QueryClient.withExtensions(tmClient, setupAuthExtension, setupBankExtension, setupWasmExtension); +} + +/** + * A class for testing clients using an Amino signer which modifies the transaction it receives before signing + */ +export class ModifyingSecp256k1HdWallet extends Secp256k1HdWallet { + public static async fromMnemonic( + mnemonic: string, + hdPath = makeCosmoshubPath(0), + prefix = "cosmos", + ): Promise { + const mnemonicChecked = new EnglishMnemonic(mnemonic); + const seed = await Bip39.mnemonicToSeed(mnemonicChecked); + const { privkey } = Slip10.derivePath(Slip10Curve.Secp256k1, seed, hdPath); + const uncompressed = (await Secp256k1.makeKeypair(privkey)).pubkey; + return new ModifyingSecp256k1HdWallet( + mnemonicChecked, + hdPath, + privkey, + Secp256k1.compressPubkey(uncompressed), + prefix, + ); + } + + public async signAmino(signerAddress: string, signDoc: StdSignDoc): Promise { + const modifiedSignDoc = { + ...signDoc, + fee: { + amount: coins(3000, "ucosm"), + gas: "333333", + }, + memo: "This was modified", + }; + return super.signAmino(signerAddress, modifiedSignDoc); + } +} + +/** + * A class for testing clients using a direct signer which modifies the transaction it receives before signing + */ +export class ModifyingDirectSecp256k1HdWallet extends DirectSecp256k1HdWallet { + public static async fromMnemonic( + mnemonic: string, + hdPath = makeCosmoshubPath(0), + prefix = "cosmos", + ): Promise { + const mnemonicChecked = new EnglishMnemonic(mnemonic); + const seed = await Bip39.mnemonicToSeed(mnemonicChecked); + const { privkey } = Slip10.derivePath(Slip10Curve.Secp256k1, seed, hdPath); + const uncompressed = (await Secp256k1.makeKeypair(privkey)).pubkey; + return new ModifyingDirectSecp256k1HdWallet( + mnemonicChecked, + hdPath, + privkey, + Secp256k1.compressPubkey(uncompressed), + prefix, + ); + } + + public async signDirect(address: string, signDoc: ISignDoc): Promise { + const txBody = TxBody.decode(signDoc.bodyBytes!); + const modifiedTxBody = TxBody.create({ + ...txBody, + memo: "This was modified", + }); + const authInfo = AuthInfo.decode(signDoc.authInfoBytes!); + const pubkeys = authInfo.signerInfos.map((signerInfo) => signerInfo.publicKey!); + const sequence = authInfo.signerInfos[0].sequence!.toNumber(); + const modifiedFeeAmount = coins(3000, "ucosm"); + const modifiedGasLimit = 333333; + const modifiedSignDoc = { + ...signDoc, + bodyBytes: Uint8Array.from(TxBody.encode(modifiedTxBody).finish()), + authInfoBytes: makeAuthInfoBytes( + pubkeys, + modifiedFeeAmount, + modifiedGasLimit, + sequence, + SignMode.SIGN_MODE_DIRECT, + ), + }; + return super.signDirect(address, modifiedSignDoc); + } +} From ef307f53cc5e2b74c9f69c0f60df776e69d8cba1 Mon Sep 17 00:00:00 2001 From: willclarktech Date: Wed, 9 Dec 2020 12:40:21 +0000 Subject: [PATCH 17/33] cosmwasm-stargate: Add wasm query tests --- .../src/queries/wasm.spec.ts | 447 ++++++++++++++++++ 1 file changed, 447 insertions(+) create mode 100644 packages/cosmwasm-stargate/src/queries/wasm.spec.ts diff --git a/packages/cosmwasm-stargate/src/queries/wasm.spec.ts b/packages/cosmwasm-stargate/src/queries/wasm.spec.ts new file mode 100644 index 00000000..a2696082 --- /dev/null +++ b/packages/cosmwasm-stargate/src/queries/wasm.spec.ts @@ -0,0 +1,447 @@ +/* eslint-disable @typescript-eslint/naming-convention */ +import { sha256 } from "@cosmjs/crypto"; +import { fromAscii, fromHex, toAscii, toHex } from "@cosmjs/encoding"; +import { Coin, coin, coins, logs, StdFee } from "@cosmjs/launchpad"; +import { DirectSecp256k1HdWallet, OfflineDirectSigner, Registry } from "@cosmjs/proto-signing"; +import { + assertIsBroadcastTxSuccess, + BroadcastTxResponse, + parseRawLog, + SigningStargateClient, +} from "@cosmjs/stargate"; +import { assert } from "@cosmjs/utils"; +import Long from "long"; + +import { cosmwasm } from "../codec"; +import { SigningCosmWasmClient } from "../signingcosmwasmclient"; +import { + alice, + base64Matcher, + bech32AddressMatcher, + ContractUploadInstructions, + getHackatom, + makeRandomAddress, + makeWasmClient, + pendingWithoutWasmd, + wasmd, + wasmdEnabled, +} from "../testutils.spec"; + +const { MsgExecuteContract, MsgInstantiateContract, MsgStoreCode } = cosmwasm.wasm.v1beta1; + +const registry = new Registry([ + ["/cosmwasm.wasm.v1beta1.MsgExecuteContract", MsgExecuteContract], + ["/cosmwasm.wasm.v1beta1.MsgStoreCode", MsgStoreCode], + ["/cosmwasm.wasm.v1beta1.MsgInstantiateContract", MsgInstantiateContract], +]); + +async function uploadContract( + signer: OfflineDirectSigner, + contract: ContractUploadInstructions, +): Promise { + const memo = "My first contract on chain"; + const theMsg = { + typeUrl: "/cosmwasm.wasm.v1beta1.MsgStoreCode", + value: MsgStoreCode.create({ + sender: alice.address0, + wasmByteCode: contract.data, + source: contract.source || "", + builder: contract.builder || "", + }), + }; + const fee: StdFee = { + amount: coins(5000000, "ucosm"), + gas: "89000000", + }; + const firstAddress = (await signer.getAccounts())[0].address; + const client = await SigningStargateClient.connectWithWallet(wasmd.endpoint, signer, { registry }); + return client.signAndBroadcast(firstAddress, [theMsg], fee, memo); +} + +async function instantiateContract( + signer: OfflineDirectSigner, + codeId: number, + beneficiaryAddress: string, + transferAmount?: readonly Coin[], +): Promise { + const memo = "Create an escrow instance"; + const theMsg = { + typeUrl: "/cosmwasm.wasm.v1beta1.MsgInstantiateContract", + value: MsgInstantiateContract.create({ + sender: alice.address0, + codeId: Long.fromNumber(codeId), + label: "my escrow", + initMsg: toAscii( + JSON.stringify({ + verifier: alice.address0, + beneficiary: beneficiaryAddress, + }), + ), + initFunds: transferAmount ? [...transferAmount] : [], + }), + }; + const fee: StdFee = { + amount: coins(5000000, "ucosm"), + gas: "89000000", + }; + + const firstAddress = (await signer.getAccounts())[0].address; + const client = await SigningStargateClient.connectWithWallet(wasmd.endpoint, signer, { registry }); + return client.signAndBroadcast(firstAddress, [theMsg], fee, memo); +} + +async function executeContract( + signer: OfflineDirectSigner, + contractAddress: string, + msg: Record, +): Promise { + const memo = "Time for action"; + const theMsg = { + typeUrl: "/cosmwasm.wasm.v1beta1.MsgExecuteContract", + value: MsgExecuteContract.create({ + sender: alice.address0, + contract: contractAddress, + msg: toAscii(JSON.stringify(msg)), + sentFunds: [], + }), + }; + const fee: StdFee = { + amount: coins(5000000, "ucosm"), + gas: "89000000", + }; + + const firstAddress = (await signer.getAccounts())[0].address; + const client = await SigningCosmWasmClient.connectWithWallet(wasmd.endpoint, signer, { registry }); + return client.signAndBroadcast(firstAddress, [theMsg], fee, memo); +} + +describe("WasmExtension", () => { + const hackatom = getHackatom(); + const hackatomConfigKey = toAscii("config"); + let hackatomCodeId: number | undefined; + let hackatomContractAddress: string | undefined; + + beforeAll(async () => { + if (wasmdEnabled()) { + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, "wasm"); + const result = await uploadContract(wallet, hackatom); + assertIsBroadcastTxSuccess(result); + hackatomCodeId = Number.parseInt( + JSON.parse(result.rawLog!)[0].events[0].attributes.find( + (attribute: any) => attribute.key === "code_id", + ).value, + 10, + ); + + const instantiateResult = await instantiateContract(wallet, hackatomCodeId, makeRandomAddress()); + assertIsBroadcastTxSuccess(instantiateResult); + hackatomContractAddress = JSON.parse(instantiateResult.rawLog!)[0] + .events.find((event: any) => event.type === "message") + .attributes.find((attribute: any) => attribute.key === "contract_address").value; + } + }); + + describe("listCodeInfo", () => { + it("has recently uploaded contract as last entry", async () => { + pendingWithoutWasmd(); + assert(hackatomCodeId); + const client = await makeWasmClient(wasmd.endpoint); + const { codeInfos } = await client.unverified.wasm.listCodeInfo(); + assert(codeInfos); + const lastCode = codeInfos[codeInfos.length - 1]; + expect(lastCode.codeId!.toNumber()).toEqual(hackatomCodeId); + expect(lastCode.creator).toEqual(alice.address0); + expect(lastCode.source).toEqual(hackatom.source); + expect(lastCode.builder).toEqual(hackatom.builder); + expect(toHex(lastCode.dataHash!)).toEqual(toHex(sha256(hackatom.data))); + }); + }); + + describe("getCode", () => { + it("contains fill code information", async () => { + pendingWithoutWasmd(); + assert(hackatomCodeId); + const client = await makeWasmClient(wasmd.endpoint); + const { codeInfo, data } = await client.unverified.wasm.getCode(hackatomCodeId); + expect(codeInfo!.codeId!.toNumber()).toEqual(hackatomCodeId); + expect(codeInfo!.creator).toEqual(alice.address0); + expect(codeInfo!.source).toEqual(hackatom.source); + expect(codeInfo!.builder).toEqual(hackatom.builder); + expect(toHex(codeInfo!.dataHash!)).toEqual(toHex(sha256(hackatom.data))); + expect(data).toEqual(hackatom.data); + }); + }); + + // TODO: move listContractsByCodeId tests out of here + describe("getContractInfo", () => { + it("works", async () => { + pendingWithoutWasmd(); + assert(hackatomCodeId); + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, "wasm"); + const client = await makeWasmClient(wasmd.endpoint); + const beneficiaryAddress = makeRandomAddress(); + const transferAmount = coins(707707, "ucosm"); + + // create new instance and compare before and after + const { contractInfos: existingContractInfos } = await client.unverified.wasm.listContractsByCodeId( + hackatomCodeId, + ); + assert(existingContractInfos); + for (const { address, contractInfo } of existingContractInfos) { + expect(address).toMatch(bech32AddressMatcher); + expect(contractInfo!.codeId!.toNumber()).toEqual(hackatomCodeId); + expect(contractInfo!.creator).toMatch(bech32AddressMatcher); + expect(contractInfo!.label).toMatch(/^.+$/); + } + + const result = await instantiateContract(wallet, hackatomCodeId, beneficiaryAddress, transferAmount); + assertIsBroadcastTxSuccess(result); + const myAddress = JSON.parse(result.rawLog!)[0] + .events.find((event: any) => event.type === "message") + .attributes!.find((attribute: any) => attribute.key === "contract_address").value; + + const { contractInfos: newContractInfos } = await client.unverified.wasm.listContractsByCodeId( + hackatomCodeId, + ); + assert(newContractInfos); + expect(newContractInfos.length).toEqual(existingContractInfos.length + 1); + const newContract = newContractInfos[newContractInfos.length - 1]; + expect({ ...newContract.contractInfo }).toEqual({ + codeId: Long.fromNumber(hackatomCodeId, true), + creator: alice.address0, + label: "my escrow", + }); + + const { contractInfo } = await client.unverified.wasm.getContractInfo(myAddress); + assert(contractInfo); + expect({ ...contractInfo }).toEqual({ + codeId: Long.fromNumber(hackatomCodeId, true), + creator: alice.address0, + label: "my escrow", + }); + expect(contractInfo.admin).toEqual(""); + }); + + it("rejects for non-existent address", async () => { + pendingWithoutWasmd(); + assert(hackatomCodeId); + const client = await makeWasmClient(wasmd.endpoint); + const nonExistentAddress = makeRandomAddress(); + await expectAsync(client.unverified.wasm.getContractInfo(nonExistentAddress)).toBeRejectedWithError( + /not found/i, + ); + }); + }); + + describe("getContractCodeHistory", () => { + it("can list contract history", async () => { + pendingWithoutWasmd(); + assert(hackatomCodeId); + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, "wasm"); + const client = await makeWasmClient(wasmd.endpoint); + const beneficiaryAddress = makeRandomAddress(); + const transferAmount = coins(707707, "ucosm"); + + // create new instance and compare before and after + const result = await instantiateContract(wallet, hackatomCodeId, beneficiaryAddress, transferAmount); + assertIsBroadcastTxSuccess(result); + + const myAddress = JSON.parse(result.rawLog!)[0] + .events.find((event: any) => event.type === "message") + .attributes!.find((attribute: any) => attribute.key === "contract_address").value; + + const history = await client.unverified.wasm.getContractCodeHistory(myAddress); + assert(history.entries); + expect(history.entries).toContain( + jasmine.objectContaining({ + codeId: Long.fromNumber(hackatomCodeId, true), + operation: + cosmwasm.wasm.v1beta1.ContractCodeHistoryOperationType.CONTRACT_CODE_HISTORY_OPERATION_TYPE_INIT, + msg: toAscii( + JSON.stringify({ + verifier: alice.address0, + beneficiary: beneficiaryAddress, + }), + ), + }), + ); + }); + + it("returns empty list for non-existent address", async () => { + pendingWithoutWasmd(); + assert(hackatomCodeId); + const client = await makeWasmClient(wasmd.endpoint); + const nonExistentAddress = makeRandomAddress(); + const history = await client.unverified.wasm.getContractCodeHistory(nonExistentAddress); + expect(history.entries).toEqual([]); + }); + }); + + describe("getAllContractState", () => { + it("can get all state", async () => { + pendingWithoutWasmd(); + assert(hackatomContractAddress); + const client = await makeWasmClient(wasmd.endpoint); + const { models } = await client.unverified.wasm.getAllContractState(hackatomContractAddress); + assert(models); + expect(models.length).toEqual(1); + const data = models[0]; + expect(data.key).toEqual(hackatomConfigKey); + const value = JSON.parse(fromAscii(data.value!)); + expect(value.verifier).toMatch(base64Matcher); + expect(value.beneficiary).toMatch(base64Matcher); + }); + + it("rejects for non-existent address", async () => { + pendingWithoutWasmd(); + const client = await makeWasmClient(wasmd.endpoint); + const nonExistentAddress = makeRandomAddress(); + await expectAsync(client.unverified.wasm.getAllContractState(nonExistentAddress)).toBeRejectedWithError( + /not found/i, + ); + }); + }); + + describe("queryContractRaw", () => { + it("can query by key", async () => { + pendingWithoutWasmd(); + assert(hackatomContractAddress); + const client = await makeWasmClient(wasmd.endpoint); + const raw = await client.unverified.wasm.queryContractRaw(hackatomContractAddress, hackatomConfigKey); + assert(raw.data, "must get result"); + const model = JSON.parse(fromAscii(raw.data)); + expect(model.verifier).toMatch(base64Matcher); + expect(model.beneficiary).toMatch(base64Matcher); + }); + + it("returns empty object for missing key", async () => { + pendingWithoutWasmd(); + assert(hackatomContractAddress); + const client = await makeWasmClient(wasmd.endpoint); + const response = await client.unverified.wasm.queryContractRaw( + hackatomContractAddress, + fromHex("cafe0dad"), + ); + expect({ ...response }).toEqual({}); + }); + + it("returns null for non-existent address", async () => { + pendingWithoutWasmd(); + const client = await makeWasmClient(wasmd.endpoint); + const nonExistentAddress = makeRandomAddress(); + await expectAsync( + client.unverified.wasm.queryContractRaw(nonExistentAddress, hackatomConfigKey), + ).toBeRejectedWithError(/not found/i); + }); + }); + + describe("queryContractSmart", () => { + it("can make smart queries", async () => { + pendingWithoutWasmd(); + assert(hackatomContractAddress); + const client = await makeWasmClient(wasmd.endpoint); + const request = { verifier: {} }; + const { data } = await client.unverified.wasm.queryContractSmart(hackatomContractAddress, request); + assert(data); + const parsedData = JSON.parse(fromAscii(data)); + expect(parsedData).toEqual({ verifier: alice.address0 }); + }); + + it("throws for invalid query requests", async () => { + pendingWithoutWasmd(); + assert(hackatomContractAddress); + const client = await makeWasmClient(wasmd.endpoint); + const request = { nosuchkey: {} }; + await expectAsync( + client.unverified.wasm.queryContractSmart(hackatomContractAddress, request), + ).toBeRejectedWithError(/Error parsing into type hackatom::contract::QueryMsg: unknown variant/i); + }); + + it("throws for non-existent address", async () => { + pendingWithoutWasmd(); + const client = await makeWasmClient(wasmd.endpoint); + const nonExistentAddress = makeRandomAddress(); + const request = { verifier: {} }; + await expectAsync( + client.unverified.wasm.queryContractSmart(nonExistentAddress, request), + ).toBeRejectedWithError(/not found/i); + }); + }); + + describe("broadcastTx", () => { + it("can upload, instantiate and execute wasm", async () => { + pendingWithoutWasmd(); + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, wasmd.prefix); + const client = await makeWasmClient(wasmd.endpoint); + + const transferAmount = [coin(1234, "ucosm"), coin(321, "ustake")]; + const beneficiaryAddress = makeRandomAddress(); + + let codeId: number; + + // upload + { + const result = await uploadContract(wallet, getHackatom()); + assertIsBroadcastTxSuccess(result); + const parsedLogs = logs.parseLogs(parseRawLog(result.rawLog)); + const codeIdAttr = logs.findAttribute(parsedLogs, "message", "code_id"); + codeId = Number.parseInt(codeIdAttr.value, 10); + expect(codeId).toBeGreaterThanOrEqual(1); + expect(codeId).toBeLessThanOrEqual(200); + expect(result.data!.length).toEqual(1); + expect({ ...result.data![0] }).toEqual({ + msgType: "store-code", + data: toAscii(`${codeId}`), + }); + } + + let contractAddress: string; + + // instantiate + { + const result = await instantiateContract(wallet, codeId, beneficiaryAddress, transferAmount); + assertIsBroadcastTxSuccess(result); + const parsedLogs = logs.parseLogs(parseRawLog(result.rawLog)); + const contractAddressAttr = logs.findAttribute(parsedLogs, "message", "contract_address"); + contractAddress = contractAddressAttr.value; + const amountAttr = logs.findAttribute(parsedLogs, "transfer", "amount"); + expect(amountAttr.value).toEqual("1234ucosm,321ustake"); + expect(result.data!.length).toEqual(1); + expect({ ...result.data![0] }).toEqual({ + msgType: "instantiate", + data: toAscii(contractAddress), + }); + + const balanceUcosm = await client.bank.balance(contractAddress, "ucosm"); + expect(balanceUcosm).toEqual(transferAmount[0]); + const balanceUstake = await client.bank.balance(contractAddress, "ustake"); + expect(balanceUstake).toEqual(transferAmount[1]); + } + + // execute + { + const result = await executeContract(wallet, contractAddress, { release: {} }); + assertIsBroadcastTxSuccess(result); + expect(result.data!.length).toEqual(1); + expect({ ...result.data![0] }).toEqual({ + msgType: "execute", + data: fromHex("F00BAA"), + }); + const parsedLogs = logs.parseLogs(parseRawLog(result.rawLog)); + const wasmEvent = parsedLogs.find(() => true)?.events.find((e) => e.type === "wasm"); + assert(wasmEvent, "Event of type wasm expected"); + expect(wasmEvent.attributes).toContain({ key: "action", value: "release" }); + expect(wasmEvent.attributes).toContain({ + key: "destination", + value: beneficiaryAddress, + }); + + // Verify token transfer from contract to beneficiary + const beneficiaryBalanceUcosm = await client.bank.balance(beneficiaryAddress, "ucosm"); + expect(beneficiaryBalanceUcosm).toEqual(transferAmount[0]); + const beneficiaryBalanceUstake = await client.bank.balance(beneficiaryAddress, "ustake"); + expect(beneficiaryBalanceUstake).toEqual(transferAmount[1]); + } + }); + }); +}); From 1aa70a97f7e1f7ebc5e833da4bf9aaae4262f9b7 Mon Sep 17 00:00:00 2001 From: willclarktech Date: Wed, 9 Dec 2020 12:40:36 +0000 Subject: [PATCH 18/33] cosmwasm-stargate: Add CosmWasmClient tests --- .../src/cosmwasmclient.spec.ts | 437 ++++++++++++++++++ 1 file changed, 437 insertions(+) create mode 100644 packages/cosmwasm-stargate/src/cosmwasmclient.spec.ts diff --git a/packages/cosmwasm-stargate/src/cosmwasmclient.spec.ts b/packages/cosmwasm-stargate/src/cosmwasmclient.spec.ts new file mode 100644 index 00000000..e1a6f6eb --- /dev/null +++ b/packages/cosmwasm-stargate/src/cosmwasmclient.spec.ts @@ -0,0 +1,437 @@ +/* eslint-disable @typescript-eslint/naming-convention */ +import { Code } from "@cosmjs/cosmwasm"; +import { sha256 } from "@cosmjs/crypto"; +import { Bech32, fromAscii, fromBase64, fromHex, toAscii, toBase64 } from "@cosmjs/encoding"; +import { coins, logs, StdFee } from "@cosmjs/launchpad"; +import { Int53 } from "@cosmjs/math"; +import { + DirectSecp256k1HdWallet, + encodePubkey, + makeAuthInfoBytes, + makeSignDoc, + Registry, +} from "@cosmjs/proto-signing"; +import { assertIsBroadcastTxSuccess, codec, parseRawLog } from "@cosmjs/stargate"; +import { assert, sleep } from "@cosmjs/utils"; +import { ReadonlyDate } from "readonly-date"; + +import { CosmWasmClient, PrivateCosmWasmClient } from "./cosmwasmclient"; +import { SigningCosmWasmClient } from "./signingcosmwasmclient"; +import { + alice, + deployedHackatom, + getHackatom, + makeRandomAddress, + pendingWithoutWasmd, + tendermintIdMatcher, + unused, + wasmd, + wasmdEnabled, +} from "./testutils.spec"; + +const { TxRaw } = codec.cosmos.tx.v1beta1; + +interface HackatomInstance { + readonly initMsg: { + readonly verifier: string; + readonly beneficiary: string; + }; + readonly address: string; +} + +describe("CosmWasmClient", () => { + describe("connect", () => { + it("can be constructed", async () => { + const client = await CosmWasmClient.connect(wasmd.endpoint); + expect(client).toBeTruthy(); + }); + }); + + describe("getChainId", () => { + it("works", async () => { + pendingWithoutWasmd(); + const client = await CosmWasmClient.connect(wasmd.endpoint); + expect(await client.getChainId()).toEqual(wasmd.chainId); + }); + + it("caches chain ID", async () => { + pendingWithoutWasmd(); + const client = await CosmWasmClient.connect(wasmd.endpoint); + const openedClient = (client as unknown) as PrivateCosmWasmClient; + const getCodeSpy = spyOn(openedClient.tmClient, "status").and.callThrough(); + + expect(await client.getChainId()).toEqual(wasmd.chainId); // from network + expect(await client.getChainId()).toEqual(wasmd.chainId); // from cache + + expect(getCodeSpy).toHaveBeenCalledTimes(1); + }); + }); + + describe("getHeight", () => { + it("works", async () => { + pendingWithoutWasmd(); + const client = await CosmWasmClient.connect(wasmd.endpoint); + + const height1 = await client.getHeight(); + expect(height1).toBeGreaterThan(0); + + await sleep(wasmd.blockTime * 1.4); // tolerate chain being 40% slower than expected + + const height2 = await client.getHeight(); + expect(height2).toBeGreaterThanOrEqual(height1 + 1); + expect(height2).toBeLessThanOrEqual(height1 + 2); + }); + }); + + describe("getSequence", () => { + it("works", async () => { + pendingWithoutWasmd(); + const client = await CosmWasmClient.connect(wasmd.endpoint); + expect(await client.getSequence(unused.address)).toEqual({ + accountNumber: unused.accountNumber, + sequence: unused.sequence, + }); + }); + + it("returns null for missing accounts", async () => { + pendingWithoutWasmd(); + const client = await CosmWasmClient.connect(wasmd.endpoint); + const missing = makeRandomAddress(); + expect(await client.getSequence(missing)).toBeNull(); + }); + }); + + describe("getAccount", () => { + it("works", async () => { + pendingWithoutWasmd(); + const client = await CosmWasmClient.connect(wasmd.endpoint); + expect(await client.getAccount(unused.address)).toEqual({ + address: unused.address, + accountNumber: unused.accountNumber, + sequence: unused.sequence, + pubkey: null, + }); + }); + + it("returns null for missing accounts", async () => { + pendingWithoutWasmd(); + const client = await CosmWasmClient.connect(wasmd.endpoint); + const missing = makeRandomAddress(); + expect(await client.getAccount(missing)).toBeNull(); + }); + }); + + describe("getBlock", () => { + it("works for latest block", async () => { + pendingWithoutWasmd(); + const client = await CosmWasmClient.connect(wasmd.endpoint); + const response = await client.getBlock(); + + // id + expect(response.id).toMatch(tendermintIdMatcher); + + // header + expect(response.header.height).toBeGreaterThanOrEqual(1); + expect(response.header.chainId).toEqual(await client.getChainId()); + expect(new ReadonlyDate(response.header.time).getTime()).toBeLessThan(ReadonlyDate.now()); + expect(new ReadonlyDate(response.header.time).getTime()).toBeGreaterThanOrEqual( + ReadonlyDate.now() - 5_000, + ); + + // txs + expect(Array.isArray(response.txs)).toEqual(true); + }); + + it("works for block by height", async () => { + pendingWithoutWasmd(); + const client = await CosmWasmClient.connect(wasmd.endpoint); + const height = (await client.getBlock()).header.height; + const response = await client.getBlock(height - 1); + + // id + expect(response.id).toMatch(tendermintIdMatcher); + + // header + expect(response.header.height).toEqual(height - 1); + expect(response.header.chainId).toEqual(await client.getChainId()); + expect(new ReadonlyDate(response.header.time).getTime()).toBeLessThan(ReadonlyDate.now()); + expect(new ReadonlyDate(response.header.time).getTime()).toBeGreaterThanOrEqual( + ReadonlyDate.now() - 5_000, + ); + + // txs + expect(Array.isArray(response.txs)).toEqual(true); + }); + }); + + describe("broadcastTx", () => { + it("works", async () => { + pendingWithoutWasmd(); + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, wasmd.prefix); + const client = await CosmWasmClient.connect(wasmd.endpoint); + const registry = new Registry(); + + const memo = "My first contract on chain"; + const sendMsg = { + typeUrl: "/cosmos.bank.v1beta1.MsgSend", + value: { + fromAddress: alice.address0, + toAddress: makeRandomAddress(), + amount: coins(1234567, "ucosm"), + }, + }; + const fee: StdFee = { + amount: coins(5000, "ucosm"), + gas: "890000", + }; + + const chainId = await client.getChainId(); + const sequenceResponse = await client.getSequence(alice.address0); + assert(sequenceResponse); + const { accountNumber, sequence } = sequenceResponse; + const pubkeyAny = encodePubkey(alice.pubkey0); + const txBody = { + messages: [sendMsg], + memo: memo, + }; + const txBodyBytes = registry.encode({ + typeUrl: "/cosmos.tx.v1beta1.TxBody", + value: txBody, + }); + const gasLimit = Int53.fromString(fee.gas).toNumber(); + const authInfoBytes = makeAuthInfoBytes([pubkeyAny], fee.amount, gasLimit, sequence); + const signDoc = makeSignDoc(txBodyBytes, authInfoBytes, chainId, accountNumber); + const { signed, signature } = await wallet.signDirect(alice.address0, signDoc); + const txRaw = TxRaw.create({ + bodyBytes: signed.bodyBytes, + authInfoBytes: signed.authInfoBytes, + signatures: [fromBase64(signature.signature)], + }); + const signedTx = Uint8Array.from(TxRaw.encode(txRaw).finish()); + const result = await client.broadcastTx(signedTx); + assertIsBroadcastTxSuccess(result); + const amountAttr = logs.findAttribute(parseRawLog(result.rawLog), "transfer", "amount"); + expect(amountAttr.value).toEqual("1234567ucosm"); + expect(result.transactionHash).toMatch(/^[0-9A-F]{64}$/); + }); + }); + + describe("getCodes", () => { + it("works", async () => { + pendingWithoutWasmd(); + const client = await CosmWasmClient.connect(wasmd.endpoint); + const result = await client.getCodes(); + expect(result.length).toBeGreaterThanOrEqual(1); + const [first] = result; + expect(first).toEqual({ + id: deployedHackatom.codeId, + source: deployedHackatom.source, + builder: deployedHackatom.builder, + checksum: deployedHackatom.checksum, + creator: alice.address0, + }); + }); + }); + + describe("getCodeDetails", () => { + it("works", async () => { + pendingWithoutWasmd(); + const client = await CosmWasmClient.connect(wasmd.endpoint); + const result = await client.getCodeDetails(1); + + const expectedInfo: Code = { + id: deployedHackatom.codeId, + source: deployedHackatom.source, + builder: deployedHackatom.builder, + checksum: deployedHackatom.checksum, + creator: alice.address0, + }; + + // check info + expect(result).toEqual(jasmine.objectContaining(expectedInfo)); + // check data + expect(sha256(result.data)).toEqual(fromHex(expectedInfo.checksum)); + }); + + it("caches downloads", async () => { + pendingWithoutWasmd(); + const client = await CosmWasmClient.connect(wasmd.endpoint); + const openedClient = (client as unknown) as PrivateCosmWasmClient; + const getCodeSpy = spyOn(openedClient.queryClient.unverified.wasm, "getCode").and.callThrough(); + + const result1 = await client.getCodeDetails(deployedHackatom.codeId); // from network + const result2 = await client.getCodeDetails(deployedHackatom.codeId); // from cache + expect(result2).toEqual(result1); + + expect(getCodeSpy).toHaveBeenCalledTimes(1); + }); + }); + + describe("getContracts", () => { + it("works", async () => { + pendingWithoutWasmd(); + const client = await CosmWasmClient.connect(wasmd.endpoint); + const result = await client.getContracts(1); + expect(result.length).toBeGreaterThanOrEqual(3); + const [zero, one, two] = result; + expect(zero).toEqual({ + address: deployedHackatom.instances[0].address, + codeId: deployedHackatom.codeId, + creator: alice.address0, + admin: undefined, + label: deployedHackatom.instances[0].label, + }); + expect(one).toEqual({ + address: deployedHackatom.instances[1].address, + codeId: deployedHackatom.codeId, + creator: alice.address0, + admin: undefined, + label: deployedHackatom.instances[1].label, + }); + expect(two).toEqual({ + address: deployedHackatom.instances[2].address, + codeId: deployedHackatom.codeId, + creator: alice.address0, + admin: alice.address1, + label: deployedHackatom.instances[2].label, + }); + }); + }); + + describe("getContract", () => { + it("works for instance without admin", async () => { + pendingWithoutWasmd(); + const client = await CosmWasmClient.connect(wasmd.endpoint); + const zero = await client.getContract(deployedHackatom.instances[0].address); + expect(zero).toEqual({ + address: deployedHackatom.instances[0].address, + codeId: deployedHackatom.codeId, + creator: alice.address0, + label: deployedHackatom.instances[0].label, + admin: undefined, + }); + }); + + it("works for instance with admin", async () => { + pendingWithoutWasmd(); + const client = await CosmWasmClient.connect(wasmd.endpoint); + const two = await client.getContract(deployedHackatom.instances[2].address); + expect(two).toEqual( + jasmine.objectContaining({ + address: deployedHackatom.instances[2].address, + codeId: deployedHackatom.codeId, + creator: alice.address0, + label: deployedHackatom.instances[2].label, + admin: alice.address1, + }), + ); + }); + }); + + describe("queryContractRaw", () => { + const configKey = toAscii("config"); + const otherKey = toAscii("this_does_not_exist"); + let contract: HackatomInstance | undefined; + + beforeAll(async () => { + if (wasmdEnabled()) { + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, wasmd.prefix); + const client = await SigningCosmWasmClient.connectWithWallet(wasmd.endpoint, wallet); + const { codeId } = await client.upload(alice.address0, getHackatom().data); + const initMsg = { verifier: makeRandomAddress(), beneficiary: makeRandomAddress() }; + const { contractAddress } = await client.instantiate( + alice.address0, + codeId, + initMsg, + "random hackatom", + ); + contract = { initMsg: initMsg, address: contractAddress }; + } + }); + + it("can query existing key", async () => { + pendingWithoutWasmd(); + assert(contract); + + const client = await CosmWasmClient.connect(wasmd.endpoint); + const raw = await client.queryContractRaw(contract.address, configKey); + assert(raw, "must get result"); + expect(JSON.parse(fromAscii(raw))).toEqual({ + verifier: toBase64(Bech32.decode(contract.initMsg.verifier).data), + beneficiary: toBase64(Bech32.decode(contract.initMsg.beneficiary).data), + funder: toBase64(Bech32.decode(alice.address0).data), + }); + }); + + it("can query non-existent key", async () => { + pendingWithoutWasmd(); + assert(contract); + + const client = await CosmWasmClient.connect(wasmd.endpoint); + const raw = await client.queryContractRaw(contract.address, otherKey); + assert(raw, "must get result"); + expect(Uint8Array.from(raw)).toEqual(new Uint8Array()); + }); + + it("errors for non-existent contract", async () => { + pendingWithoutWasmd(); + assert(contract); + + const nonExistentAddress = makeRandomAddress(); + const client = await CosmWasmClient.connect(wasmd.endpoint); + await expectAsync(client.queryContractRaw(nonExistentAddress, configKey)).toBeRejectedWithError( + /not found/i, + ); + }); + }); + + describe("queryContractSmart", () => { + let contract: HackatomInstance | undefined; + + beforeAll(async () => { + if (wasmdEnabled()) { + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, wasmd.prefix); + const client = await SigningCosmWasmClient.connectWithWallet(wasmd.endpoint, wallet); + const { codeId } = await client.upload(alice.address0, getHackatom().data); + const initMsg = { verifier: makeRandomAddress(), beneficiary: makeRandomAddress() }; + const { contractAddress } = await client.instantiate( + alice.address0, + codeId, + initMsg, + "a different hackatom", + ); + contract = { initMsg: initMsg, address: contractAddress }; + } + }); + + it("works", async () => { + pendingWithoutWasmd(); + assert(contract); + + const client = await CosmWasmClient.connect(wasmd.endpoint); + const { data } = await client.queryContractSmart(contract.address, { verifier: {} }); + const parsedData = JSON.parse(fromAscii(data)); + expect(parsedData).toEqual({ verifier: contract.initMsg.verifier }); + }); + + it("errors for malformed query message", async () => { + pendingWithoutWasmd(); + assert(contract); + + const client = await CosmWasmClient.connect(wasmd.endpoint); + await expectAsync(client.queryContractSmart(contract.address, { broken: {} })).toBeRejectedWithError( + /Error parsing into type hackatom::contract::QueryMsg: unknown variant/i, + ); + }); + + it("errors for non-existent contract", async () => { + pendingWithoutWasmd(); + + const nonExistentAddress = makeRandomAddress(); + const client = await CosmWasmClient.connect(wasmd.endpoint); + await expectAsync( + client.queryContractSmart(nonExistentAddress, { verifier: {} }), + ).toBeRejectedWithError(/not found/i); + }); + }); +}); From 1c4a2d9d4c852017220b77c8ac9ac5f054847488 Mon Sep 17 00:00:00 2001 From: willclarktech Date: Wed, 9 Dec 2020 12:40:44 +0000 Subject: [PATCH 19/33] cosmwasm-stargate: Add SigningCosmWasmClient tests --- .../src/signingcosmwasmclient.spec.ts | 583 ++++++++++++++++++ 1 file changed, 583 insertions(+) create mode 100644 packages/cosmwasm-stargate/src/signingcosmwasmclient.spec.ts diff --git a/packages/cosmwasm-stargate/src/signingcosmwasmclient.spec.ts b/packages/cosmwasm-stargate/src/signingcosmwasmclient.spec.ts new file mode 100644 index 00000000..7f21df86 --- /dev/null +++ b/packages/cosmwasm-stargate/src/signingcosmwasmclient.spec.ts @@ -0,0 +1,583 @@ +/* eslint-disable @typescript-eslint/naming-convention */ +import { UploadMeta } from "@cosmjs/cosmwasm"; +import { sha256 } from "@cosmjs/crypto"; +import { toHex } from "@cosmjs/encoding"; +import { coin, coins, GasPrice } from "@cosmjs/launchpad"; +import { Coin, cosmosField, DirectSecp256k1HdWallet, registered, Registry } from "@cosmjs/proto-signing"; +import { assertIsBroadcastTxSuccess, codec } from "@cosmjs/stargate"; +import { assert, sleep } from "@cosmjs/utils"; +import Long from "long"; +import { Message } from "protobufjs"; + +import { PrivateSigningCosmWasmClient, SigningCosmWasmClient } from "./signingcosmwasmclient"; +import { + alice, + getHackatom, + makeRandomAddress, + makeWasmClient, + ModifyingDirectSecp256k1HdWallet, + ModifyingSecp256k1HdWallet, + pendingWithoutWasmd, + unused, + validator, + wasmd, +} from "./testutils.spec"; + +const { MsgDelegate } = codec.cosmos.staking.v1beta1; +const { Tx } = codec.cosmos.tx.v1beta1; + +describe("SigningCosmWasmClient", () => { + describe("connectWithWallet", () => { + it("can be constructed", async () => { + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, wasmd.prefix); + const client = await SigningCosmWasmClient.connectWithWallet(wasmd.endpoint, wallet); + expect(client).toBeTruthy(); + }); + + it("can be constructed with custom gas price", async () => { + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, wasmd.prefix); + const gasPrice = GasPrice.fromString("3.14utest"); + const client = await SigningCosmWasmClient.connectWithWallet(wasmd.endpoint, wallet, { gasPrice }); + const openedClient = (client as unknown) as PrivateSigningCosmWasmClient; + expect(openedClient.fees).toEqual({ + upload: { + amount: coins(4710000, "utest"), + gas: "1500000", + }, + init: { + amount: coins(1570000, "utest"), + gas: "500000", + }, + migrate: { + amount: coins(628000, "utest"), + gas: "200000", + }, + exec: { + amount: coins(628000, "utest"), + gas: "200000", + }, + send: { + amount: coins(251200, "utest"), + gas: "80000", + }, + changeAdmin: { + amount: coins(251200, "utest"), + gas: "80000", + }, + }); + }); + + it("can be constructed with custom gas limits", async () => { + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, wasmd.prefix); + const gasLimits = { + send: 160000, + }; + const client = await SigningCosmWasmClient.connectWithWallet(wasmd.endpoint, wallet, { gasLimits }); + const openedClient = (client as unknown) as PrivateSigningCosmWasmClient; + expect(openedClient.fees).toEqual({ + upload: { + amount: coins(37500, "ucosm"), + gas: "1500000", + }, + init: { + amount: coins(12500, "ucosm"), + gas: "500000", + }, + migrate: { + amount: coins(5000, "ucosm"), + gas: "200000", + }, + exec: { + amount: coins(5000, "ucosm"), + gas: "200000", + }, + send: { + amount: coins(4000, "ucosm"), + gas: "160000", + }, + changeAdmin: { + amount: coins(2000, "ucosm"), + gas: "80000", + }, + }); + }); + + it("can be constructed with custom gas price and gas limits", async () => { + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, wasmd.prefix); + const gasPrice = GasPrice.fromString("3.14utest"); + const gasLimits = { + send: 160000, + }; + const client = await SigningCosmWasmClient.connectWithWallet(wasmd.endpoint, wallet, { + gasPrice, + gasLimits, + }); + const openedClient = (client as unknown) as PrivateSigningCosmWasmClient; + expect(openedClient.fees).toEqual({ + upload: { + amount: coins(4710000, "utest"), + gas: "1500000", + }, + init: { + amount: coins(1570000, "utest"), + gas: "500000", + }, + migrate: { + amount: coins(628000, "utest"), + gas: "200000", + }, + exec: { + amount: coins(628000, "utest"), + gas: "200000", + }, + send: { + amount: coins(502400, "utest"), + gas: "160000", + }, + changeAdmin: { + amount: coins(251200, "utest"), + gas: "80000", + }, + }); + }); + }); + + describe("upload", () => { + it("works", async () => { + pendingWithoutWasmd(); + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, wasmd.prefix); + const client = await SigningCosmWasmClient.connectWithWallet(wasmd.endpoint, wallet); + const wasm = getHackatom().data; + const { + codeId, + originalChecksum, + originalSize, + compressedChecksum, + compressedSize, + } = await client.upload(alice.address0, wasm); + expect(originalChecksum).toEqual(toHex(sha256(wasm))); + expect(originalSize).toEqual(wasm.length); + expect(compressedChecksum).toMatch(/^[0-9a-f]{64}$/); + expect(compressedSize).toBeLessThan(wasm.length * 0.5); + expect(codeId).toBeGreaterThanOrEqual(1); + }); + + it("can set builder and source", async () => { + pendingWithoutWasmd(); + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, wasmd.prefix); + const client = await SigningCosmWasmClient.connectWithWallet(wasmd.endpoint, wallet); + const hackatom = getHackatom(); + const meta: UploadMeta = { + source: "https://crates.io/api/v1/crates/cw-nameservice/0.1.0/download", + builder: "confio/cosmwasm-opt:0.6.2", + }; + const { codeId } = await client.upload(alice.address0, hackatom.data, meta); + const codeDetails = await client.getCodeDetails(codeId); + expect(codeDetails.source).toEqual(meta.source); + expect(codeDetails.builder).toEqual(meta.builder); + }); + }); + + describe("instantiate", () => { + it("works with transfer amount", async () => { + pendingWithoutWasmd(); + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, wasmd.prefix); + const client = await SigningCosmWasmClient.connectWithWallet(wasmd.endpoint, wallet); + const { codeId } = await client.upload(alice.address0, getHackatom().data); + const transferAmount = [coin(1234, "ucosm"), coin(321, "ustake")]; + const beneficiaryAddress = makeRandomAddress(); + const { contractAddress } = await client.instantiate( + alice.address0, + codeId, + { + verifier: alice.address0, + beneficiary: beneficiaryAddress, + }, + "My cool label", + { + memo: "Let's see if the memo is used", + transferAmount, + }, + ); + const wasmClient = await makeWasmClient(wasmd.endpoint); + const ucosmBalance = await wasmClient.bank.balance(contractAddress, "ucosm"); + expect(ucosmBalance).toEqual(transferAmount[0]); + const ustakeBalance = await wasmClient.bank.balance(contractAddress, "ustake"); + expect(ustakeBalance).toEqual(transferAmount[1]); + }); + + it("works with admin", async () => { + pendingWithoutWasmd(); + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, wasmd.prefix); + const client = await SigningCosmWasmClient.connectWithWallet(wasmd.endpoint, wallet); + const { codeId } = await client.upload(alice.address0, getHackatom().data); + const beneficiaryAddress = makeRandomAddress(); + const { contractAddress } = await client.instantiate( + alice.address0, + codeId, + { + verifier: alice.address0, + beneficiary: beneficiaryAddress, + }, + "My cool label", + { admin: unused.address }, + ); + const wasmClient = await makeWasmClient(wasmd.endpoint); + const { contractInfo } = await wasmClient.unverified.wasm.getContractInfo(contractAddress); + assert(contractInfo); + expect(contractInfo.admin).toEqual(unused.address); + }); + + it("can instantiate one code multiple times", async () => { + pendingWithoutWasmd(); + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, wasmd.prefix); + const client = await SigningCosmWasmClient.connectWithWallet(wasmd.endpoint, wallet); + const { codeId } = await client.upload(alice.address0, getHackatom().data); + const contractAddress1 = await client.instantiate( + alice.address0, + codeId, + { + verifier: alice.address0, + beneficiary: makeRandomAddress(), + }, + "contract 1", + ); + const contractAddress2 = await client.instantiate( + alice.address0, + codeId, + { + verifier: alice.address0, + beneficiary: makeRandomAddress(), + }, + "contract 2", + ); + expect(contractAddress1).not.toEqual(contractAddress2); + }); + }); + + describe("updateAdmin", () => { + it("can update an admin", async () => { + pendingWithoutWasmd(); + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, wasmd.prefix); + const client = await SigningCosmWasmClient.connectWithWallet(wasmd.endpoint, wallet); + const { codeId } = await client.upload(alice.address0, getHackatom().data); + const beneficiaryAddress = makeRandomAddress(); + const { contractAddress } = await client.instantiate( + alice.address0, + codeId, + { + verifier: alice.address0, + beneficiary: beneficiaryAddress, + }, + "My cool label", + { + admin: alice.address0, + }, + ); + const wasmClient = await makeWasmClient(wasmd.endpoint); + const { contractInfo: contractInfo1 } = await wasmClient.unverified.wasm.getContractInfo( + contractAddress, + ); + assert(contractInfo1); + expect(contractInfo1.admin).toEqual(alice.address0); + + await client.updateAdmin(alice.address0, contractAddress, unused.address); + const { contractInfo: contractInfo2 } = await wasmClient.unverified.wasm.getContractInfo( + contractAddress, + ); + assert(contractInfo2); + expect(contractInfo2.admin).toEqual(unused.address); + }); + }); + + describe("clearAdmin", () => { + it("can clear an admin", async () => { + pendingWithoutWasmd(); + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, wasmd.prefix); + const client = await SigningCosmWasmClient.connectWithWallet(wasmd.endpoint, wallet); + const { codeId } = await client.upload(alice.address0, getHackatom().data); + const beneficiaryAddress = makeRandomAddress(); + const { contractAddress } = await client.instantiate( + alice.address0, + codeId, + { + verifier: alice.address0, + beneficiary: beneficiaryAddress, + }, + "My cool label", + { + admin: alice.address0, + }, + ); + const wasmClient = await makeWasmClient(wasmd.endpoint); + const { contractInfo: contractInfo1 } = await wasmClient.unverified.wasm.getContractInfo( + contractAddress, + ); + assert(contractInfo1); + expect(contractInfo1.admin).toEqual(alice.address0); + + await client.clearAdmin(alice.address0, contractAddress); + const { contractInfo: contractInfo2 } = await wasmClient.unverified.wasm.getContractInfo( + contractAddress, + ); + assert(contractInfo2); + expect(contractInfo2.admin).toEqual(""); + }); + }); + + describe("migrate", () => { + it("can can migrate from one code ID to another", async () => { + pendingWithoutWasmd(); + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, wasmd.prefix); + const client = await SigningCosmWasmClient.connectWithWallet(wasmd.endpoint, wallet); + const { codeId: codeId1 } = await client.upload(alice.address0, getHackatom().data); + const { codeId: codeId2 } = await client.upload(alice.address0, getHackatom().data); + const beneficiaryAddress = makeRandomAddress(); + const { contractAddress } = await client.instantiate( + alice.address0, + codeId1, + { + verifier: alice.address0, + beneficiary: beneficiaryAddress, + }, + "My cool label", + { + admin: alice.address0, + }, + ); + const wasmClient = await makeWasmClient(wasmd.endpoint); + const { contractInfo: contractInfo1 } = await wasmClient.unverified.wasm.getContractInfo( + contractAddress, + ); + assert(contractInfo1); + expect(contractInfo1.admin).toEqual(alice.address0); + + const newVerifier = makeRandomAddress(); + await client.migrate(alice.address0, contractAddress, codeId2, { verifier: newVerifier }); + const { contractInfo: contractInfo2 } = await wasmClient.unverified.wasm.getContractInfo( + contractAddress, + ); + assert(contractInfo2); + expect({ ...contractInfo2 }).toEqual({ + ...contractInfo1, + codeId: Long.fromNumber(codeId2, true), + }); + }); + }); + + describe("execute", () => { + it("works", async () => { + pendingWithoutWasmd(); + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, wasmd.prefix); + const client = await SigningCosmWasmClient.connectWithWallet(wasmd.endpoint, wallet); + const { codeId } = await client.upload(alice.address0, getHackatom().data); + // instantiate + const transferAmount = [coin(233444, "ucosm"), coin(5454, "ustake")]; + const beneficiaryAddress = makeRandomAddress(); + const { contractAddress } = await client.instantiate( + alice.address0, + codeId, + { + verifier: alice.address0, + beneficiary: beneficiaryAddress, + }, + "amazing random contract", + { + transferAmount, + }, + ); + // execute + const result = await client.execute(alice.address0, contractAddress, { release: {} }, undefined); + const wasmEvent = result.logs[0].events.find((e) => e.type === "wasm"); + assert(wasmEvent, "Event of type wasm expected"); + expect(wasmEvent.attributes).toContain({ key: "action", value: "release" }); + expect(wasmEvent.attributes).toContain({ + key: "destination", + value: beneficiaryAddress, + }); + // Verify token transfer from contract to beneficiary + const wasmClient = await makeWasmClient(wasmd.endpoint); + const beneficiaryBalanceUcosm = await wasmClient.bank.balance(beneficiaryAddress, "ucosm"); + expect(beneficiaryBalanceUcosm).toEqual(transferAmount[0]); + const beneficiaryBalanceUstake = await wasmClient.bank.balance(beneficiaryAddress, "ustake"); + expect(beneficiaryBalanceUstake).toEqual(transferAmount[1]); + const contractBalanceUcosm = await wasmClient.bank.balance(contractAddress, "ucosm"); + expect(contractBalanceUcosm).toEqual(coin(0, "ucosm")); + const contractBalanceUstake = await wasmClient.bank.balance(contractAddress, "ustake"); + expect(contractBalanceUstake).toEqual(coin(0, "ustake")); + }); + }); + + describe("sendTokens", () => { + it("works", async () => { + pendingWithoutWasmd(); + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, wasmd.prefix); + const client = await SigningCosmWasmClient.connectWithWallet(wasmd.endpoint, wallet); + + const transferAmount = coins(7890, "ucosm"); + const beneficiaryAddress = makeRandomAddress(); + const memo = "for dinner"; + + // no tokens here + const before = await client.getBalance(beneficiaryAddress, "ucosm"); + expect(before).toBeNull(); + + // send + const result = await client.sendTokens(alice.address0, beneficiaryAddress, transferAmount, memo); + assertIsBroadcastTxSuccess(result); + expect(result.rawLog).toBeTruthy(); + + // got tokens + const after = await client.getBalance(beneficiaryAddress, "ucosm"); + assert(after); + expect(after).toEqual(transferAmount[0]); + }); + }); + + describe("signAndBroadcast", () => { + describe("direct mode", () => { + it("works", async () => { + pendingWithoutWasmd(); + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, wasmd.prefix); + const msgDelegateTypeUrl = "/cosmos.staking.v1beta1.MsgDelegate"; + const registry = new Registry(); + registry.register(msgDelegateTypeUrl, MsgDelegate); + const options = { registry: registry }; + const client = await SigningCosmWasmClient.connectWithWallet(wasmd.endpoint, wallet, options); + + const msg = MsgDelegate.create({ + delegatorAddress: alice.address0, + validatorAddress: validator.validatorAddress, + amount: coin(1234, "ustake"), + }); + const msgAny = { + typeUrl: msgDelegateTypeUrl, + value: msg, + }; + const fee = { + amount: coins(2000, "ucosm"), + gas: "180000", // 180k + }; + const memo = "Use your power wisely"; + const result = await client.signAndBroadcast(alice.address0, [msgAny], fee, memo); + assertIsBroadcastTxSuccess(result); + }); + + it("works with a modifying signer", async () => { + pendingWithoutWasmd(); + const wallet = await ModifyingDirectSecp256k1HdWallet.fromMnemonic( + alice.mnemonic, + undefined, + wasmd.prefix, + ); + const msgDelegateTypeUrl = "/cosmos.staking.v1beta1.MsgDelegate"; + const registry = new Registry(); + registry.register(msgDelegateTypeUrl, MsgDelegate); + const options = { registry: registry }; + const client = await SigningCosmWasmClient.connectWithWallet(wasmd.endpoint, wallet, options); + + const msg = MsgDelegate.create({ + delegatorAddress: alice.address0, + validatorAddress: validator.validatorAddress, + amount: coin(1234, "ustake"), + }); + const msgAny = { + typeUrl: msgDelegateTypeUrl, + value: msg, + }; + const fee = { + amount: coins(2000, "ucosm"), + gas: "180000", // 180k + }; + const memo = "Use your power wisely"; + const result = await client.signAndBroadcast(alice.address0, [msgAny], fee, memo); + assertIsBroadcastTxSuccess(result); + + await sleep(1000); + + const searchResult = await client.searchTx({ id: result.transactionHash }); + const tx = Tx.decode(searchResult[0].tx); + // From ModifyingDirectSecp256k1HdWallet + expect(tx.body!.memo).toEqual("This was modified"); + expect({ ...tx.authInfo!.fee!.amount![0] }).toEqual(coin(3000, "ucosm")); + expect(tx.authInfo!.fee!.gasLimit!.toNumber()).toEqual(333333); + }); + }); + + describe("legacy Amino mode", () => { + // NOTE: One registry shared between tests + // See https://github.com/protobufjs/protobuf.js#using-decorators + // > Decorated types reside in protobuf.roots["decorated"] using a flat structure, so no duplicate names. + const registry = new Registry(); + const msgDelegateTypeUrl = "/cosmos.staking.v1beta1.MsgDelegate"; + + @registered(registry, msgDelegateTypeUrl) + // eslint-disable-next-line @typescript-eslint/no-unused-vars + class CustomMsgDelegate extends Message { + @cosmosField.string(1) + public readonly delegator_address?: string; + @cosmosField.string(2) + public readonly validator_address?: string; + @cosmosField.message(3, Coin) + public readonly amount?: Coin; + } + + it("works", async () => { + pendingWithoutWasmd(); + const wallet = await DirectSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, wasmd.prefix); + const options = { registry: registry }; + const client = await SigningCosmWasmClient.connectWithWallet(wasmd.endpoint, wallet, options); + + const msg = { + delegator_address: alice.address0, + validator_address: validator.validatorAddress, + amount: coin(1234, "ustake"), + }; + const msgAny = { + typeUrl: msgDelegateTypeUrl, + value: msg, + }; + const fee = { + amount: coins(2000, "ucosm"), + gas: "200000", + }; + const memo = "Use your power wisely"; + const result = await client.signAndBroadcast(alice.address0, [msgAny], fee, memo); + assertIsBroadcastTxSuccess(result); + }); + + it("works with a modifying signer", async () => { + pendingWithoutWasmd(); + const wallet = await ModifyingSecp256k1HdWallet.fromMnemonic(alice.mnemonic, undefined, wasmd.prefix); + const options = { registry: registry }; + const client = await SigningCosmWasmClient.connectWithWallet(wasmd.endpoint, wallet, options); + + const msg = { + delegator_address: alice.address0, + validator_address: validator.validatorAddress, + amount: coin(1234, "ustake"), + }; + const msgAny = { + typeUrl: msgDelegateTypeUrl, + value: msg, + }; + const fee = { + amount: coins(2000, "ucosm"), + gas: "200000", + }; + const memo = "Use your power wisely"; + const result = await client.signAndBroadcast(alice.address0, [msgAny], fee, memo); + assertIsBroadcastTxSuccess(result); + + await sleep(1000); + + const searchResult = await client.searchTx({ id: result.transactionHash }); + const tx = Tx.decode(searchResult[0].tx); + // From ModifyingSecp256k1HdWallet + expect(tx.body!.memo).toEqual("This was modified"); + expect({ ...tx.authInfo!.fee!.amount![0] }).toEqual(coin(3000, "ucosm")); + expect(tx.authInfo!.fee!.gasLimit!.toNumber()).toEqual(333333); + }); + }); + }); +}); From 18e73715bd6968b74d529472833ff66e549afacd Mon Sep 17 00:00:00 2001 From: willclarktech Date: Thu, 10 Dec 2020 14:05:20 +0000 Subject: [PATCH 20/33] root: Update CHANGELOG for cosmwasm-stargate --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 90bdd8da..2ad3710e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,7 @@ @cosmjs/launchpad instead. - @cosmjs/cosmwasm: Export `JsonObject`, `ChangeAdminResult` and `WasmData` types as well as `isValidBuilder` and `parseWasmData` functions. +- @cosmjs/cosmwasm-stargate: Add new package for CosmWasm Stargate support. - @cosmjs/launchpad: Add `Secp256k1Wallet` to manage a single raw secp256k1 keypair. - @cosmjs/launchpad: `OfflineSigner` type’s `sign` method renamed `signAmino` From 0da1439a1f8e7e57a04901461b8d922380632b5b Mon Sep 17 00:00:00 2001 From: willclarktech Date: Thu, 10 Dec 2020 16:48:49 +0000 Subject: [PATCH 21/33] cosmwasm-stargate: Update README wasmd version --- packages/cosmwasm-stargate/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/cosmwasm-stargate/README.md b/packages/cosmwasm-stargate/README.md index de15c931..d05a46a7 100644 --- a/packages/cosmwasm-stargate/README.md +++ b/packages/cosmwasm-stargate/README.md @@ -8,7 +8,7 @@ An SDK to build CosmWasm clients. | CosmWasm | x/wasm | @cosmjs/cosmwasm-stargate | | -------- | ------ | ------------------------- | -| 0.12 | 0.12 | `^0.24.0` | +| 0.12 | 0.13 | `^0.24.0` | ## Development From 19d3e86acc8d978998da72714e513bbfb2fe2b18 Mon Sep 17 00:00:00 2001 From: willclarktech Date: Thu, 10 Dec 2020 17:03:02 +0000 Subject: [PATCH 22/33] cosmwasm-stargate: Standardise shx use in package.json scripts --- packages/cosmwasm-stargate/package.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/packages/cosmwasm-stargate/package.json b/packages/cosmwasm-stargate/package.json index 616fd3f1..dc720204 100644 --- a/packages/cosmwasm-stargate/package.json +++ b/packages/cosmwasm-stargate/package.json @@ -29,7 +29,7 @@ "format-text": "prettier --write --prose-wrap always --print-width 80 \"./*.md\"", "lint": "eslint --max-warnings 0 \"**/*.{js,ts}\"", "lint-fix": "eslint --max-warnings 0 \"**/*.{js,ts}\" --fix", - "move-types": "shx rm -rf ./types/* && shx mv build/types/* ./types && rm -rf ./types/testdata && shx rm -f ./types/*.spec.d.ts && shx rm -f ./types/**/*.spec.d.ts", + "move-types": "shx rm -rf ./types/* && shx mv build/types/* ./types && rm -rf ./types/testdata ./types/*.spec.d.ts ./types/*/*.spec.d.ts", "format-types": "prettier --write --loglevel warn \"./types/**/*.d.ts\"", "prebuild": "shx rm -rf ./build", "build": "tsc && shx mkdir -p build/codec/generated && shx cp ./src/codec/generated/*.js ./build/codec/generated", @@ -41,7 +41,7 @@ "test": "yarn build-or-skip && yarn test-node", "coverage": "nyc --reporter=text --reporter=lcov yarn test --quiet", "pack-web": "yarn build-or-skip && webpack --mode development --config webpack.web.config.js", - "preget-proto": "rm -rf proto", + "preget-proto": "shx rm -rf proto", "get-proto": "WASM_REF=v0.13.0 COSMOS_REF=v0.40.0-rc3 ./scripts/get-proto.sh", "predefine-proto": "./scripts/predefine-proto.sh", "define-proto": "./scripts/define-proto.sh", From caf054e1eedd5a94b0741e620ac74644da6a2266 Mon Sep 17 00:00:00 2001 From: willclarktech Date: Thu, 10 Dec 2020 17:03:35 +0000 Subject: [PATCH 23/33] proto-signing: Standardise shx use in package.json scripts --- packages/proto-signing/package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/proto-signing/package.json b/packages/proto-signing/package.json index 508a6a41..a5a2dd62 100644 --- a/packages/proto-signing/package.json +++ b/packages/proto-signing/package.json @@ -41,7 +41,7 @@ "test": "yarn build-or-skip && yarn test-node", "coverage": "nyc --reporter=text --reporter=lcov yarn test --quiet", "pack-web": "yarn build-or-skip && webpack --mode development --config webpack.web.config.js", - "preget-proto": "rm -rf proto", + "preget-proto": "shx rm -rf proto", "get-proto": "REF=v0.40.0-rc3 ./scripts/get-proto.sh", "predefine-proto": "./scripts/predefine-proto.sh", "define-proto": "./scripts/define-proto.sh", From afba99f88c74c1b1830ff1298a74316bb66bf6e5 Mon Sep 17 00:00:00 2001 From: willclarktech Date: Thu, 10 Dec 2020 17:03:44 +0000 Subject: [PATCH 24/33] stargate: Standardise shx use in package.json scripts --- packages/stargate/package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/stargate/package.json b/packages/stargate/package.json index 5f3a1b4d..35ef99c9 100644 --- a/packages/stargate/package.json +++ b/packages/stargate/package.json @@ -40,7 +40,7 @@ "test": "yarn build-or-skip && yarn test-node", "coverage": "nyc --reporter=text --reporter=lcov yarn test --quiet", "pack-web": "yarn build-or-skip && webpack --mode development --config webpack.web.config.js", - "preget-proto": "rm -rf proto", + "preget-proto": "shx rm -rf proto", "get-proto": "REF=v0.40.0-rc3 ./scripts/get-proto.sh", "predefine-proto": "./scripts/predefine-proto.sh", "define-proto": "./scripts/define-proto.sh", From 65fe7fa4a2366ef6ed8d940c0524b3c92ede070f Mon Sep 17 00:00:00 2001 From: willclarktech Date: Thu, 10 Dec 2020 17:51:25 +0000 Subject: [PATCH 25/33] cosmwasm: Add CW1/CW3 env variables to webpack --- packages/cosmwasm/webpack.web.config.js | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/packages/cosmwasm/webpack.web.config.js b/packages/cosmwasm/webpack.web.config.js index 2cda344b..feee73e5 100644 --- a/packages/cosmwasm/webpack.web.config.js +++ b/packages/cosmwasm/webpack.web.config.js @@ -14,6 +14,8 @@ module.exports = [ path: distdir, filename: "tests.js", }, - plugins: [new webpack.EnvironmentPlugin(["LAUNCHPAD_ENABLED", "ERC20_ENABLED"])], + plugins: [ + new webpack.EnvironmentPlugin(["LAUNCHPAD_ENABLED", "ERC20_ENABLED", "CW3_ENABLED", "CW1_ENABLED"]), + ], }, ]; From b8120c4dc7541098f51f54c56aa45642f4304ade Mon Sep 17 00:00:00 2001 From: willclarktech Date: Thu, 10 Dec 2020 16:58:32 +0000 Subject: [PATCH 26/33] cosmwasm-stargate: Add env variables to webpack --- packages/cosmwasm-stargate/webpack.web.config.js | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/packages/cosmwasm-stargate/webpack.web.config.js b/packages/cosmwasm-stargate/webpack.web.config.js index 15fc60f0..df7e4559 100644 --- a/packages/cosmwasm-stargate/webpack.web.config.js +++ b/packages/cosmwasm-stargate/webpack.web.config.js @@ -1,6 +1,6 @@ const glob = require("glob"); const path = require("path"); -// const webpack = require("webpack"); +const webpack = require("webpack"); const target = "web"; const distdir = path.join(__dirname, "dist", "web"); @@ -14,6 +14,8 @@ module.exports = [ path: distdir, filename: "tests.js", }, - // plugins: [new webpack.EnvironmentPlugin(["LAUNCHPAD_ENABLED", "ERC20_ENABLED"])], + plugins: [ + new webpack.EnvironmentPlugin(["WASMD_ENABLED", "ERC20_ENABLED", "CW3_ENABLED", "CW1_ENABLED"]), + ], }, ]; From 79f4e33676da7be607a1051018eb51e1823af1a6 Mon Sep 17 00:00:00 2001 From: willclarktech Date: Fri, 11 Dec 2020 18:13:33 +0000 Subject: [PATCH 27/33] cosmwasm-stargate: Refactor predefine-proto.sh --- packages/cosmwasm-stargate/scripts/predefine-proto.sh | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/packages/cosmwasm-stargate/scripts/predefine-proto.sh b/packages/cosmwasm-stargate/scripts/predefine-proto.sh index 35547ca0..2b1ddb9e 100755 --- a/packages/cosmwasm-stargate/scripts/predefine-proto.sh +++ b/packages/cosmwasm-stargate/scripts/predefine-proto.sh @@ -3,8 +3,9 @@ set -o errexit -o nounset -o pipefail command -v shellcheck >/dev/null && shellcheck "$0" GENERATED_DIR="./tmp" -ROOT_PROTO_DIR="./proto/cosmwasm/wasmd" -WASM_PROTO_DIR="$ROOT_PROTO_DIR/x/wasm" +ROOT_PROTO_DIR="./proto" +WASM_PROTO_DIR="$ROOT_PROTO_DIR/cosmwasm/wasmd/x/wasm" +COSMOS_PROTO_DIR="$ROOT_PROTO_DIR/cosmos/cosmos-sdk/proto/cosmos" mkdir -p "$GENERATED_DIR" # Can't use --sparse for some reason. Seems related to https://github.com/protobufjs/protobuf.js/issues/1165 @@ -21,8 +22,8 @@ yarn pbjs \ "$WASM_PROTO_DIR/internal/types/msg.proto" \ "$WASM_PROTO_DIR/internal/types/query.proto" \ "$WASM_PROTO_DIR/internal/types/types.proto" \ - "./proto/cosmos/cosmos-sdk/proto/cosmos/base/v1beta1/coin.proto" \ - "./proto/cosmos/cosmos-sdk/proto/cosmos/base/query/v1beta1/pagination.proto" + "$COSMOS_PROTO_DIR/base/v1beta1/coin.proto" \ + "$COSMOS_PROTO_DIR/base/query/v1beta1/pagination.proto" # Work around https://github.com/protobufjs/protobuf.js/issues/1477 # shellcheck disable=SC2016 From 96beb8432744b6658dc910cd0b67f6fe681429d5 Mon Sep 17 00:00:00 2001 From: willclarktech Date: Tue, 15 Dec 2020 10:20:16 +0000 Subject: [PATCH 28/33] cosmwasm: Update pako to v2 --- packages/cosmwasm/package.json | 2 +- yarn.lock | 10 +++++----- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/packages/cosmwasm/package.json b/packages/cosmwasm/package.json index 96d5bc21..a9e21f9d 100644 --- a/packages/cosmwasm/package.json +++ b/packages/cosmwasm/package.json @@ -45,7 +45,7 @@ "@cosmjs/launchpad": "^0.24.0-alpha.10", "@cosmjs/math": "^0.24.0-alpha.10", "@cosmjs/utils": "^0.24.0-alpha.10", - "pako": "^1.0.11" + "pako": "^2.0.2" }, "devDependencies": { "@types/pako": "^1.0.1", diff --git a/yarn.lock b/yarn.lock index 125a1b79..dde35bf9 100644 --- a/yarn.lock +++ b/yarn.lock @@ -6802,16 +6802,16 @@ package-hash@^4.0.0: lodash.flattendeep "^4.4.0" release-zalgo "^1.0.0" -pako@^1.0.11, pako@~1.0.5: - version "1.0.11" - resolved "https://registry.yarnpkg.com/pako/-/pako-1.0.11.tgz#6c9599d340d54dfd3946380252a35705a6b992bf" - integrity sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw== - pako@^2.0.2: version "2.0.2" resolved "https://registry.yarnpkg.com/pako/-/pako-2.0.2.tgz#8a72af7a93431ef22aa97e0d53b0acaa3c689220" integrity sha512-9e8DRI3+dRLomCmMBAH30B2ejh+blwXr7VmMEx/pVFZlSDA7oyI8uKMhKXr8IrZpoxBF2YlxUvhqRXzTT1i0NA== +pako@~1.0.5: + version "1.0.11" + resolved "https://registry.yarnpkg.com/pako/-/pako-1.0.11.tgz#6c9599d340d54dfd3946380252a35705a6b992bf" + integrity sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw== + parallel-transform@^1.1.0: version "1.2.0" resolved "https://registry.yarnpkg.com/parallel-transform/-/parallel-transform-1.2.0.tgz#9049ca37d6cb2182c3b1d2c720be94d14a5814fc" From cec77508214680405360dabac99f14fd4ba8a7b2 Mon Sep 17 00:00:00 2001 From: willclarktech Date: Tue, 15 Dec 2020 10:53:41 +0000 Subject: [PATCH 29/33] tendermint-rpc: Add encode method to DateTime --- packages/tendermint-rpc/src/encodings.ts | 6 ++++++ packages/tendermint-rpc/types/encodings.d.ts | 1 + 2 files changed, 7 insertions(+) diff --git a/packages/tendermint-rpc/src/encodings.ts b/packages/tendermint-rpc/src/encodings.ts index 9266fcc1..aaab84a1 100644 --- a/packages/tendermint-rpc/src/encodings.ts +++ b/packages/tendermint-rpc/src/encodings.ts @@ -179,6 +179,12 @@ export class DateTime { (readonlyDate as any).nanoseconds = parseInt(nanoseconds.padEnd(6, "0"), 10); return readonlyDate as ReadonlyDateWithNanoseconds; } + + public static encode(dateTime: ReadonlyDateWithNanoseconds): DateTimeString { + const millisecondIso = dateTime.toISOString(); + const nanoseconds = dateTime.nanoseconds?.toString() ?? ""; + return `${millisecondIso.slice(0, -1)}${nanoseconds.padStart(6, "0")}Z` as DateTimeString; + } } export class Hex { diff --git a/packages/tendermint-rpc/types/encodings.d.ts b/packages/tendermint-rpc/types/encodings.d.ts index cd004f17..83a48433 100644 --- a/packages/tendermint-rpc/types/encodings.d.ts +++ b/packages/tendermint-rpc/types/encodings.d.ts @@ -68,6 +68,7 @@ export declare class Base64 { } export declare class DateTime { static decode(dateTimeString: DateTimeString): ReadonlyDateWithNanoseconds; + static encode(dateTime: ReadonlyDateWithNanoseconds): DateTimeString; } export declare class Hex { static encode(data: Uint8Array): HexString; From 67aa4f786f96b57e3838fb757b63d98cce505a1f Mon Sep 17 00:00:00 2001 From: willclarktech Date: Tue, 15 Dec 2020 10:54:42 +0000 Subject: [PATCH 30/33] tendermint-rpc: Export DateTime --- CHANGELOG.md | 1 + packages/tendermint-rpc/src/index.ts | 1 + packages/tendermint-rpc/types/index.d.ts | 1 + 3 files changed, 3 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2ad3710e..7a71f8e6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -26,6 +26,7 @@ which allows skipping the auto-detection. - @cosmjs/tendermint-rpc: Remove export `v0_33` in favour of `adaptor33` and `adaptor34`. Export the `Adaptor` type. +- @cosmjs/tendermint-rpc: Export `DateTime` class. ## 0.23.1 (2020-10-27) diff --git a/packages/tendermint-rpc/src/index.ts b/packages/tendermint-rpc/src/index.ts index eb72f812..c01b7fd0 100644 --- a/packages/tendermint-rpc/src/index.ts +++ b/packages/tendermint-rpc/src/index.ts @@ -1,6 +1,7 @@ export { Adaptor } from "./adaptor"; export { adaptor33, adaptor34 } from "./adaptors"; export { Client } from "./client"; +export { DateTime } from "./encodings"; export { AbciInfoRequest, AbciQueryParams, diff --git a/packages/tendermint-rpc/types/index.d.ts b/packages/tendermint-rpc/types/index.d.ts index 6b0ca746..4923480d 100644 --- a/packages/tendermint-rpc/types/index.d.ts +++ b/packages/tendermint-rpc/types/index.d.ts @@ -1,6 +1,7 @@ export { Adaptor } from "./adaptor"; export { adaptor33, adaptor34 } from "./adaptors"; export { Client } from "./client"; +export { DateTime } from "./encodings"; export { AbciInfoRequest, AbciQueryParams, From 98a771fcfc5fed61e006135c9c618f7ae20044cc Mon Sep 17 00:00:00 2001 From: willclarktech Date: Tue, 15 Dec 2020 11:29:14 +0000 Subject: [PATCH 31/33] tendermint-rpc: Add tests for DateTime --- packages/tendermint-rpc/src/encodings.spec.ts | 48 ++++++++++++++++++- 1 file changed, 47 insertions(+), 1 deletion(-) diff --git a/packages/tendermint-rpc/src/encodings.spec.ts b/packages/tendermint-rpc/src/encodings.spec.ts index afea0600..e64c517a 100644 --- a/packages/tendermint-rpc/src/encodings.spec.ts +++ b/packages/tendermint-rpc/src/encodings.spec.ts @@ -1,8 +1,54 @@ import { ReadonlyDate } from "readonly-date"; -import { encodeBlockId, encodeBytes, encodeInt, encodeString, encodeTime, encodeVersion } from "./encodings"; +import { + DateTime, + DateTimeString, + encodeBlockId, + encodeBytes, + encodeInt, + encodeString, + encodeTime, + encodeVersion, +} from "./encodings"; +import { ReadonlyDateWithNanoseconds } from "./responses"; describe("encodings", () => { + describe("DateTime", () => { + it("decodes a string", () => { + expect(DateTime.decode("2020-12-15T10:57:26.778Z" as DateTimeString).nanoseconds).toEqual(0); + expect(DateTime.decode("2020-12-15T10:57:26.7789Z" as DateTimeString).nanoseconds).toEqual(900000); + expect(DateTime.decode("2020-12-15T10:57:26.77809Z" as DateTimeString).nanoseconds).toEqual(90000); + expect(DateTime.decode("2020-12-15T10:57:26.778009Z" as DateTimeString).nanoseconds).toEqual(9000); + expect(DateTime.decode("2020-12-15T10:57:26.7780009Z" as DateTimeString).nanoseconds).toEqual(900); + expect(DateTime.decode("2020-12-15T10:57:26.77800009Z" as DateTimeString).nanoseconds).toEqual(90); + expect(DateTime.decode("2020-12-15T10:57:26.778000009Z" as DateTimeString).nanoseconds).toEqual(9); + }); + + it("encodes a string", () => { + const date1 = new ReadonlyDate("2020-12-15T10:57:26.778Z") as ReadonlyDateWithNanoseconds; + (date1 as any).nanoseconds = 0; + expect(DateTime.encode(date1)).toEqual("2020-12-15T10:57:26.778000000Z"); + const date2 = new ReadonlyDate("2020-12-15T10:57:26.778Z") as ReadonlyDateWithNanoseconds; + (date2 as any).nanoseconds = 900000; + expect(DateTime.encode(date2)).toEqual("2020-12-15T10:57:26.778900000Z"); + const date3 = new ReadonlyDate("2020-12-15T10:57:26.778Z") as ReadonlyDateWithNanoseconds; + (date3 as any).nanoseconds = 90000; + expect(DateTime.encode(date3)).toEqual("2020-12-15T10:57:26.778090000Z"); + const date4 = new ReadonlyDate("2020-12-15T10:57:26.778Z") as ReadonlyDateWithNanoseconds; + (date4 as any).nanoseconds = 9000; + expect(DateTime.encode(date4)).toEqual("2020-12-15T10:57:26.778009000Z"); + const date5 = new ReadonlyDate("2020-12-15T10:57:26.778Z") as ReadonlyDateWithNanoseconds; + (date5 as any).nanoseconds = 900; + expect(DateTime.encode(date5)).toEqual("2020-12-15T10:57:26.778000900Z"); + const date6 = new ReadonlyDate("2020-12-15T10:57:26.778Z") as ReadonlyDateWithNanoseconds; + (date6 as any).nanoseconds = 90; + expect(DateTime.encode(date6)).toEqual("2020-12-15T10:57:26.778000090Z"); + const date7 = new ReadonlyDate("2020-12-15T10:57:26.778Z") as ReadonlyDateWithNanoseconds; + (date7 as any).nanoseconds = 9; + expect(DateTime.encode(date7)).toEqual("2020-12-15T10:57:26.778000009Z"); + }); + }); + describe("encodeString", () => { it("works", () => { expect(encodeString("")).toEqual(Uint8Array.from([0])); From 1fe99ffc0f76884e942336769ee84e4972ea2889 Mon Sep 17 00:00:00 2001 From: willclarktech Date: Tue, 15 Dec 2020 12:20:27 +0000 Subject: [PATCH 32/33] tendermint-rpc: Remove DateTimeString type --- .../src/adaptors/v0-33/responses.ts | 9 ++++----- packages/tendermint-rpc/src/encodings.spec.ts | 15 +++++++-------- packages/tendermint-rpc/src/encodings.ts | 7 +++---- packages/tendermint-rpc/types/encodings.d.ts | 5 ++--- 4 files changed, 16 insertions(+), 20 deletions(-) diff --git a/packages/tendermint-rpc/src/adaptors/v0-33/responses.ts b/packages/tendermint-rpc/src/adaptors/v0-33/responses.ts index 81af176e..4740558e 100644 --- a/packages/tendermint-rpc/src/adaptors/v0-33/responses.ts +++ b/packages/tendermint-rpc/src/adaptors/v0-33/responses.ts @@ -13,7 +13,6 @@ import { Base64, Base64String, DateTime, - DateTimeString, dictionaryToStringMap, Hex, HexString, @@ -286,7 +285,7 @@ interface RpcHeader { readonly version: RpcBlockVersion; readonly chain_id: string; readonly height: IntegerString; - readonly time: DateTimeString; + readonly time: string; readonly num_txs: IntegerString; readonly total_txs: IntegerString; @@ -382,7 +381,7 @@ function decodeBroadcastTxCommit(data: RpcBroadcastTxCommitResponse): responses. type RpcSignature = { readonly block_id_flag: number; readonly validator_address: HexString; - readonly timestamp: DateTimeString; + readonly timestamp: string; readonly signature: Base64String; }; @@ -436,7 +435,7 @@ function decodeValidatorGenesis(data: RpcValidatorGenesis): responses.Validator } interface RpcGenesisResponse { - readonly genesis_time: DateTimeString; + readonly genesis_time: string; readonly chain_id: string; readonly consensus_params: RpcConsensusParams; // The validators key is used to specify a set of validators for testnets or PoA blockchains. @@ -519,7 +518,7 @@ interface RpcSyncInfo { readonly latest_block_hash: HexString; readonly latest_app_hash: HexString; readonly latest_block_height: IntegerString; - readonly latest_block_time: DateTimeString; + readonly latest_block_time: string; readonly catching_up: boolean; } diff --git a/packages/tendermint-rpc/src/encodings.spec.ts b/packages/tendermint-rpc/src/encodings.spec.ts index e64c517a..ea89db8e 100644 --- a/packages/tendermint-rpc/src/encodings.spec.ts +++ b/packages/tendermint-rpc/src/encodings.spec.ts @@ -2,7 +2,6 @@ import { ReadonlyDate } from "readonly-date"; import { DateTime, - DateTimeString, encodeBlockId, encodeBytes, encodeInt, @@ -15,13 +14,13 @@ import { ReadonlyDateWithNanoseconds } from "./responses"; describe("encodings", () => { describe("DateTime", () => { it("decodes a string", () => { - expect(DateTime.decode("2020-12-15T10:57:26.778Z" as DateTimeString).nanoseconds).toEqual(0); - expect(DateTime.decode("2020-12-15T10:57:26.7789Z" as DateTimeString).nanoseconds).toEqual(900000); - expect(DateTime.decode("2020-12-15T10:57:26.77809Z" as DateTimeString).nanoseconds).toEqual(90000); - expect(DateTime.decode("2020-12-15T10:57:26.778009Z" as DateTimeString).nanoseconds).toEqual(9000); - expect(DateTime.decode("2020-12-15T10:57:26.7780009Z" as DateTimeString).nanoseconds).toEqual(900); - expect(DateTime.decode("2020-12-15T10:57:26.77800009Z" as DateTimeString).nanoseconds).toEqual(90); - expect(DateTime.decode("2020-12-15T10:57:26.778000009Z" as DateTimeString).nanoseconds).toEqual(9); + expect(DateTime.decode("2020-12-15T10:57:26.778Z").nanoseconds).toEqual(0); + expect(DateTime.decode("2020-12-15T10:57:26.7789Z").nanoseconds).toEqual(900000); + expect(DateTime.decode("2020-12-15T10:57:26.77809Z").nanoseconds).toEqual(90000); + expect(DateTime.decode("2020-12-15T10:57:26.778009Z").nanoseconds).toEqual(9000); + expect(DateTime.decode("2020-12-15T10:57:26.7780009Z").nanoseconds).toEqual(900); + expect(DateTime.decode("2020-12-15T10:57:26.77800009Z").nanoseconds).toEqual(90); + expect(DateTime.decode("2020-12-15T10:57:26.778000009Z").nanoseconds).toEqual(9); }); it("encodes a string", () => { diff --git a/packages/tendermint-rpc/src/encodings.ts b/packages/tendermint-rpc/src/encodings.ts index aaab84a1..964554ca 100644 --- a/packages/tendermint-rpc/src/encodings.ts +++ b/packages/tendermint-rpc/src/encodings.ts @@ -7,7 +7,6 @@ import { BlockId, ReadonlyDateWithNanoseconds, Version } from "./responses"; export type Base64String = string & As<"base64">; export type HexString = string & As<"hex">; export type IntegerString = string & As<"integer">; -export type DateTimeString = string & As<"datetime">; /** * A runtime checker that ensures a given value is set (i.e. not undefined or null) @@ -172,7 +171,7 @@ export class Base64 { } export class DateTime { - public static decode(dateTimeString: DateTimeString): ReadonlyDateWithNanoseconds { + public static decode(dateTimeString: string): ReadonlyDateWithNanoseconds { const readonlyDate = fromRfc3339(dateTimeString); const nanosecondsMatch = dateTimeString.match(/\.(\d+)Z$/); const nanoseconds = nanosecondsMatch ? nanosecondsMatch[1].slice(3) : ""; @@ -180,10 +179,10 @@ export class DateTime { return readonlyDate as ReadonlyDateWithNanoseconds; } - public static encode(dateTime: ReadonlyDateWithNanoseconds): DateTimeString { + public static encode(dateTime: ReadonlyDateWithNanoseconds): string { const millisecondIso = dateTime.toISOString(); const nanoseconds = dateTime.nanoseconds?.toString() ?? ""; - return `${millisecondIso.slice(0, -1)}${nanoseconds.padStart(6, "0")}Z` as DateTimeString; + return `${millisecondIso.slice(0, -1)}${nanoseconds.padStart(6, "0")}Z`; } } diff --git a/packages/tendermint-rpc/types/encodings.d.ts b/packages/tendermint-rpc/types/encodings.d.ts index 83a48433..8a455cc0 100644 --- a/packages/tendermint-rpc/types/encodings.d.ts +++ b/packages/tendermint-rpc/types/encodings.d.ts @@ -3,7 +3,6 @@ import { BlockId, ReadonlyDateWithNanoseconds, Version } from "./responses"; export declare type Base64String = string & As<"base64">; export declare type HexString = string & As<"hex">; export declare type IntegerString = string & As<"integer">; -export declare type DateTimeString = string & As<"datetime">; /** * A runtime checker that ensures a given value is set (i.e. not undefined or null) * @@ -67,8 +66,8 @@ export declare class Base64 { static decode(base64String: Base64String): Uint8Array; } export declare class DateTime { - static decode(dateTimeString: DateTimeString): ReadonlyDateWithNanoseconds; - static encode(dateTime: ReadonlyDateWithNanoseconds): DateTimeString; + static decode(dateTimeString: string): ReadonlyDateWithNanoseconds; + static encode(dateTime: ReadonlyDateWithNanoseconds): string; } export declare class Hex { static encode(data: Uint8Array): HexString; From 9ce5241b9ba39879356c61b077c259f88cea1091 Mon Sep 17 00:00:00 2001 From: willclarktech Date: Tue, 15 Dec 2020 11:31:10 +0000 Subject: [PATCH 33/33] cosmwasm-stargate: Use DateTime to encode times --- packages/cosmwasm-stargate/src/cosmwasmclient.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/packages/cosmwasm-stargate/src/cosmwasmclient.ts b/packages/cosmwasm-stargate/src/cosmwasmclient.ts index 870c2554..902f40d4 100644 --- a/packages/cosmwasm-stargate/src/cosmwasmclient.ts +++ b/packages/cosmwasm-stargate/src/cosmwasmclient.ts @@ -30,6 +30,7 @@ import { adaptor34, broadcastTxCommitSuccess, Client as TendermintClient, + DateTime, QueryString, } from "@cosmjs/tendermint-rpc"; import { assert } from "@cosmjs/utils"; @@ -114,7 +115,7 @@ export class CosmWasmClient { }, height: response.block.header.height, chainId: response.block.header.chainId, - time: response.block.header.time.toISOString(), + time: DateTime.encode(response.block.header.time), }, txs: response.block.txs, };