From 0798b1cd672aa11d2410de8c8b634ba1877c4d35 Mon Sep 17 00:00:00 2001 From: Amaury Date: Thu, 14 Jan 2021 11:30:44 +0100 Subject: [PATCH] fix(api): Regenerate from v0.40.0 proto files (#13) --- packages/api/.npmignore | 3 + packages/api/README.md | 2 +- packages/api/package.json | 1 + .../base/tendermint/v1beta1/query.proto | 136 ++ .../api/proto/cosmos/staking/v1beta1/tx.proto | 1 - .../api/proto/cosmos/tx/v1beta1/service.proto | 50 +- packages/api/proto/cosmos/tx/v1beta1/tx.proto | 1 - .../proto/cosmos/upgrade/v1beta1/query.proto | 23 + .../google/protobuf/timestamp.proto | 147 -- .../{generate_proto.sh => protocgen.sh} | 4 +- .../cosmos/base/tendermint/v1beta1/query.ts | 1309 +++++++++++++ .../generated/cosmos/staking/v1beta1/tx.ts | 1 - .../generated/cosmos/tx/v1beta1/service.ts | 269 ++- .../api/src/generated/cosmos/tx/v1beta1/tx.ts | 1 - .../generated/cosmos/upgrade/v1beta1/query.ts | 138 ++ .../generated/google/protobuf/timestamp.ts | 11 +- .../api/src/generated/tendermint/p2p/types.ts | 465 +++++ .../src/generated/tendermint/types/block.ts | 128 ++ .../generated/tendermint/types/evidence.ts | 453 +++++ .../generated/third_party/confio/proofs.ts | 1613 ----------------- .../third_party/cosmos_proto/cosmos.ts | 3 - .../generated/third_party/gogoproto/gogo.ts | 3 - .../proto}/confio/proofs.proto | 0 .../proto}/cosmos_proto/cosmos.proto | 0 .../proto}/gogoproto/gogo.proto | 0 .../proto}/google/api/annotations.proto | 0 .../proto}/google/api/http.proto | 0 .../proto}/google/api/httpbody.proto | 0 .../proto}/google/protobuf/any.proto | 0 .../proto}/tendermint/abci/types.proto | 0 .../proto}/tendermint/crypto/keys.proto | 0 .../proto}/tendermint/crypto/proof.proto | 0 .../proto}/tendermint/libs/bits/types.proto | 0 .../proto/tendermint/p2p/types.proto | 34 + .../proto/tendermint/types/block.proto | 15 + .../proto}/tendermint/types/evidence.proto | 0 .../proto}/tendermint/types/params.proto | 0 .../proto}/tendermint/types/types.proto | 0 .../proto}/tendermint/types/validator.proto | 0 .../proto}/tendermint/version/types.proto | 0 40 files changed, 3009 insertions(+), 1802 deletions(-) create mode 100644 packages/api/proto/cosmos/base/tendermint/v1beta1/query.proto delete mode 100644 packages/api/proto/third_party/google/protobuf/timestamp.proto rename packages/api/scripts/{generate_proto.sh => protocgen.sh} (91%) create mode 100644 packages/api/src/generated/cosmos/base/tendermint/v1beta1/query.ts create mode 100644 packages/api/src/generated/tendermint/p2p/types.ts create mode 100644 packages/api/src/generated/tendermint/types/block.ts create mode 100644 packages/api/src/generated/tendermint/types/evidence.ts delete mode 100644 packages/api/src/generated/third_party/confio/proofs.ts delete mode 100644 packages/api/src/generated/third_party/cosmos_proto/cosmos.ts delete mode 100644 packages/api/src/generated/third_party/gogoproto/gogo.ts rename packages/api/{proto/third_party => third_party/proto}/confio/proofs.proto (100%) rename packages/api/{proto/third_party => third_party/proto}/cosmos_proto/cosmos.proto (100%) rename packages/api/{proto/third_party => third_party/proto}/gogoproto/gogo.proto (100%) rename packages/api/{proto/third_party => third_party/proto}/google/api/annotations.proto (100%) rename packages/api/{proto/third_party => third_party/proto}/google/api/http.proto (100%) rename packages/api/{proto/third_party => third_party/proto}/google/api/httpbody.proto (100%) rename packages/api/{proto/third_party => third_party/proto}/google/protobuf/any.proto (100%) rename packages/api/{proto/third_party => third_party/proto}/tendermint/abci/types.proto (100%) rename packages/api/{proto/third_party => third_party/proto}/tendermint/crypto/keys.proto (100%) rename packages/api/{proto/third_party => third_party/proto}/tendermint/crypto/proof.proto (100%) rename packages/api/{proto/third_party => third_party/proto}/tendermint/libs/bits/types.proto (100%) create mode 100644 packages/api/third_party/proto/tendermint/p2p/types.proto create mode 100644 packages/api/third_party/proto/tendermint/types/block.proto rename packages/api/{proto/third_party => third_party/proto}/tendermint/types/evidence.proto (100%) rename packages/api/{proto/third_party => third_party/proto}/tendermint/types/params.proto (100%) rename packages/api/{proto/third_party => third_party/proto}/tendermint/types/types.proto (100%) rename packages/api/{proto/third_party => third_party/proto}/tendermint/types/validator.proto (100%) rename packages/api/{proto/third_party => third_party/proto}/tendermint/version/types.proto (100%) diff --git a/packages/api/.npmignore b/packages/api/.npmignore index 24eaf916..bea17bb8 100644 --- a/packages/api/.npmignore +++ b/packages/api/.npmignore @@ -10,6 +10,9 @@ coverage # os-generated files .DS_Store +# TS source code +src + # Proto definitions proto scripts diff --git a/packages/api/README.md b/packages/api/README.md index 71b5e5ca..6f866fef 100644 --- a/packages/api/README.md +++ b/packages/api/README.md @@ -24,7 +24,7 @@ import { RegenApi } from '@regen-network/api'; import { QueryClientImpl } from '@regen-network/api/lib/generated/cosmos/bank/v1beta1/query'; // Create a new instance of the RegenApi class. -const api = new RegenApi({ +const api = RegenApi.connect({ // RegenApi supports multiple client connections to interact with a node: // - via the Tendermint RPC // - via gRPC diff --git a/packages/api/package.json b/packages/api/package.json index 9989bee3..0754cc11 100644 --- a/packages/api/package.json +++ b/packages/api/package.json @@ -14,6 +14,7 @@ }, "scripts": { "build": "rimraf lib && tsc", + "gen": "rimraf src/generated && mkdir src/generated && ./scripts/protocgen.sh", "test": "jest" }, "devDependencies": { diff --git a/packages/api/proto/cosmos/base/tendermint/v1beta1/query.proto b/packages/api/proto/cosmos/base/tendermint/v1beta1/query.proto new file mode 100644 index 00000000..50cb5852 --- /dev/null +++ b/packages/api/proto/cosmos/base/tendermint/v1beta1/query.proto @@ -0,0 +1,136 @@ +syntax = "proto3"; +package cosmos.base.tendermint.v1beta1; + +import "gogoproto/gogo.proto"; +import "google/protobuf/any.proto"; +import "google/api/annotations.proto"; +import "tendermint/p2p/types.proto"; +import "tendermint/types/block.proto"; +import "tendermint/types/types.proto"; +import "cosmos/base/query/v1beta1/pagination.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/client/grpc/tmservice"; + +// Service defines the gRPC querier service for tendermint queries. +service Service { + // GetNodeInfo queries the current node info. + rpc GetNodeInfo(GetNodeInfoRequest) returns (GetNodeInfoResponse) { + option (google.api.http).get = "/cosmos/base/tendermint/v1beta1/node_info"; + } + // GetSyncing queries node syncing. + rpc GetSyncing(GetSyncingRequest) returns (GetSyncingResponse) { + option (google.api.http).get = "/cosmos/base/tendermint/v1beta1/syncing"; + } + // GetLatestBlock returns the latest block. + rpc GetLatestBlock(GetLatestBlockRequest) returns (GetLatestBlockResponse) { + option (google.api.http).get = "/cosmos/base/tendermint/v1beta1/blocks/latest"; + } + // GetBlockByHeight queries block for given height. + rpc GetBlockByHeight(GetBlockByHeightRequest) returns (GetBlockByHeightResponse) { + option (google.api.http).get = "/cosmos/base/tendermint/v1beta1/blocks/{height}"; + } + + // GetLatestValidatorSet queries latest validator-set. + rpc GetLatestValidatorSet(GetLatestValidatorSetRequest) returns (GetLatestValidatorSetResponse) { + option (google.api.http).get = "/cosmos/base/tendermint/v1beta1/validatorsets/latest"; + } + // GetValidatorSetByHeight queries validator-set at a given height. + rpc GetValidatorSetByHeight(GetValidatorSetByHeightRequest) returns (GetValidatorSetByHeightResponse) { + option (google.api.http).get = "/cosmos/base/tendermint/v1beta1/validatorsets/{height}"; + } +} + +// GetValidatorSetByHeightRequest is the request type for the Query/GetValidatorSetByHeight RPC method. +message GetValidatorSetByHeightRequest { + int64 height = 1; + // pagination defines an pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 2; +} + +// GetValidatorSetByHeightResponse is the response type for the Query/GetValidatorSetByHeight RPC method. +message GetValidatorSetByHeightResponse { + int64 block_height = 1; + repeated Validator validators = 2; + // pagination defines an pagination for the response. + cosmos.base.query.v1beta1.PageResponse pagination = 3; +} + +// GetLatestValidatorSetRequest is the request type for the Query/GetValidatorSetByHeight RPC method. +message GetLatestValidatorSetRequest { + // pagination defines an pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 1; +} + +// GetLatestValidatorSetResponse is the response type for the Query/GetValidatorSetByHeight RPC method. +message GetLatestValidatorSetResponse { + int64 block_height = 1; + repeated Validator validators = 2; + // pagination defines an pagination for the response. + cosmos.base.query.v1beta1.PageResponse pagination = 3; +} + +// Validator is the type for the validator-set. +message Validator { + string address = 1; + google.protobuf.Any pub_key = 2; + int64 voting_power = 3; + int64 proposer_priority = 4; +} + +// GetBlockByHeightRequest is the request type for the Query/GetBlockByHeight RPC method. +message GetBlockByHeightRequest { + int64 height = 1; +} + +// GetBlockByHeightResponse is the response type for the Query/GetBlockByHeight RPC method. +message GetBlockByHeightResponse { + .tendermint.types.BlockID block_id = 1; + .tendermint.types.Block block = 2; +} + +// GetLatestBlockRequest is the request type for the Query/GetLatestBlock RPC method. +message GetLatestBlockRequest {} + +// GetLatestBlockResponse is the response type for the Query/GetLatestBlock RPC method. +message GetLatestBlockResponse { + .tendermint.types.BlockID block_id = 1; + .tendermint.types.Block block = 2; +} + +// GetSyncingRequest is the request type for the Query/GetSyncing RPC method. +message GetSyncingRequest {} + +// GetSyncingResponse is the response type for the Query/GetSyncing RPC method. +message GetSyncingResponse { + bool syncing = 1; +} + +// GetNodeInfoRequest is the request type for the Query/GetNodeInfo RPC method. +message GetNodeInfoRequest {} + +// GetNodeInfoResponse is the request type for the Query/GetNodeInfo RPC method. +message GetNodeInfoResponse { + .tendermint.p2p.DefaultNodeInfo default_node_info = 1; + VersionInfo application_version = 2; +} + +// VersionInfo is the type for the GetNodeInfoResponse message. +message VersionInfo { + string name = 1; + string app_name = 2; + string version = 3; + string git_commit = 4; + string build_tags = 5; + string go_version = 6; + repeated Module build_deps = 7; +} + +// Module is the type for VersionInfo +message Module { + // module path + string path = 1; + // module version + string version = 2; + // checksum + string sum = 3; +} diff --git a/packages/api/proto/cosmos/staking/v1beta1/tx.proto b/packages/api/proto/cosmos/staking/v1beta1/tx.proto index ffcd74b2..7b05d89e 100644 --- a/packages/api/proto/cosmos/staking/v1beta1/tx.proto +++ b/packages/api/proto/cosmos/staking/v1beta1/tx.proto @@ -64,7 +64,6 @@ message MsgEditValidator { // We pass a reference to the new commission rate and min self delegation as // it's not mandatory to update. If not updated, the deserialized rate will be // zero with no way to distinguish if an update was intended. - // // REF: #2373 string commission_rate = 3 [ (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", diff --git a/packages/api/proto/cosmos/tx/v1beta1/service.proto b/packages/api/proto/cosmos/tx/v1beta1/service.proto index d78216d0..59df75ba 100644 --- a/packages/api/proto/cosmos/tx/v1beta1/service.proto +++ b/packages/api/proto/cosmos/tx/v1beta1/service.proto @@ -4,6 +4,7 @@ package cosmos.tx.v1beta1; import "google/api/annotations.proto"; import "cosmos/base/abci/v1beta1/abci.proto"; import "cosmos/tx/v1beta1/tx.proto"; +import "gogoproto/gogo.proto"; import "cosmos/base/query/v1beta1/pagination.proto"; option go_package = "github.com/cosmos/cosmos-sdk/types/tx"; @@ -12,13 +13,22 @@ option go_package = "github.com/cosmos/cosmos-sdk/types/tx"; service Service { // Simulate simulates executing a transaction for estimating gas usage. rpc Simulate(SimulateRequest) returns (SimulateResponse) { - option (google.api.http).post = "/cosmos/tx/v1beta1/simulate"; + option (google.api.http) = { + post: "/cosmos/tx/v1beta1/simulate" + body: "*" + }; } // GetTx fetches a tx by hash. rpc GetTx(GetTxRequest) returns (GetTxResponse) { - option (google.api.http).get = "/cosmos/tx/v1beta1/tx/{hash}"; + option (google.api.http).get = "/cosmos/tx/v1beta1/txs/{hash}"; + } + // BroadcastTx broadcast transaction. + rpc BroadcastTx(BroadcastTxRequest) returns (BroadcastTxResponse) { + option (google.api.http) = { + post: "/cosmos/tx/v1beta1/txs" + body: "*" + }; } - // GetTxsEvent fetches txs by event. rpc GetTxsEvent(GetTxsEventRequest) returns (GetTxsEventResponse) { option (google.api.http).get = "/cosmos/tx/v1beta1/txs"; @@ -28,8 +38,8 @@ service Service { // GetTxsEventRequest is the request type for the Service.TxsByEvents // RPC method. message GetTxsEventRequest { - // event is the transaction event type. - string event = 1; + // events is the list of transaction event type. + repeated string events = 1; // pagination defines an pagination for the request. cosmos.base.query.v1beta1.PageRequest pagination = 2; } @@ -45,6 +55,36 @@ message GetTxsEventResponse { cosmos.base.query.v1beta1.PageResponse pagination = 3; } +// BroadcastTxRequest is the request type for the Service.BroadcastTxRequest +// RPC method. +message BroadcastTxRequest { + // tx_bytes is the raw transaction. + bytes tx_bytes = 1; + BroadcastMode mode = 2; +} + +// BroadcastMode specifies the broadcast mode for the TxService.Broadcast RPC method. +enum BroadcastMode { + // zero-value for mode ordering + BROADCAST_MODE_UNSPECIFIED = 0; + // BROADCAST_MODE_BLOCK defines a tx broadcasting mode where the client waits for + // the tx to be committed in a block. + BROADCAST_MODE_BLOCK = 1; + // BROADCAST_MODE_SYNC defines a tx broadcasting mode where the client waits for + // a CheckTx execution response only. + BROADCAST_MODE_SYNC = 2; + // BROADCAST_MODE_ASYNC defines a tx broadcasting mode where the client returns + // immediately. + BROADCAST_MODE_ASYNC = 3; +} + +// BroadcastTxResponse is the response type for the +// Service.BroadcastTx method. +message BroadcastTxResponse { + // tx_response is the queried TxResponses. + cosmos.base.abci.v1beta1.TxResponse tx_response = 1; +} + // SimulateRequest is the request type for the Service.Simulate // RPC method. message SimulateRequest { diff --git a/packages/api/proto/cosmos/tx/v1beta1/tx.proto b/packages/api/proto/cosmos/tx/v1beta1/tx.proto index 05eea1f6..2b02874c 100644 --- a/packages/api/proto/cosmos/tx/v1beta1/tx.proto +++ b/packages/api/proto/cosmos/tx/v1beta1/tx.proto @@ -69,7 +69,6 @@ message TxBody { // those messages define the number and order of elements in AuthInfo's // signer_infos and Tx's signatures. Each required signer address is added to // the list only the first time it occurs. - // // By convention, the first required signer (usually from the first message) // is referred to as the primary signer and pays the fee for the whole // transaction. diff --git a/packages/api/proto/cosmos/upgrade/v1beta1/query.proto b/packages/api/proto/cosmos/upgrade/v1beta1/query.proto index d5c6bd7b..9eab27e7 100644 --- a/packages/api/proto/cosmos/upgrade/v1beta1/query.proto +++ b/packages/api/proto/cosmos/upgrade/v1beta1/query.proto @@ -1,6 +1,7 @@ syntax = "proto3"; package cosmos.upgrade.v1beta1; +import "google/protobuf/any.proto"; import "google/api/annotations.proto"; import "cosmos/upgrade/v1beta1/upgrade.proto"; @@ -17,6 +18,14 @@ service Query { rpc AppliedPlan(QueryAppliedPlanRequest) returns (QueryAppliedPlanResponse) { option (google.api.http).get = "/cosmos/upgrade/v1beta1/applied_plan/{name}"; } + + // UpgradedConsensusState queries the consensus state that will serve + // as a trusted kernel for the next version of this chain. It will only be + // stored at the last height of this chain. + // UpgradedConsensusState RPC not supported with legacy querier + rpc UpgradedConsensusState(QueryUpgradedConsensusStateRequest) returns (QueryUpgradedConsensusStateResponse) { + option (google.api.http).get = "/cosmos/upgrade/v1beta1/upgraded_consensus_state/{last_height}"; + } } // QueryCurrentPlanRequest is the request type for the Query/CurrentPlan RPC @@ -43,3 +52,17 @@ message QueryAppliedPlanResponse { // height is the block height at which the plan was applied. int64 height = 1; } + +// QueryUpgradedConsensusStateRequest is the request type for the Query/UpgradedConsensusState +// RPC method. +message QueryUpgradedConsensusStateRequest { + // last height of the current chain must be sent in request + // as this is the height under which next consensus state is stored + int64 last_height = 1; +} + +// QueryUpgradedConsensusStateResponse is the response type for the Query/UpgradedConsensusState +// RPC method. +message QueryUpgradedConsensusStateResponse { + google.protobuf.Any upgraded_consensus_state = 1; +} diff --git a/packages/api/proto/third_party/google/protobuf/timestamp.proto b/packages/api/proto/third_party/google/protobuf/timestamp.proto deleted file mode 100644 index 3b2df6d9..00000000 --- a/packages/api/proto/third_party/google/protobuf/timestamp.proto +++ /dev/null @@ -1,147 +0,0 @@ -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -syntax = "proto3"; - -package google.protobuf; - -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; -option cc_enable_arenas = true; -option go_package = "google.golang.org/protobuf/types/known/timestamppb"; -option java_package = "com.google.protobuf"; -option java_outer_classname = "TimestampProto"; -option java_multiple_files = true; -option objc_class_prefix = "GPB"; - -// A Timestamp represents a point in time independent of any time zone or local -// calendar, encoded as a count of seconds and fractions of seconds at -// nanosecond resolution. The count is relative to an epoch at UTC midnight on -// January 1, 1970, in the proleptic Gregorian calendar which extends the -// Gregorian calendar backwards to year one. -// -// All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap -// second table is needed for interpretation, using a [24-hour linear -// smear](https://developers.google.com/time/smear). -// -// The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By -// restricting to that range, we ensure that we can convert to and from [RFC -// 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. -// -// # Examples -// -// Example 1: Compute Timestamp from POSIX `time()`. -// -// Timestamp timestamp; -// timestamp.set_seconds(time(NULL)); -// timestamp.set_nanos(0); -// -// Example 2: Compute Timestamp from POSIX `gettimeofday()`. -// -// struct timeval tv; -// gettimeofday(&tv, NULL); -// -// Timestamp timestamp; -// timestamp.set_seconds(tv.tv_sec); -// timestamp.set_nanos(tv.tv_usec * 1000); -// -// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. -// -// FILETIME ft; -// GetSystemTimeAsFileTime(&ft); -// UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; -// -// // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z -// // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. -// Timestamp timestamp; -// timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); -// timestamp.set_nanos((INT32) ((ticks % 10000000) * 100)); -// -// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. -// -// long millis = System.currentTimeMillis(); -// -// Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) -// .setNanos((int) ((millis % 1000) * 1000000)).build(); -// -// -// Example 5: Compute Timestamp from Java `Instant.now()`. -// -// Instant now = Instant.now(); -// -// Timestamp timestamp = -// Timestamp.newBuilder().setSeconds(now.getEpochSecond()) -// .setNanos(now.getNano()).build(); -// -// -// Example 6: Compute Timestamp from current time in Python. -// -// timestamp = Timestamp() -// timestamp.GetCurrentTime() -// -// # JSON Mapping -// -// In JSON format, the Timestamp type is encoded as a string in the -// [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the -// format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" -// where {year} is always expressed using four digits while {month}, {day}, -// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional -// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), -// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone -// is required. A proto3 JSON serializer should always use UTC (as indicated by -// "Z") when printing the Timestamp type and a proto3 JSON parser should be -// able to accept both UTC and other timezones (as indicated by an offset). -// -// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past -// 01:30 UTC on January 15, 2017. -// -// In JavaScript, one can convert a Date object to this format using the -// standard -// [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) -// method. In Python, a standard `datetime.datetime` object can be converted -// to this format using -// [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with -// the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use -// the Joda Time's [`ISODateTimeFormat.dateTime()`]( -// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D -// ) to obtain a formatter capable of generating timestamps in this format. -// -// -message Timestamp { - // Represents seconds of UTC time since Unix epoch - // 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to - // 9999-12-31T23:59:59Z inclusive. - int64 seconds = 1; - - // Non-negative fractions of a second at nanosecond resolution. Negative - // second values with fractions must still have non-negative nanos values - // that count forward in time. Must be from 0 to 999,999,999 - // inclusive. - int32 nanos = 2; -} diff --git a/packages/api/scripts/generate_proto.sh b/packages/api/scripts/protocgen.sh similarity index 91% rename from packages/api/scripts/generate_proto.sh rename to packages/api/scripts/protocgen.sh index 34a94405..8211dd7b 100755 --- a/packages/api/scripts/generate_proto.sh +++ b/packages/api/scripts/protocgen.sh @@ -7,9 +7,9 @@ PROTO_DIRS=$(find ./proto -path -prune -o -name '*.proto' -print0 | xargs -0 -n1 # Generate TS files with ts-proto for dir in $PROTO_DIRS; do - protoc \ + buf protoc \ -I "proto" \ - -I "proto/third_party" \ + -I "third_party/proto" \ --plugin=${TS_PROTO_BIN} \ --ts_proto_opt=useOptionals=true \ --ts_proto_opt=forceLong=long \ diff --git a/packages/api/src/generated/cosmos/base/tendermint/v1beta1/query.ts b/packages/api/src/generated/cosmos/base/tendermint/v1beta1/query.ts new file mode 100644 index 00000000..667ba25b --- /dev/null +++ b/packages/api/src/generated/cosmos/base/tendermint/v1beta1/query.ts @@ -0,0 +1,1309 @@ +/* eslint-disable */ +import * as Long from 'long'; +import { PageRequest, PageResponse } from '../../../../cosmos/base/query/v1beta1/pagination'; +import { Any } from '../../../../google/protobuf/any'; +import { BlockID } from '../../../../tendermint/types/types'; +import { Block } from '../../../../tendermint/types/block'; +import { DefaultNodeInfo } from '../../../../tendermint/p2p/types'; +import { Reader, Writer } from 'protobufjs/minimal'; + + +/** + * GetValidatorSetByHeightRequest is the request type for the Query/GetValidatorSetByHeight RPC method. + */ +export interface GetValidatorSetByHeightRequest { + height: Long; + /** + * pagination defines an pagination for the request. + */ + pagination?: PageRequest; +} + +/** + * GetValidatorSetByHeightResponse is the response type for the Query/GetValidatorSetByHeight RPC method. + */ +export interface GetValidatorSetByHeightResponse { + blockHeight: Long; + validators: Validator[]; + /** + * pagination defines an pagination for the response. + */ + pagination?: PageResponse; +} + +/** + * GetLatestValidatorSetRequest is the request type for the Query/GetValidatorSetByHeight RPC method. + */ +export interface GetLatestValidatorSetRequest { + /** + * pagination defines an pagination for the request. + */ + pagination?: PageRequest; +} + +/** + * GetLatestValidatorSetResponse is the response type for the Query/GetValidatorSetByHeight RPC method. + */ +export interface GetLatestValidatorSetResponse { + blockHeight: Long; + validators: Validator[]; + /** + * pagination defines an pagination for the response. + */ + pagination?: PageResponse; +} + +/** + * Validator is the type for the validator-set. + */ +export interface Validator { + address: string; + pubKey?: Any; + votingPower: Long; + proposerPriority: Long; +} + +/** + * GetBlockByHeightRequest is the request type for the Query/GetBlockByHeight RPC method. + */ +export interface GetBlockByHeightRequest { + height: Long; +} + +/** + * GetBlockByHeightResponse is the response type for the Query/GetBlockByHeight RPC method. + */ +export interface GetBlockByHeightResponse { + blockId?: BlockID; + block?: Block; +} + +/** + * GetLatestBlockRequest is the request type for the Query/GetLatestBlock RPC method. + */ +export interface GetLatestBlockRequest { +} + +/** + * GetLatestBlockResponse is the response type for the Query/GetLatestBlock RPC method. + */ +export interface GetLatestBlockResponse { + blockId?: BlockID; + block?: Block; +} + +/** + * GetSyncingRequest is the request type for the Query/GetSyncing RPC method. + */ +export interface GetSyncingRequest { +} + +/** + * GetSyncingResponse is the response type for the Query/GetSyncing RPC method. + */ +export interface GetSyncingResponse { + syncing: boolean; +} + +/** + * GetNodeInfoRequest is the request type for the Query/GetNodeInfo RPC method. + */ +export interface GetNodeInfoRequest { +} + +/** + * GetNodeInfoResponse is the request type for the Query/GetNodeInfo RPC method. + */ +export interface GetNodeInfoResponse { + defaultNodeInfo?: DefaultNodeInfo; + applicationVersion?: VersionInfo; +} + +/** + * VersionInfo is the type for the GetNodeInfoResponse message. + */ +export interface VersionInfo { + name: string; + appName: string; + version: string; + gitCommit: string; + buildTags: string; + goVersion: string; + buildDeps: Module[]; +} + +/** + * Module is the type for VersionInfo + */ +export interface Module { + /** + * module path + */ + path: string; + /** + * module version + */ + version: string; + /** + * checksum + */ + sum: string; +} + +const baseGetValidatorSetByHeightRequest: object = { + height: Long.ZERO, +}; + +const baseGetValidatorSetByHeightResponse: object = { + blockHeight: Long.ZERO, +}; + +const baseGetLatestValidatorSetRequest: object = { +}; + +const baseGetLatestValidatorSetResponse: object = { + blockHeight: Long.ZERO, +}; + +const baseValidator: object = { + address: "", + votingPower: Long.ZERO, + proposerPriority: Long.ZERO, +}; + +const baseGetBlockByHeightRequest: object = { + height: Long.ZERO, +}; + +const baseGetBlockByHeightResponse: object = { +}; + +const baseGetLatestBlockRequest: object = { +}; + +const baseGetLatestBlockResponse: object = { +}; + +const baseGetSyncingRequest: object = { +}; + +const baseGetSyncingResponse: object = { + syncing: false, +}; + +const baseGetNodeInfoRequest: object = { +}; + +const baseGetNodeInfoResponse: object = { +}; + +const baseVersionInfo: object = { + name: "", + appName: "", + version: "", + gitCommit: "", + buildTags: "", + goVersion: "", +}; + +const baseModule: object = { + path: "", + version: "", + sum: "", +}; + +/** + * Service defines the gRPC querier service for tendermint queries. + */ +export interface Service { + + /** + * GetNodeInfo queries the current node info. + */ + GetNodeInfo(request: GetNodeInfoRequest): Promise; + + /** + * GetSyncing queries node syncing. + */ + GetSyncing(request: GetSyncingRequest): Promise; + + /** + * GetLatestBlock returns the latest block. + */ + GetLatestBlock(request: GetLatestBlockRequest): Promise; + + /** + * GetBlockByHeight queries block for given height. + */ + GetBlockByHeight(request: GetBlockByHeightRequest): Promise; + + /** + * GetLatestValidatorSet queries latest validator-set. + */ + GetLatestValidatorSet(request: GetLatestValidatorSetRequest): Promise; + + /** + * GetValidatorSetByHeight queries validator-set at a given height. + */ + GetValidatorSetByHeight(request: GetValidatorSetByHeightRequest): Promise; + +} + +export class ServiceClientImpl implements Service { + + private readonly rpc: Rpc; + + constructor(rpc: Rpc) { + this.rpc = rpc; + } + + GetNodeInfo(request: GetNodeInfoRequest): Promise { + const data = GetNodeInfoRequest.encode(request).finish(); + const promise = this.rpc.request("cosmos.base.tendermint.v1beta1.Service", "GetNodeInfo", data); + return promise.then(data => GetNodeInfoResponse.decode(new Reader(data))); + } + + GetSyncing(request: GetSyncingRequest): Promise { + const data = GetSyncingRequest.encode(request).finish(); + const promise = this.rpc.request("cosmos.base.tendermint.v1beta1.Service", "GetSyncing", data); + return promise.then(data => GetSyncingResponse.decode(new Reader(data))); + } + + GetLatestBlock(request: GetLatestBlockRequest): Promise { + const data = GetLatestBlockRequest.encode(request).finish(); + const promise = this.rpc.request("cosmos.base.tendermint.v1beta1.Service", "GetLatestBlock", data); + return promise.then(data => GetLatestBlockResponse.decode(new Reader(data))); + } + + GetBlockByHeight(request: GetBlockByHeightRequest): Promise { + const data = GetBlockByHeightRequest.encode(request).finish(); + const promise = this.rpc.request("cosmos.base.tendermint.v1beta1.Service", "GetBlockByHeight", data); + return promise.then(data => GetBlockByHeightResponse.decode(new Reader(data))); + } + + GetLatestValidatorSet(request: GetLatestValidatorSetRequest): Promise { + const data = GetLatestValidatorSetRequest.encode(request).finish(); + const promise = this.rpc.request("cosmos.base.tendermint.v1beta1.Service", "GetLatestValidatorSet", data); + return promise.then(data => GetLatestValidatorSetResponse.decode(new Reader(data))); + } + + GetValidatorSetByHeight(request: GetValidatorSetByHeightRequest): Promise { + const data = GetValidatorSetByHeightRequest.encode(request).finish(); + const promise = this.rpc.request("cosmos.base.tendermint.v1beta1.Service", "GetValidatorSetByHeight", data); + return promise.then(data => GetValidatorSetByHeightResponse.decode(new Reader(data))); + } + +} + +interface Rpc { + + request(service: string, method: string, data: Uint8Array): Promise; + +} + +export const protobufPackage = 'cosmos.base.tendermint.v1beta1' + +export const GetValidatorSetByHeightRequest = { + encode(message: GetValidatorSetByHeightRequest, writer: Writer = Writer.create()): Writer { + writer.uint32(8).int64(message.height); + if (message.pagination !== undefined && message.pagination !== undefined) { + PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim(); + } + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): GetValidatorSetByHeightRequest { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseGetValidatorSetByHeightRequest } as GetValidatorSetByHeightRequest; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.height = reader.int64() as Long; + break; + case 2: + message.pagination = PageRequest.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): GetValidatorSetByHeightRequest { + const message = { ...baseGetValidatorSetByHeightRequest } as GetValidatorSetByHeightRequest; + if (object.height !== undefined && object.height !== null) { + message.height = Long.fromString(object.height); + } else { + message.height = Long.ZERO; + } + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageRequest.fromJSON(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, + fromPartial(object: DeepPartial): GetValidatorSetByHeightRequest { + const message = { ...baseGetValidatorSetByHeightRequest } as GetValidatorSetByHeightRequest; + if (object.height !== undefined && object.height !== null) { + message.height = object.height as Long; + } else { + message.height = Long.ZERO; + } + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageRequest.fromPartial(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, + toJSON(message: GetValidatorSetByHeightRequest): unknown { + const obj: any = {}; + message.height !== undefined && (obj.height = (message.height || Long.ZERO).toString()); + message.pagination !== undefined && (obj.pagination = message.pagination ? PageRequest.toJSON(message.pagination) : undefined); + return obj; + }, +}; + +export const GetValidatorSetByHeightResponse = { + encode(message: GetValidatorSetByHeightResponse, writer: Writer = Writer.create()): Writer { + writer.uint32(8).int64(message.blockHeight); + for (const v of message.validators) { + Validator.encode(v!, writer.uint32(18).fork()).ldelim(); + } + if (message.pagination !== undefined && message.pagination !== undefined) { + PageResponse.encode(message.pagination, writer.uint32(26).fork()).ldelim(); + } + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): GetValidatorSetByHeightResponse { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseGetValidatorSetByHeightResponse } as GetValidatorSetByHeightResponse; + message.validators = []; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.blockHeight = reader.int64() as Long; + break; + case 2: + message.validators.push(Validator.decode(reader, reader.uint32())); + break; + case 3: + message.pagination = PageResponse.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): GetValidatorSetByHeightResponse { + const message = { ...baseGetValidatorSetByHeightResponse } as GetValidatorSetByHeightResponse; + message.validators = []; + if (object.blockHeight !== undefined && object.blockHeight !== null) { + message.blockHeight = Long.fromString(object.blockHeight); + } else { + message.blockHeight = Long.ZERO; + } + if (object.validators !== undefined && object.validators !== null) { + for (const e of object.validators) { + message.validators.push(Validator.fromJSON(e)); + } + } + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageResponse.fromJSON(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, + fromPartial(object: DeepPartial): GetValidatorSetByHeightResponse { + const message = { ...baseGetValidatorSetByHeightResponse } as GetValidatorSetByHeightResponse; + message.validators = []; + if (object.blockHeight !== undefined && object.blockHeight !== null) { + message.blockHeight = object.blockHeight as Long; + } else { + message.blockHeight = Long.ZERO; + } + if (object.validators !== undefined && object.validators !== null) { + for (const e of object.validators) { + message.validators.push(Validator.fromPartial(e)); + } + } + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageResponse.fromPartial(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, + toJSON(message: GetValidatorSetByHeightResponse): unknown { + const obj: any = {}; + message.blockHeight !== undefined && (obj.blockHeight = (message.blockHeight || Long.ZERO).toString()); + if (message.validators) { + obj.validators = message.validators.map(e => e ? Validator.toJSON(e) : undefined); + } else { + obj.validators = []; + } + message.pagination !== undefined && (obj.pagination = message.pagination ? PageResponse.toJSON(message.pagination) : undefined); + return obj; + }, +}; + +export const GetLatestValidatorSetRequest = { + encode(message: GetLatestValidatorSetRequest, writer: Writer = Writer.create()): Writer { + if (message.pagination !== undefined && message.pagination !== undefined) { + PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): GetLatestValidatorSetRequest { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseGetLatestValidatorSetRequest } as GetLatestValidatorSetRequest; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.pagination = PageRequest.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): GetLatestValidatorSetRequest { + const message = { ...baseGetLatestValidatorSetRequest } as GetLatestValidatorSetRequest; + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageRequest.fromJSON(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, + fromPartial(object: DeepPartial): GetLatestValidatorSetRequest { + const message = { ...baseGetLatestValidatorSetRequest } as GetLatestValidatorSetRequest; + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageRequest.fromPartial(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, + toJSON(message: GetLatestValidatorSetRequest): unknown { + const obj: any = {}; + message.pagination !== undefined && (obj.pagination = message.pagination ? PageRequest.toJSON(message.pagination) : undefined); + return obj; + }, +}; + +export const GetLatestValidatorSetResponse = { + encode(message: GetLatestValidatorSetResponse, writer: Writer = Writer.create()): Writer { + writer.uint32(8).int64(message.blockHeight); + for (const v of message.validators) { + Validator.encode(v!, writer.uint32(18).fork()).ldelim(); + } + if (message.pagination !== undefined && message.pagination !== undefined) { + PageResponse.encode(message.pagination, writer.uint32(26).fork()).ldelim(); + } + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): GetLatestValidatorSetResponse { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseGetLatestValidatorSetResponse } as GetLatestValidatorSetResponse; + message.validators = []; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.blockHeight = reader.int64() as Long; + break; + case 2: + message.validators.push(Validator.decode(reader, reader.uint32())); + break; + case 3: + message.pagination = PageResponse.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): GetLatestValidatorSetResponse { + const message = { ...baseGetLatestValidatorSetResponse } as GetLatestValidatorSetResponse; + message.validators = []; + if (object.blockHeight !== undefined && object.blockHeight !== null) { + message.blockHeight = Long.fromString(object.blockHeight); + } else { + message.blockHeight = Long.ZERO; + } + if (object.validators !== undefined && object.validators !== null) { + for (const e of object.validators) { + message.validators.push(Validator.fromJSON(e)); + } + } + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageResponse.fromJSON(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, + fromPartial(object: DeepPartial): GetLatestValidatorSetResponse { + const message = { ...baseGetLatestValidatorSetResponse } as GetLatestValidatorSetResponse; + message.validators = []; + if (object.blockHeight !== undefined && object.blockHeight !== null) { + message.blockHeight = object.blockHeight as Long; + } else { + message.blockHeight = Long.ZERO; + } + if (object.validators !== undefined && object.validators !== null) { + for (const e of object.validators) { + message.validators.push(Validator.fromPartial(e)); + } + } + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageResponse.fromPartial(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, + toJSON(message: GetLatestValidatorSetResponse): unknown { + const obj: any = {}; + message.blockHeight !== undefined && (obj.blockHeight = (message.blockHeight || Long.ZERO).toString()); + if (message.validators) { + obj.validators = message.validators.map(e => e ? Validator.toJSON(e) : undefined); + } else { + obj.validators = []; + } + message.pagination !== undefined && (obj.pagination = message.pagination ? PageResponse.toJSON(message.pagination) : undefined); + return obj; + }, +}; + +export const Validator = { + encode(message: Validator, writer: Writer = Writer.create()): Writer { + writer.uint32(10).string(message.address); + if (message.pubKey !== undefined && message.pubKey !== undefined) { + Any.encode(message.pubKey, writer.uint32(18).fork()).ldelim(); + } + writer.uint32(24).int64(message.votingPower); + writer.uint32(32).int64(message.proposerPriority); + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): Validator { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseValidator } as Validator; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.address = reader.string(); + break; + case 2: + message.pubKey = Any.decode(reader, reader.uint32()); + break; + case 3: + message.votingPower = reader.int64() as Long; + break; + case 4: + message.proposerPriority = reader.int64() as Long; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): Validator { + const message = { ...baseValidator } as Validator; + if (object.address !== undefined && object.address !== null) { + message.address = String(object.address); + } else { + message.address = ""; + } + if (object.pubKey !== undefined && object.pubKey !== null) { + message.pubKey = Any.fromJSON(object.pubKey); + } else { + message.pubKey = undefined; + } + if (object.votingPower !== undefined && object.votingPower !== null) { + message.votingPower = Long.fromString(object.votingPower); + } else { + message.votingPower = Long.ZERO; + } + if (object.proposerPriority !== undefined && object.proposerPriority !== null) { + message.proposerPriority = Long.fromString(object.proposerPriority); + } else { + message.proposerPriority = Long.ZERO; + } + return message; + }, + fromPartial(object: DeepPartial): Validator { + const message = { ...baseValidator } as Validator; + if (object.address !== undefined && object.address !== null) { + message.address = object.address; + } else { + message.address = ""; + } + if (object.pubKey !== undefined && object.pubKey !== null) { + message.pubKey = Any.fromPartial(object.pubKey); + } else { + message.pubKey = undefined; + } + if (object.votingPower !== undefined && object.votingPower !== null) { + message.votingPower = object.votingPower as Long; + } else { + message.votingPower = Long.ZERO; + } + if (object.proposerPriority !== undefined && object.proposerPriority !== null) { + message.proposerPriority = object.proposerPriority as Long; + } else { + message.proposerPriority = Long.ZERO; + } + return message; + }, + toJSON(message: Validator): unknown { + const obj: any = {}; + message.address !== undefined && (obj.address = message.address); + message.pubKey !== undefined && (obj.pubKey = message.pubKey ? Any.toJSON(message.pubKey) : undefined); + message.votingPower !== undefined && (obj.votingPower = (message.votingPower || Long.ZERO).toString()); + message.proposerPriority !== undefined && (obj.proposerPriority = (message.proposerPriority || Long.ZERO).toString()); + return obj; + }, +}; + +export const GetBlockByHeightRequest = { + encode(message: GetBlockByHeightRequest, writer: Writer = Writer.create()): Writer { + writer.uint32(8).int64(message.height); + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): GetBlockByHeightRequest { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseGetBlockByHeightRequest } as GetBlockByHeightRequest; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.height = reader.int64() as Long; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): GetBlockByHeightRequest { + const message = { ...baseGetBlockByHeightRequest } as GetBlockByHeightRequest; + if (object.height !== undefined && object.height !== null) { + message.height = Long.fromString(object.height); + } else { + message.height = Long.ZERO; + } + return message; + }, + fromPartial(object: DeepPartial): GetBlockByHeightRequest { + const message = { ...baseGetBlockByHeightRequest } as GetBlockByHeightRequest; + if (object.height !== undefined && object.height !== null) { + message.height = object.height as Long; + } else { + message.height = Long.ZERO; + } + return message; + }, + toJSON(message: GetBlockByHeightRequest): unknown { + const obj: any = {}; + message.height !== undefined && (obj.height = (message.height || Long.ZERO).toString()); + return obj; + }, +}; + +export const GetBlockByHeightResponse = { + encode(message: GetBlockByHeightResponse, writer: Writer = Writer.create()): Writer { + if (message.blockId !== undefined && message.blockId !== undefined) { + BlockID.encode(message.blockId, writer.uint32(10).fork()).ldelim(); + } + if (message.block !== undefined && message.block !== undefined) { + Block.encode(message.block, writer.uint32(18).fork()).ldelim(); + } + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): GetBlockByHeightResponse { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseGetBlockByHeightResponse } as GetBlockByHeightResponse; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.blockId = BlockID.decode(reader, reader.uint32()); + break; + case 2: + message.block = Block.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): GetBlockByHeightResponse { + const message = { ...baseGetBlockByHeightResponse } as GetBlockByHeightResponse; + if (object.blockId !== undefined && object.blockId !== null) { + message.blockId = BlockID.fromJSON(object.blockId); + } else { + message.blockId = undefined; + } + if (object.block !== undefined && object.block !== null) { + message.block = Block.fromJSON(object.block); + } else { + message.block = undefined; + } + return message; + }, + fromPartial(object: DeepPartial): GetBlockByHeightResponse { + const message = { ...baseGetBlockByHeightResponse } as GetBlockByHeightResponse; + if (object.blockId !== undefined && object.blockId !== null) { + message.blockId = BlockID.fromPartial(object.blockId); + } else { + message.blockId = undefined; + } + if (object.block !== undefined && object.block !== null) { + message.block = Block.fromPartial(object.block); + } else { + message.block = undefined; + } + return message; + }, + toJSON(message: GetBlockByHeightResponse): unknown { + const obj: any = {}; + message.blockId !== undefined && (obj.blockId = message.blockId ? BlockID.toJSON(message.blockId) : undefined); + message.block !== undefined && (obj.block = message.block ? Block.toJSON(message.block) : undefined); + return obj; + }, +}; + +export const GetLatestBlockRequest = { + encode(_: GetLatestBlockRequest, writer: Writer = Writer.create()): Writer { + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): GetLatestBlockRequest { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseGetLatestBlockRequest } as GetLatestBlockRequest; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(_: any): GetLatestBlockRequest { + const message = { ...baseGetLatestBlockRequest } as GetLatestBlockRequest; + return message; + }, + fromPartial(_: DeepPartial): GetLatestBlockRequest { + const message = { ...baseGetLatestBlockRequest } as GetLatestBlockRequest; + return message; + }, + toJSON(_: GetLatestBlockRequest): unknown { + const obj: any = {}; + return obj; + }, +}; + +export const GetLatestBlockResponse = { + encode(message: GetLatestBlockResponse, writer: Writer = Writer.create()): Writer { + if (message.blockId !== undefined && message.blockId !== undefined) { + BlockID.encode(message.blockId, writer.uint32(10).fork()).ldelim(); + } + if (message.block !== undefined && message.block !== undefined) { + Block.encode(message.block, writer.uint32(18).fork()).ldelim(); + } + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): GetLatestBlockResponse { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseGetLatestBlockResponse } as GetLatestBlockResponse; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.blockId = BlockID.decode(reader, reader.uint32()); + break; + case 2: + message.block = Block.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): GetLatestBlockResponse { + const message = { ...baseGetLatestBlockResponse } as GetLatestBlockResponse; + if (object.blockId !== undefined && object.blockId !== null) { + message.blockId = BlockID.fromJSON(object.blockId); + } else { + message.blockId = undefined; + } + if (object.block !== undefined && object.block !== null) { + message.block = Block.fromJSON(object.block); + } else { + message.block = undefined; + } + return message; + }, + fromPartial(object: DeepPartial): GetLatestBlockResponse { + const message = { ...baseGetLatestBlockResponse } as GetLatestBlockResponse; + if (object.blockId !== undefined && object.blockId !== null) { + message.blockId = BlockID.fromPartial(object.blockId); + } else { + message.blockId = undefined; + } + if (object.block !== undefined && object.block !== null) { + message.block = Block.fromPartial(object.block); + } else { + message.block = undefined; + } + return message; + }, + toJSON(message: GetLatestBlockResponse): unknown { + const obj: any = {}; + message.blockId !== undefined && (obj.blockId = message.blockId ? BlockID.toJSON(message.blockId) : undefined); + message.block !== undefined && (obj.block = message.block ? Block.toJSON(message.block) : undefined); + return obj; + }, +}; + +export const GetSyncingRequest = { + encode(_: GetSyncingRequest, writer: Writer = Writer.create()): Writer { + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): GetSyncingRequest { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseGetSyncingRequest } as GetSyncingRequest; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(_: any): GetSyncingRequest { + const message = { ...baseGetSyncingRequest } as GetSyncingRequest; + return message; + }, + fromPartial(_: DeepPartial): GetSyncingRequest { + const message = { ...baseGetSyncingRequest } as GetSyncingRequest; + return message; + }, + toJSON(_: GetSyncingRequest): unknown { + const obj: any = {}; + return obj; + }, +}; + +export const GetSyncingResponse = { + encode(message: GetSyncingResponse, writer: Writer = Writer.create()): Writer { + writer.uint32(8).bool(message.syncing); + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): GetSyncingResponse { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseGetSyncingResponse } as GetSyncingResponse; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.syncing = reader.bool(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): GetSyncingResponse { + const message = { ...baseGetSyncingResponse } as GetSyncingResponse; + if (object.syncing !== undefined && object.syncing !== null) { + message.syncing = Boolean(object.syncing); + } else { + message.syncing = false; + } + return message; + }, + fromPartial(object: DeepPartial): GetSyncingResponse { + const message = { ...baseGetSyncingResponse } as GetSyncingResponse; + if (object.syncing !== undefined && object.syncing !== null) { + message.syncing = object.syncing; + } else { + message.syncing = false; + } + return message; + }, + toJSON(message: GetSyncingResponse): unknown { + const obj: any = {}; + message.syncing !== undefined && (obj.syncing = message.syncing); + return obj; + }, +}; + +export const GetNodeInfoRequest = { + encode(_: GetNodeInfoRequest, writer: Writer = Writer.create()): Writer { + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): GetNodeInfoRequest { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseGetNodeInfoRequest } as GetNodeInfoRequest; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(_: any): GetNodeInfoRequest { + const message = { ...baseGetNodeInfoRequest } as GetNodeInfoRequest; + return message; + }, + fromPartial(_: DeepPartial): GetNodeInfoRequest { + const message = { ...baseGetNodeInfoRequest } as GetNodeInfoRequest; + return message; + }, + toJSON(_: GetNodeInfoRequest): unknown { + const obj: any = {}; + return obj; + }, +}; + +export const GetNodeInfoResponse = { + encode(message: GetNodeInfoResponse, writer: Writer = Writer.create()): Writer { + if (message.defaultNodeInfo !== undefined && message.defaultNodeInfo !== undefined) { + DefaultNodeInfo.encode(message.defaultNodeInfo, writer.uint32(10).fork()).ldelim(); + } + if (message.applicationVersion !== undefined && message.applicationVersion !== undefined) { + VersionInfo.encode(message.applicationVersion, writer.uint32(18).fork()).ldelim(); + } + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): GetNodeInfoResponse { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseGetNodeInfoResponse } as GetNodeInfoResponse; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.defaultNodeInfo = DefaultNodeInfo.decode(reader, reader.uint32()); + break; + case 2: + message.applicationVersion = VersionInfo.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): GetNodeInfoResponse { + const message = { ...baseGetNodeInfoResponse } as GetNodeInfoResponse; + if (object.defaultNodeInfo !== undefined && object.defaultNodeInfo !== null) { + message.defaultNodeInfo = DefaultNodeInfo.fromJSON(object.defaultNodeInfo); + } else { + message.defaultNodeInfo = undefined; + } + if (object.applicationVersion !== undefined && object.applicationVersion !== null) { + message.applicationVersion = VersionInfo.fromJSON(object.applicationVersion); + } else { + message.applicationVersion = undefined; + } + return message; + }, + fromPartial(object: DeepPartial): GetNodeInfoResponse { + const message = { ...baseGetNodeInfoResponse } as GetNodeInfoResponse; + if (object.defaultNodeInfo !== undefined && object.defaultNodeInfo !== null) { + message.defaultNodeInfo = DefaultNodeInfo.fromPartial(object.defaultNodeInfo); + } else { + message.defaultNodeInfo = undefined; + } + if (object.applicationVersion !== undefined && object.applicationVersion !== null) { + message.applicationVersion = VersionInfo.fromPartial(object.applicationVersion); + } else { + message.applicationVersion = undefined; + } + return message; + }, + toJSON(message: GetNodeInfoResponse): unknown { + const obj: any = {}; + message.defaultNodeInfo !== undefined && (obj.defaultNodeInfo = message.defaultNodeInfo ? DefaultNodeInfo.toJSON(message.defaultNodeInfo) : undefined); + message.applicationVersion !== undefined && (obj.applicationVersion = message.applicationVersion ? VersionInfo.toJSON(message.applicationVersion) : undefined); + return obj; + }, +}; + +export const VersionInfo = { + encode(message: VersionInfo, writer: Writer = Writer.create()): Writer { + writer.uint32(10).string(message.name); + writer.uint32(18).string(message.appName); + writer.uint32(26).string(message.version); + writer.uint32(34).string(message.gitCommit); + writer.uint32(42).string(message.buildTags); + writer.uint32(50).string(message.goVersion); + for (const v of message.buildDeps) { + Module.encode(v!, writer.uint32(58).fork()).ldelim(); + } + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): VersionInfo { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseVersionInfo } as VersionInfo; + message.buildDeps = []; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.name = reader.string(); + break; + case 2: + message.appName = reader.string(); + break; + case 3: + message.version = reader.string(); + break; + case 4: + message.gitCommit = reader.string(); + break; + case 5: + message.buildTags = reader.string(); + break; + case 6: + message.goVersion = reader.string(); + break; + case 7: + message.buildDeps.push(Module.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): VersionInfo { + const message = { ...baseVersionInfo } as VersionInfo; + message.buildDeps = []; + if (object.name !== undefined && object.name !== null) { + message.name = String(object.name); + } else { + message.name = ""; + } + if (object.appName !== undefined && object.appName !== null) { + message.appName = String(object.appName); + } else { + message.appName = ""; + } + if (object.version !== undefined && object.version !== null) { + message.version = String(object.version); + } else { + message.version = ""; + } + if (object.gitCommit !== undefined && object.gitCommit !== null) { + message.gitCommit = String(object.gitCommit); + } else { + message.gitCommit = ""; + } + if (object.buildTags !== undefined && object.buildTags !== null) { + message.buildTags = String(object.buildTags); + } else { + message.buildTags = ""; + } + if (object.goVersion !== undefined && object.goVersion !== null) { + message.goVersion = String(object.goVersion); + } else { + message.goVersion = ""; + } + if (object.buildDeps !== undefined && object.buildDeps !== null) { + for (const e of object.buildDeps) { + message.buildDeps.push(Module.fromJSON(e)); + } + } + return message; + }, + fromPartial(object: DeepPartial): VersionInfo { + const message = { ...baseVersionInfo } as VersionInfo; + message.buildDeps = []; + if (object.name !== undefined && object.name !== null) { + message.name = object.name; + } else { + message.name = ""; + } + if (object.appName !== undefined && object.appName !== null) { + message.appName = object.appName; + } else { + message.appName = ""; + } + if (object.version !== undefined && object.version !== null) { + message.version = object.version; + } else { + message.version = ""; + } + if (object.gitCommit !== undefined && object.gitCommit !== null) { + message.gitCommit = object.gitCommit; + } else { + message.gitCommit = ""; + } + if (object.buildTags !== undefined && object.buildTags !== null) { + message.buildTags = object.buildTags; + } else { + message.buildTags = ""; + } + if (object.goVersion !== undefined && object.goVersion !== null) { + message.goVersion = object.goVersion; + } else { + message.goVersion = ""; + } + if (object.buildDeps !== undefined && object.buildDeps !== null) { + for (const e of object.buildDeps) { + message.buildDeps.push(Module.fromPartial(e)); + } + } + return message; + }, + toJSON(message: VersionInfo): unknown { + const obj: any = {}; + message.name !== undefined && (obj.name = message.name); + message.appName !== undefined && (obj.appName = message.appName); + message.version !== undefined && (obj.version = message.version); + message.gitCommit !== undefined && (obj.gitCommit = message.gitCommit); + message.buildTags !== undefined && (obj.buildTags = message.buildTags); + message.goVersion !== undefined && (obj.goVersion = message.goVersion); + if (message.buildDeps) { + obj.buildDeps = message.buildDeps.map(e => e ? Module.toJSON(e) : undefined); + } else { + obj.buildDeps = []; + } + return obj; + }, +}; + +export const Module = { + encode(message: Module, writer: Writer = Writer.create()): Writer { + writer.uint32(10).string(message.path); + writer.uint32(18).string(message.version); + writer.uint32(26).string(message.sum); + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): Module { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseModule } as Module; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.path = reader.string(); + break; + case 2: + message.version = reader.string(); + break; + case 3: + message.sum = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): Module { + const message = { ...baseModule } as Module; + if (object.path !== undefined && object.path !== null) { + message.path = String(object.path); + } else { + message.path = ""; + } + if (object.version !== undefined && object.version !== null) { + message.version = String(object.version); + } else { + message.version = ""; + } + if (object.sum !== undefined && object.sum !== null) { + message.sum = String(object.sum); + } else { + message.sum = ""; + } + return message; + }, + fromPartial(object: DeepPartial): Module { + const message = { ...baseModule } as Module; + if (object.path !== undefined && object.path !== null) { + message.path = object.path; + } else { + message.path = ""; + } + if (object.version !== undefined && object.version !== null) { + message.version = object.version; + } else { + message.version = ""; + } + if (object.sum !== undefined && object.sum !== null) { + message.sum = object.sum; + } else { + message.sum = ""; + } + return message; + }, + toJSON(message: Module): unknown { + const obj: any = {}; + message.path !== undefined && (obj.path = message.path); + message.version !== undefined && (obj.version = message.version); + message.sum !== undefined && (obj.sum = message.sum); + return obj; + }, +}; + +type Builtin = Date | Function | Uint8Array | string | number | undefined; +export type DeepPartial = T extends Builtin + ? T + : T extends Array + ? Array> + : T extends ReadonlyArray + ? ReadonlyArray> + : T extends {} + ? { [K in keyof T]?: DeepPartial } + : Partial; \ No newline at end of file diff --git a/packages/api/src/generated/cosmos/staking/v1beta1/tx.ts b/packages/api/src/generated/cosmos/staking/v1beta1/tx.ts index 1bde3225..693c6cee 100644 --- a/packages/api/src/generated/cosmos/staking/v1beta1/tx.ts +++ b/packages/api/src/generated/cosmos/staking/v1beta1/tx.ts @@ -36,7 +36,6 @@ export interface MsgEditValidator { * We pass a reference to the new commission rate and min self delegation as * it's not mandatory to update. If not updated, the deserialized rate will be * zero with no way to distinguish if an update was intended. - * * REF: #2373 */ commissionRate: string; diff --git a/packages/api/src/generated/cosmos/tx/v1beta1/service.ts b/packages/api/src/generated/cosmos/tx/v1beta1/service.ts index 77599304..59607a76 100644 --- a/packages/api/src/generated/cosmos/tx/v1beta1/service.ts +++ b/packages/api/src/generated/cosmos/tx/v1beta1/service.ts @@ -11,9 +11,9 @@ import { Reader, Writer } from 'protobufjs/minimal'; */ export interface GetTxsEventRequest { /** - * event is the transaction event type. + * events is the list of transaction event type. */ - event: string; + events: string[]; /** * pagination defines an pagination for the request. */ @@ -39,6 +39,29 @@ export interface GetTxsEventResponse { pagination?: PageResponse; } +/** + * BroadcastTxRequest is the request type for the Service.BroadcastTxRequest + * RPC method. + */ +export interface BroadcastTxRequest { + /** + * tx_bytes is the raw transaction. + */ + txBytes: Uint8Array; + mode: BroadcastMode; +} + +/** + * BroadcastTxResponse is the response type for the + * Service.BroadcastTx method. + */ +export interface BroadcastTxResponse { + /** + * tx_response is the queried TxResponses. + */ + txResponse?: TxResponse; +} + /** * SimulateRequest is the request type for the Service.Simulate * RPC method. @@ -91,12 +114,19 @@ export interface GetTxResponse { } const baseGetTxsEventRequest: object = { - event: "", + events: "", }; const baseGetTxsEventResponse: object = { }; +const baseBroadcastTxRequest: object = { + mode: 0, +}; + +const baseBroadcastTxResponse: object = { +}; + const baseSimulateRequest: object = { }; @@ -125,6 +155,11 @@ export interface Service { */ GetTx(request: GetTxRequest): Promise; + /** + * BroadcastTx broadcast transaction. + */ + BroadcastTx(request: BroadcastTxRequest): Promise; + /** * GetTxsEvent fetches txs by event. */ @@ -152,6 +187,12 @@ export class ServiceClientImpl implements Service { return promise.then(data => GetTxResponse.decode(new Reader(data))); } + BroadcastTx(request: BroadcastTxRequest): Promise { + const data = BroadcastTxRequest.encode(request).finish(); + const promise = this.rpc.request("cosmos.tx.v1beta1.Service", "BroadcastTx", data); + return promise.then(data => BroadcastTxResponse.decode(new Reader(data))); + } + GetTxsEvent(request: GetTxsEventRequest): Promise { const data = GetTxsEventRequest.encode(request).finish(); const promise = this.rpc.request("cosmos.tx.v1beta1.Service", "GetTxsEvent", data); @@ -168,9 +209,68 @@ interface Rpc { export const protobufPackage = 'cosmos.tx.v1beta1' +/** BroadcastMode specifies the broadcast mode for the TxService.Broadcast RPC method. + */ +export enum BroadcastMode { + /** BROADCAST_MODE_UNSPECIFIED - zero-value for mode ordering + */ + BROADCAST_MODE_UNSPECIFIED = 0, + /** BROADCAST_MODE_BLOCK - BROADCAST_MODE_BLOCK defines a tx broadcasting mode where the client waits for + the tx to be committed in a block. + */ + BROADCAST_MODE_BLOCK = 1, + /** BROADCAST_MODE_SYNC - BROADCAST_MODE_SYNC defines a tx broadcasting mode where the client waits for + a CheckTx execution response only. + */ + BROADCAST_MODE_SYNC = 2, + /** BROADCAST_MODE_ASYNC - BROADCAST_MODE_ASYNC defines a tx broadcasting mode where the client returns + immediately. + */ + BROADCAST_MODE_ASYNC = 3, + UNRECOGNIZED = -1, +} + +export function broadcastModeFromJSON(object: any): BroadcastMode { + switch (object) { + case 0: + case "BROADCAST_MODE_UNSPECIFIED": + return BroadcastMode.BROADCAST_MODE_UNSPECIFIED; + case 1: + case "BROADCAST_MODE_BLOCK": + return BroadcastMode.BROADCAST_MODE_BLOCK; + case 2: + case "BROADCAST_MODE_SYNC": + return BroadcastMode.BROADCAST_MODE_SYNC; + case 3: + case "BROADCAST_MODE_ASYNC": + return BroadcastMode.BROADCAST_MODE_ASYNC; + case -1: + case "UNRECOGNIZED": + default: + return BroadcastMode.UNRECOGNIZED; + } +} + +export function broadcastModeToJSON(object: BroadcastMode): string { + switch (object) { + case BroadcastMode.BROADCAST_MODE_UNSPECIFIED: + return "BROADCAST_MODE_UNSPECIFIED"; + case BroadcastMode.BROADCAST_MODE_BLOCK: + return "BROADCAST_MODE_BLOCK"; + case BroadcastMode.BROADCAST_MODE_SYNC: + return "BROADCAST_MODE_SYNC"; + case BroadcastMode.BROADCAST_MODE_ASYNC: + return "BROADCAST_MODE_ASYNC"; + default: + return "UNKNOWN"; + } +} + export const GetTxsEventRequest = { encode(message: GetTxsEventRequest, writer: Writer = Writer.create()): Writer { - writer.uint32(10).string(message.event); + for (const v of message.events) { + writer.uint32(10).string(v!); + } if (message.pagination !== undefined && message.pagination !== undefined) { PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim(); } @@ -180,11 +280,12 @@ export const GetTxsEventRequest = { const reader = input instanceof Uint8Array ? new Reader(input) : input; let end = length === undefined ? reader.len : reader.pos + length; const message = { ...baseGetTxsEventRequest } as GetTxsEventRequest; + message.events = []; while (reader.pos < end) { const tag = reader.uint32(); switch (tag >>> 3) { case 1: - message.event = reader.string(); + message.events.push(reader.string()); break; case 2: message.pagination = PageRequest.decode(reader, reader.uint32()); @@ -198,10 +299,11 @@ export const GetTxsEventRequest = { }, fromJSON(object: any): GetTxsEventRequest { const message = { ...baseGetTxsEventRequest } as GetTxsEventRequest; - if (object.event !== undefined && object.event !== null) { - message.event = String(object.event); - } else { - message.event = ""; + message.events = []; + if (object.events !== undefined && object.events !== null) { + for (const e of object.events) { + message.events.push(String(e)); + } } if (object.pagination !== undefined && object.pagination !== null) { message.pagination = PageRequest.fromJSON(object.pagination); @@ -212,10 +314,11 @@ export const GetTxsEventRequest = { }, fromPartial(object: DeepPartial): GetTxsEventRequest { const message = { ...baseGetTxsEventRequest } as GetTxsEventRequest; - if (object.event !== undefined && object.event !== null) { - message.event = object.event; - } else { - message.event = ""; + message.events = []; + if (object.events !== undefined && object.events !== null) { + for (const e of object.events) { + message.events.push(e); + } } if (object.pagination !== undefined && object.pagination !== null) { message.pagination = PageRequest.fromPartial(object.pagination); @@ -226,7 +329,11 @@ export const GetTxsEventRequest = { }, toJSON(message: GetTxsEventRequest): unknown { const obj: any = {}; - message.event !== undefined && (obj.event = message.event); + if (message.events) { + obj.events = message.events.map(e => e); + } else { + obj.events = []; + } message.pagination !== undefined && (obj.pagination = message.pagination ? PageRequest.toJSON(message.pagination) : undefined); return obj; }, @@ -329,6 +436,115 @@ export const GetTxsEventResponse = { }, }; +export const BroadcastTxRequest = { + encode(message: BroadcastTxRequest, writer: Writer = Writer.create()): Writer { + writer.uint32(10).bytes(message.txBytes); + writer.uint32(16).int32(message.mode); + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): BroadcastTxRequest { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseBroadcastTxRequest } as BroadcastTxRequest; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.txBytes = reader.bytes(); + break; + case 2: + message.mode = reader.int32() as any; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): BroadcastTxRequest { + const message = { ...baseBroadcastTxRequest } as BroadcastTxRequest; + if (object.txBytes !== undefined && object.txBytes !== null) { + message.txBytes = bytesFromBase64(object.txBytes); + } + if (object.mode !== undefined && object.mode !== null) { + message.mode = broadcastModeFromJSON(object.mode); + } else { + message.mode = 0; + } + return message; + }, + fromPartial(object: DeepPartial): BroadcastTxRequest { + const message = { ...baseBroadcastTxRequest } as BroadcastTxRequest; + if (object.txBytes !== undefined && object.txBytes !== null) { + message.txBytes = object.txBytes; + } else { + message.txBytes = new Uint8Array(); + } + if (object.mode !== undefined && object.mode !== null) { + message.mode = object.mode; + } else { + message.mode = 0; + } + return message; + }, + toJSON(message: BroadcastTxRequest): unknown { + const obj: any = {}; + message.txBytes !== undefined && (obj.txBytes = base64FromBytes(message.txBytes !== undefined ? message.txBytes : new Uint8Array())); + message.mode !== undefined && (obj.mode = broadcastModeToJSON(message.mode)); + return obj; + }, +}; + +export const BroadcastTxResponse = { + encode(message: BroadcastTxResponse, writer: Writer = Writer.create()): Writer { + if (message.txResponse !== undefined && message.txResponse !== undefined) { + TxResponse.encode(message.txResponse, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): BroadcastTxResponse { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseBroadcastTxResponse } as BroadcastTxResponse; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.txResponse = TxResponse.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): BroadcastTxResponse { + const message = { ...baseBroadcastTxResponse } as BroadcastTxResponse; + if (object.txResponse !== undefined && object.txResponse !== null) { + message.txResponse = TxResponse.fromJSON(object.txResponse); + } else { + message.txResponse = undefined; + } + return message; + }, + fromPartial(object: DeepPartial): BroadcastTxResponse { + const message = { ...baseBroadcastTxResponse } as BroadcastTxResponse; + if (object.txResponse !== undefined && object.txResponse !== null) { + message.txResponse = TxResponse.fromPartial(object.txResponse); + } else { + message.txResponse = undefined; + } + return message; + }, + toJSON(message: BroadcastTxResponse): unknown { + const obj: any = {}; + message.txResponse !== undefined && (obj.txResponse = message.txResponse ? TxResponse.toJSON(message.txResponse) : undefined); + return obj; + }, +}; + export const SimulateRequest = { encode(message: SimulateRequest, writer: Writer = Writer.create()): Writer { if (message.tx !== undefined && message.tx !== undefined) { @@ -557,6 +773,31 @@ export const GetTxResponse = { }, }; +interface WindowBase64 { + atob(b64: string): string; + btoa(bin: string): string; +} + +const windowBase64 = (globalThis as unknown as WindowBase64); +const atob = windowBase64.atob || ((b64: string) => Buffer.from(b64, 'base64').toString('binary')); +const btoa = windowBase64.btoa || ((bin: string) => Buffer.from(bin, 'binary').toString('base64')); + +function bytesFromBase64(b64: string): Uint8Array { + const bin = atob(b64); + const arr = new Uint8Array(bin.length); + for (let i = 0; i < bin.length; ++i) { + arr[i] = bin.charCodeAt(i); + } + return arr; +} + +function base64FromBytes(arr: Uint8Array): string { + const bin: string[] = []; + for (let i = 0; i < arr.byteLength; ++i) { + bin.push(String.fromCharCode(arr[i])); + } + return btoa(bin.join('')); +} type Builtin = Date | Function | Uint8Array | string | number | undefined; export type DeepPartial = T extends Builtin ? T diff --git a/packages/api/src/generated/cosmos/tx/v1beta1/tx.ts b/packages/api/src/generated/cosmos/tx/v1beta1/tx.ts index 2bbe43ee..ff996802 100644 --- a/packages/api/src/generated/cosmos/tx/v1beta1/tx.ts +++ b/packages/api/src/generated/cosmos/tx/v1beta1/tx.ts @@ -89,7 +89,6 @@ export interface TxBody { * those messages define the number and order of elements in AuthInfo's * signer_infos and Tx's signatures. Each required signer address is added to * the list only the first time it occurs. - * * By convention, the first required signer (usually from the first message) * is referred to as the primary signer and pays the fee for the whole * transaction. diff --git a/packages/api/src/generated/cosmos/upgrade/v1beta1/query.ts b/packages/api/src/generated/cosmos/upgrade/v1beta1/query.ts index c0bba92f..c1855184 100644 --- a/packages/api/src/generated/cosmos/upgrade/v1beta1/query.ts +++ b/packages/api/src/generated/cosmos/upgrade/v1beta1/query.ts @@ -1,6 +1,7 @@ /* eslint-disable */ import { Plan } from '../../../cosmos/upgrade/v1beta1/upgrade'; import * as Long from 'long'; +import { Any } from '../../../google/protobuf/any'; import { Reader, Writer } from 'protobufjs/minimal'; @@ -44,6 +45,26 @@ export interface QueryAppliedPlanResponse { height: Long; } +/** + * QueryUpgradedConsensusStateRequest is the request type for the Query/UpgradedConsensusState + * RPC method. + */ +export interface QueryUpgradedConsensusStateRequest { + /** + * last height of the current chain must be sent in request + * as this is the height under which next consensus state is stored + */ + lastHeight: Long; +} + +/** + * QueryUpgradedConsensusStateResponse is the response type for the Query/UpgradedConsensusState + * RPC method. + */ +export interface QueryUpgradedConsensusStateResponse { + upgradedConsensusState?: Any; +} + const baseQueryCurrentPlanRequest: object = { }; @@ -58,6 +79,13 @@ const baseQueryAppliedPlanResponse: object = { height: Long.ZERO, }; +const baseQueryUpgradedConsensusStateRequest: object = { + lastHeight: Long.ZERO, +}; + +const baseQueryUpgradedConsensusStateResponse: object = { +}; + /** * Query defines the gRPC upgrade querier service. */ @@ -73,6 +101,14 @@ export interface Query { */ AppliedPlan(request: QueryAppliedPlanRequest): Promise; + /** + * UpgradedConsensusState queries the consensus state that will serve + * as a trusted kernel for the next version of this chain. It will only be + * stored at the last height of this chain. + * UpgradedConsensusState RPC not supported with legacy querier + */ + UpgradedConsensusState(request: QueryUpgradedConsensusStateRequest): Promise; + } export class QueryClientImpl implements Query { @@ -95,6 +131,12 @@ export class QueryClientImpl implements Query { return promise.then(data => QueryAppliedPlanResponse.decode(new Reader(data))); } + UpgradedConsensusState(request: QueryUpgradedConsensusStateRequest): Promise { + const data = QueryUpgradedConsensusStateRequest.encode(request).finish(); + const promise = this.rpc.request("cosmos.upgrade.v1beta1.Query", "UpgradedConsensusState", data); + return promise.then(data => QueryUpgradedConsensusStateResponse.decode(new Reader(data))); + } + } interface Rpc { @@ -280,6 +322,102 @@ export const QueryAppliedPlanResponse = { }, }; +export const QueryUpgradedConsensusStateRequest = { + encode(message: QueryUpgradedConsensusStateRequest, writer: Writer = Writer.create()): Writer { + writer.uint32(8).int64(message.lastHeight); + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): QueryUpgradedConsensusStateRequest { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseQueryUpgradedConsensusStateRequest } as QueryUpgradedConsensusStateRequest; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.lastHeight = reader.int64() as Long; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): QueryUpgradedConsensusStateRequest { + const message = { ...baseQueryUpgradedConsensusStateRequest } as QueryUpgradedConsensusStateRequest; + if (object.lastHeight !== undefined && object.lastHeight !== null) { + message.lastHeight = Long.fromString(object.lastHeight); + } else { + message.lastHeight = Long.ZERO; + } + return message; + }, + fromPartial(object: DeepPartial): QueryUpgradedConsensusStateRequest { + const message = { ...baseQueryUpgradedConsensusStateRequest } as QueryUpgradedConsensusStateRequest; + if (object.lastHeight !== undefined && object.lastHeight !== null) { + message.lastHeight = object.lastHeight as Long; + } else { + message.lastHeight = Long.ZERO; + } + return message; + }, + toJSON(message: QueryUpgradedConsensusStateRequest): unknown { + const obj: any = {}; + message.lastHeight !== undefined && (obj.lastHeight = (message.lastHeight || Long.ZERO).toString()); + return obj; + }, +}; + +export const QueryUpgradedConsensusStateResponse = { + encode(message: QueryUpgradedConsensusStateResponse, writer: Writer = Writer.create()): Writer { + if (message.upgradedConsensusState !== undefined && message.upgradedConsensusState !== undefined) { + Any.encode(message.upgradedConsensusState, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): QueryUpgradedConsensusStateResponse { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseQueryUpgradedConsensusStateResponse } as QueryUpgradedConsensusStateResponse; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.upgradedConsensusState = Any.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): QueryUpgradedConsensusStateResponse { + const message = { ...baseQueryUpgradedConsensusStateResponse } as QueryUpgradedConsensusStateResponse; + if (object.upgradedConsensusState !== undefined && object.upgradedConsensusState !== null) { + message.upgradedConsensusState = Any.fromJSON(object.upgradedConsensusState); + } else { + message.upgradedConsensusState = undefined; + } + return message; + }, + fromPartial(object: DeepPartial): QueryUpgradedConsensusStateResponse { + const message = { ...baseQueryUpgradedConsensusStateResponse } as QueryUpgradedConsensusStateResponse; + if (object.upgradedConsensusState !== undefined && object.upgradedConsensusState !== null) { + message.upgradedConsensusState = Any.fromPartial(object.upgradedConsensusState); + } else { + message.upgradedConsensusState = undefined; + } + return message; + }, + toJSON(message: QueryUpgradedConsensusStateResponse): unknown { + const obj: any = {}; + message.upgradedConsensusState !== undefined && (obj.upgradedConsensusState = message.upgradedConsensusState ? Any.toJSON(message.upgradedConsensusState) : undefined); + return obj; + }, +}; + type Builtin = Date | Function | Uint8Array | string | number | undefined; export type DeepPartial = T extends Builtin ? T diff --git a/packages/api/src/generated/google/protobuf/timestamp.ts b/packages/api/src/generated/google/protobuf/timestamp.ts index 3ef63d11..894d25f6 100644 --- a/packages/api/src/generated/google/protobuf/timestamp.ts +++ b/packages/api/src/generated/google/protobuf/timestamp.ts @@ -55,16 +55,7 @@ import { Writer, Reader } from 'protobufjs/minimal'; * .setNanos((int) ((millis % 1000) * 1000000)).build(); * * - * Example 5: Compute Timestamp from Java `Instant.now()`. - * - * Instant now = Instant.now(); - * - * Timestamp timestamp = - * Timestamp.newBuilder().setSeconds(now.getEpochSecond()) - * .setNanos(now.getNano()).build(); - * - * - * Example 6: Compute Timestamp from current time in Python. + * Example 5: Compute Timestamp from current time in Python. * * timestamp = Timestamp() * timestamp.GetCurrentTime() diff --git a/packages/api/src/generated/tendermint/p2p/types.ts b/packages/api/src/generated/tendermint/p2p/types.ts new file mode 100644 index 00000000..005d33e0 --- /dev/null +++ b/packages/api/src/generated/tendermint/p2p/types.ts @@ -0,0 +1,465 @@ +/* eslint-disable */ +import * as Long from 'long'; +import { Writer, Reader } from 'protobufjs/minimal'; + + +export interface NetAddress { + id: string; + ip: string; + port: number; +} + +export interface ProtocolVersion { + p2p: Long; + block: Long; + app: Long; +} + +export interface DefaultNodeInfo { + protocolVersion?: ProtocolVersion; + defaultNodeId: string; + listenAddr: string; + network: string; + version: string; + channels: Uint8Array; + moniker: string; + other?: DefaultNodeInfoOther; +} + +export interface DefaultNodeInfoOther { + txIndex: string; + rpcAddress: string; +} + +const baseNetAddress: object = { + id: "", + ip: "", + port: 0, +}; + +const baseProtocolVersion: object = { + p2p: Long.UZERO, + block: Long.UZERO, + app: Long.UZERO, +}; + +const baseDefaultNodeInfo: object = { + defaultNodeId: "", + listenAddr: "", + network: "", + version: "", + moniker: "", +}; + +const baseDefaultNodeInfoOther: object = { + txIndex: "", + rpcAddress: "", +}; + +export const protobufPackage = 'tendermint.p2p' + +export const NetAddress = { + encode(message: NetAddress, writer: Writer = Writer.create()): Writer { + writer.uint32(10).string(message.id); + writer.uint32(18).string(message.ip); + writer.uint32(24).uint32(message.port); + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): NetAddress { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseNetAddress } as NetAddress; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.id = reader.string(); + break; + case 2: + message.ip = reader.string(); + break; + case 3: + message.port = reader.uint32(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): NetAddress { + const message = { ...baseNetAddress } as NetAddress; + if (object.id !== undefined && object.id !== null) { + message.id = String(object.id); + } else { + message.id = ""; + } + if (object.ip !== undefined && object.ip !== null) { + message.ip = String(object.ip); + } else { + message.ip = ""; + } + if (object.port !== undefined && object.port !== null) { + message.port = Number(object.port); + } else { + message.port = 0; + } + return message; + }, + fromPartial(object: DeepPartial): NetAddress { + const message = { ...baseNetAddress } as NetAddress; + if (object.id !== undefined && object.id !== null) { + message.id = object.id; + } else { + message.id = ""; + } + if (object.ip !== undefined && object.ip !== null) { + message.ip = object.ip; + } else { + message.ip = ""; + } + if (object.port !== undefined && object.port !== null) { + message.port = object.port; + } else { + message.port = 0; + } + return message; + }, + toJSON(message: NetAddress): unknown { + const obj: any = {}; + message.id !== undefined && (obj.id = message.id); + message.ip !== undefined && (obj.ip = message.ip); + message.port !== undefined && (obj.port = message.port); + return obj; + }, +}; + +export const ProtocolVersion = { + encode(message: ProtocolVersion, writer: Writer = Writer.create()): Writer { + writer.uint32(8).uint64(message.p2p); + writer.uint32(16).uint64(message.block); + writer.uint32(24).uint64(message.app); + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): ProtocolVersion { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseProtocolVersion } as ProtocolVersion; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.p2p = reader.uint64() as Long; + break; + case 2: + message.block = reader.uint64() as Long; + break; + case 3: + message.app = reader.uint64() as Long; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): ProtocolVersion { + const message = { ...baseProtocolVersion } as ProtocolVersion; + if (object.p2p !== undefined && object.p2p !== null) { + message.p2p = Long.fromString(object.p2p); + } else { + message.p2p = Long.UZERO; + } + if (object.block !== undefined && object.block !== null) { + message.block = Long.fromString(object.block); + } else { + message.block = Long.UZERO; + } + if (object.app !== undefined && object.app !== null) { + message.app = Long.fromString(object.app); + } else { + message.app = Long.UZERO; + } + return message; + }, + fromPartial(object: DeepPartial): ProtocolVersion { + const message = { ...baseProtocolVersion } as ProtocolVersion; + if (object.p2p !== undefined && object.p2p !== null) { + message.p2p = object.p2p as Long; + } else { + message.p2p = Long.UZERO; + } + if (object.block !== undefined && object.block !== null) { + message.block = object.block as Long; + } else { + message.block = Long.UZERO; + } + if (object.app !== undefined && object.app !== null) { + message.app = object.app as Long; + } else { + message.app = Long.UZERO; + } + return message; + }, + toJSON(message: ProtocolVersion): unknown { + const obj: any = {}; + message.p2p !== undefined && (obj.p2p = (message.p2p || Long.UZERO).toString()); + message.block !== undefined && (obj.block = (message.block || Long.UZERO).toString()); + message.app !== undefined && (obj.app = (message.app || Long.UZERO).toString()); + return obj; + }, +}; + +export const DefaultNodeInfo = { + encode(message: DefaultNodeInfo, writer: Writer = Writer.create()): Writer { + if (message.protocolVersion !== undefined && message.protocolVersion !== undefined) { + ProtocolVersion.encode(message.protocolVersion, writer.uint32(10).fork()).ldelim(); + } + writer.uint32(18).string(message.defaultNodeId); + writer.uint32(26).string(message.listenAddr); + writer.uint32(34).string(message.network); + writer.uint32(42).string(message.version); + writer.uint32(50).bytes(message.channels); + writer.uint32(58).string(message.moniker); + if (message.other !== undefined && message.other !== undefined) { + DefaultNodeInfoOther.encode(message.other, writer.uint32(66).fork()).ldelim(); + } + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): DefaultNodeInfo { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseDefaultNodeInfo } as DefaultNodeInfo; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.protocolVersion = ProtocolVersion.decode(reader, reader.uint32()); + break; + case 2: + message.defaultNodeId = reader.string(); + break; + case 3: + message.listenAddr = reader.string(); + break; + case 4: + message.network = reader.string(); + break; + case 5: + message.version = reader.string(); + break; + case 6: + message.channels = reader.bytes(); + break; + case 7: + message.moniker = reader.string(); + break; + case 8: + message.other = DefaultNodeInfoOther.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): DefaultNodeInfo { + const message = { ...baseDefaultNodeInfo } as DefaultNodeInfo; + if (object.protocolVersion !== undefined && object.protocolVersion !== null) { + message.protocolVersion = ProtocolVersion.fromJSON(object.protocolVersion); + } else { + message.protocolVersion = undefined; + } + if (object.defaultNodeId !== undefined && object.defaultNodeId !== null) { + message.defaultNodeId = String(object.defaultNodeId); + } else { + message.defaultNodeId = ""; + } + if (object.listenAddr !== undefined && object.listenAddr !== null) { + message.listenAddr = String(object.listenAddr); + } else { + message.listenAddr = ""; + } + if (object.network !== undefined && object.network !== null) { + message.network = String(object.network); + } else { + message.network = ""; + } + if (object.version !== undefined && object.version !== null) { + message.version = String(object.version); + } else { + message.version = ""; + } + if (object.channels !== undefined && object.channels !== null) { + message.channels = bytesFromBase64(object.channels); + } + if (object.moniker !== undefined && object.moniker !== null) { + message.moniker = String(object.moniker); + } else { + message.moniker = ""; + } + if (object.other !== undefined && object.other !== null) { + message.other = DefaultNodeInfoOther.fromJSON(object.other); + } else { + message.other = undefined; + } + return message; + }, + fromPartial(object: DeepPartial): DefaultNodeInfo { + const message = { ...baseDefaultNodeInfo } as DefaultNodeInfo; + if (object.protocolVersion !== undefined && object.protocolVersion !== null) { + message.protocolVersion = ProtocolVersion.fromPartial(object.protocolVersion); + } else { + message.protocolVersion = undefined; + } + if (object.defaultNodeId !== undefined && object.defaultNodeId !== null) { + message.defaultNodeId = object.defaultNodeId; + } else { + message.defaultNodeId = ""; + } + if (object.listenAddr !== undefined && object.listenAddr !== null) { + message.listenAddr = object.listenAddr; + } else { + message.listenAddr = ""; + } + if (object.network !== undefined && object.network !== null) { + message.network = object.network; + } else { + message.network = ""; + } + if (object.version !== undefined && object.version !== null) { + message.version = object.version; + } else { + message.version = ""; + } + if (object.channels !== undefined && object.channels !== null) { + message.channels = object.channels; + } else { + message.channels = new Uint8Array(); + } + if (object.moniker !== undefined && object.moniker !== null) { + message.moniker = object.moniker; + } else { + message.moniker = ""; + } + if (object.other !== undefined && object.other !== null) { + message.other = DefaultNodeInfoOther.fromPartial(object.other); + } else { + message.other = undefined; + } + return message; + }, + toJSON(message: DefaultNodeInfo): unknown { + const obj: any = {}; + message.protocolVersion !== undefined && (obj.protocolVersion = message.protocolVersion ? ProtocolVersion.toJSON(message.protocolVersion) : undefined); + message.defaultNodeId !== undefined && (obj.defaultNodeId = message.defaultNodeId); + message.listenAddr !== undefined && (obj.listenAddr = message.listenAddr); + message.network !== undefined && (obj.network = message.network); + message.version !== undefined && (obj.version = message.version); + message.channels !== undefined && (obj.channels = base64FromBytes(message.channels !== undefined ? message.channels : new Uint8Array())); + message.moniker !== undefined && (obj.moniker = message.moniker); + message.other !== undefined && (obj.other = message.other ? DefaultNodeInfoOther.toJSON(message.other) : undefined); + return obj; + }, +}; + +export const DefaultNodeInfoOther = { + encode(message: DefaultNodeInfoOther, writer: Writer = Writer.create()): Writer { + writer.uint32(10).string(message.txIndex); + writer.uint32(18).string(message.rpcAddress); + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): DefaultNodeInfoOther { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseDefaultNodeInfoOther } as DefaultNodeInfoOther; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.txIndex = reader.string(); + break; + case 2: + message.rpcAddress = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): DefaultNodeInfoOther { + const message = { ...baseDefaultNodeInfoOther } as DefaultNodeInfoOther; + if (object.txIndex !== undefined && object.txIndex !== null) { + message.txIndex = String(object.txIndex); + } else { + message.txIndex = ""; + } + if (object.rpcAddress !== undefined && object.rpcAddress !== null) { + message.rpcAddress = String(object.rpcAddress); + } else { + message.rpcAddress = ""; + } + return message; + }, + fromPartial(object: DeepPartial): DefaultNodeInfoOther { + const message = { ...baseDefaultNodeInfoOther } as DefaultNodeInfoOther; + if (object.txIndex !== undefined && object.txIndex !== null) { + message.txIndex = object.txIndex; + } else { + message.txIndex = ""; + } + if (object.rpcAddress !== undefined && object.rpcAddress !== null) { + message.rpcAddress = object.rpcAddress; + } else { + message.rpcAddress = ""; + } + return message; + }, + toJSON(message: DefaultNodeInfoOther): unknown { + const obj: any = {}; + message.txIndex !== undefined && (obj.txIndex = message.txIndex); + message.rpcAddress !== undefined && (obj.rpcAddress = message.rpcAddress); + return obj; + }, +}; + +interface WindowBase64 { + atob(b64: string): string; + btoa(bin: string): string; +} + +const windowBase64 = (globalThis as unknown as WindowBase64); +const atob = windowBase64.atob || ((b64: string) => Buffer.from(b64, 'base64').toString('binary')); +const btoa = windowBase64.btoa || ((bin: string) => Buffer.from(bin, 'binary').toString('base64')); + +function bytesFromBase64(b64: string): Uint8Array { + const bin = atob(b64); + const arr = new Uint8Array(bin.length); + for (let i = 0; i < bin.length; ++i) { + arr[i] = bin.charCodeAt(i); + } + return arr; +} + +function base64FromBytes(arr: Uint8Array): string { + const bin: string[] = []; + for (let i = 0; i < arr.byteLength; ++i) { + bin.push(String.fromCharCode(arr[i])); + } + return btoa(bin.join('')); +} +type Builtin = Date | Function | Uint8Array | string | number | undefined; +export type DeepPartial = T extends Builtin + ? T + : T extends Array + ? Array> + : T extends ReadonlyArray + ? ReadonlyArray> + : T extends {} + ? { [K in keyof T]?: DeepPartial } + : Partial; \ No newline at end of file diff --git a/packages/api/src/generated/tendermint/types/block.ts b/packages/api/src/generated/tendermint/types/block.ts new file mode 100644 index 00000000..5d312b9d --- /dev/null +++ b/packages/api/src/generated/tendermint/types/block.ts @@ -0,0 +1,128 @@ +/* eslint-disable */ +import { Header, Data, Commit } from '../../tendermint/types/types'; +import { EvidenceList } from '../../tendermint/types/evidence'; +import { Writer, Reader } from 'protobufjs/minimal'; + + +export interface Block { + header?: Header; + data?: Data; + evidence?: EvidenceList; + lastCommit?: Commit; +} + +const baseBlock: object = { +}; + +export const protobufPackage = 'tendermint.types' + +export const Block = { + encode(message: Block, writer: Writer = Writer.create()): Writer { + if (message.header !== undefined && message.header !== undefined) { + Header.encode(message.header, writer.uint32(10).fork()).ldelim(); + } + if (message.data !== undefined && message.data !== undefined) { + Data.encode(message.data, writer.uint32(18).fork()).ldelim(); + } + if (message.evidence !== undefined && message.evidence !== undefined) { + EvidenceList.encode(message.evidence, writer.uint32(26).fork()).ldelim(); + } + if (message.lastCommit !== undefined && message.lastCommit !== undefined) { + Commit.encode(message.lastCommit, writer.uint32(34).fork()).ldelim(); + } + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): Block { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseBlock } as Block; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.header = Header.decode(reader, reader.uint32()); + break; + case 2: + message.data = Data.decode(reader, reader.uint32()); + break; + case 3: + message.evidence = EvidenceList.decode(reader, reader.uint32()); + break; + case 4: + message.lastCommit = Commit.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): Block { + const message = { ...baseBlock } as Block; + if (object.header !== undefined && object.header !== null) { + message.header = Header.fromJSON(object.header); + } else { + message.header = undefined; + } + if (object.data !== undefined && object.data !== null) { + message.data = Data.fromJSON(object.data); + } else { + message.data = undefined; + } + if (object.evidence !== undefined && object.evidence !== null) { + message.evidence = EvidenceList.fromJSON(object.evidence); + } else { + message.evidence = undefined; + } + if (object.lastCommit !== undefined && object.lastCommit !== null) { + message.lastCommit = Commit.fromJSON(object.lastCommit); + } else { + message.lastCommit = undefined; + } + return message; + }, + fromPartial(object: DeepPartial): Block { + const message = { ...baseBlock } as Block; + if (object.header !== undefined && object.header !== null) { + message.header = Header.fromPartial(object.header); + } else { + message.header = undefined; + } + if (object.data !== undefined && object.data !== null) { + message.data = Data.fromPartial(object.data); + } else { + message.data = undefined; + } + if (object.evidence !== undefined && object.evidence !== null) { + message.evidence = EvidenceList.fromPartial(object.evidence); + } else { + message.evidence = undefined; + } + if (object.lastCommit !== undefined && object.lastCommit !== null) { + message.lastCommit = Commit.fromPartial(object.lastCommit); + } else { + message.lastCommit = undefined; + } + return message; + }, + toJSON(message: Block): unknown { + const obj: any = {}; + message.header !== undefined && (obj.header = message.header ? Header.toJSON(message.header) : undefined); + message.data !== undefined && (obj.data = message.data ? Data.toJSON(message.data) : undefined); + message.evidence !== undefined && (obj.evidence = message.evidence ? EvidenceList.toJSON(message.evidence) : undefined); + message.lastCommit !== undefined && (obj.lastCommit = message.lastCommit ? Commit.toJSON(message.lastCommit) : undefined); + return obj; + }, +}; + +type Builtin = Date | Function | Uint8Array | string | number | undefined; +export type DeepPartial = T extends Builtin + ? T + : T extends Array + ? Array> + : T extends ReadonlyArray + ? ReadonlyArray> + : T extends {} + ? { [K in keyof T]?: DeepPartial } + : Partial; \ No newline at end of file diff --git a/packages/api/src/generated/tendermint/types/evidence.ts b/packages/api/src/generated/tendermint/types/evidence.ts new file mode 100644 index 00000000..b04fe2b6 --- /dev/null +++ b/packages/api/src/generated/tendermint/types/evidence.ts @@ -0,0 +1,453 @@ +/* eslint-disable */ +import { Vote, LightBlock } from '../../tendermint/types/types'; +import * as Long from 'long'; +import { Validator } from '../../tendermint/types/validator'; +import { Timestamp } from '../../google/protobuf/timestamp'; +import { Writer, Reader, util, configure } from 'protobufjs/minimal'; + + +export interface Evidence { + duplicateVoteEvidence?: DuplicateVoteEvidence | undefined; + lightClientAttackEvidence?: LightClientAttackEvidence | undefined; +} + +/** + * DuplicateVoteEvidence contains evidence of a validator signed two conflicting votes. + */ +export interface DuplicateVoteEvidence { + voteA?: Vote; + voteB?: Vote; + totalVotingPower: Long; + validatorPower: Long; + timestamp?: Date; +} + +/** + * LightClientAttackEvidence contains evidence of a set of validators attempting to mislead a light client. + */ +export interface LightClientAttackEvidence { + conflictingBlock?: LightBlock; + commonHeight: Long; + byzantineValidators: Validator[]; + totalVotingPower: Long; + timestamp?: Date; +} + +export interface EvidenceList { + evidence: Evidence[]; +} + +const baseEvidence: object = { +}; + +const baseDuplicateVoteEvidence: object = { + totalVotingPower: Long.ZERO, + validatorPower: Long.ZERO, +}; + +const baseLightClientAttackEvidence: object = { + commonHeight: Long.ZERO, + totalVotingPower: Long.ZERO, +}; + +const baseEvidenceList: object = { +}; + +function fromJsonTimestamp(o: any): Date { + if (o instanceof Date) { + return o; + } else if (typeof o === "string") { + return new Date(o); + } else { + return fromTimestamp(Timestamp.fromJSON(o)); + } +} + +function toTimestamp(date: Date): Timestamp { + const seconds = numberToLong(date.getTime() / 1_000); + const nanos = (date.getTime() % 1_000) * 1_000_000; + return { seconds, nanos }; +} + +function fromTimestamp(t: Timestamp): Date { + let millis = t.seconds.toNumber() * 1_000; + millis += t.nanos / 1_000_000; + return new Date(millis); +} + +function numberToLong(number: number) { + return Long.fromNumber(number); +} + +export const protobufPackage = 'tendermint.types' + +export const Evidence = { + encode(message: Evidence, writer: Writer = Writer.create()): Writer { + if (message.duplicateVoteEvidence !== undefined) { + DuplicateVoteEvidence.encode(message.duplicateVoteEvidence, writer.uint32(10).fork()).ldelim(); + } + if (message.lightClientAttackEvidence !== undefined) { + LightClientAttackEvidence.encode(message.lightClientAttackEvidence, writer.uint32(18).fork()).ldelim(); + } + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): Evidence { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseEvidence } as Evidence; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.duplicateVoteEvidence = DuplicateVoteEvidence.decode(reader, reader.uint32()); + break; + case 2: + message.lightClientAttackEvidence = LightClientAttackEvidence.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): Evidence { + const message = { ...baseEvidence } as Evidence; + if (object.duplicateVoteEvidence !== undefined && object.duplicateVoteEvidence !== null) { + message.duplicateVoteEvidence = DuplicateVoteEvidence.fromJSON(object.duplicateVoteEvidence); + } else { + message.duplicateVoteEvidence = undefined; + } + if (object.lightClientAttackEvidence !== undefined && object.lightClientAttackEvidence !== null) { + message.lightClientAttackEvidence = LightClientAttackEvidence.fromJSON(object.lightClientAttackEvidence); + } else { + message.lightClientAttackEvidence = undefined; + } + return message; + }, + fromPartial(object: DeepPartial): Evidence { + const message = { ...baseEvidence } as Evidence; + if (object.duplicateVoteEvidence !== undefined && object.duplicateVoteEvidence !== null) { + message.duplicateVoteEvidence = DuplicateVoteEvidence.fromPartial(object.duplicateVoteEvidence); + } else { + message.duplicateVoteEvidence = undefined; + } + if (object.lightClientAttackEvidence !== undefined && object.lightClientAttackEvidence !== null) { + message.lightClientAttackEvidence = LightClientAttackEvidence.fromPartial(object.lightClientAttackEvidence); + } else { + message.lightClientAttackEvidence = undefined; + } + return message; + }, + toJSON(message: Evidence): unknown { + const obj: any = {}; + message.duplicateVoteEvidence !== undefined && (obj.duplicateVoteEvidence = message.duplicateVoteEvidence ? DuplicateVoteEvidence.toJSON(message.duplicateVoteEvidence) : undefined); + message.lightClientAttackEvidence !== undefined && (obj.lightClientAttackEvidence = message.lightClientAttackEvidence ? LightClientAttackEvidence.toJSON(message.lightClientAttackEvidence) : undefined); + return obj; + }, +}; + +export const DuplicateVoteEvidence = { + encode(message: DuplicateVoteEvidence, writer: Writer = Writer.create()): Writer { + if (message.voteA !== undefined && message.voteA !== undefined) { + Vote.encode(message.voteA, writer.uint32(10).fork()).ldelim(); + } + if (message.voteB !== undefined && message.voteB !== undefined) { + Vote.encode(message.voteB, writer.uint32(18).fork()).ldelim(); + } + writer.uint32(24).int64(message.totalVotingPower); + writer.uint32(32).int64(message.validatorPower); + if (message.timestamp !== undefined && message.timestamp !== undefined) { + Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(42).fork()).ldelim(); + } + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): DuplicateVoteEvidence { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseDuplicateVoteEvidence } as DuplicateVoteEvidence; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.voteA = Vote.decode(reader, reader.uint32()); + break; + case 2: + message.voteB = Vote.decode(reader, reader.uint32()); + break; + case 3: + message.totalVotingPower = reader.int64() as Long; + break; + case 4: + message.validatorPower = reader.int64() as Long; + break; + case 5: + message.timestamp = fromTimestamp(Timestamp.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): DuplicateVoteEvidence { + const message = { ...baseDuplicateVoteEvidence } as DuplicateVoteEvidence; + if (object.voteA !== undefined && object.voteA !== null) { + message.voteA = Vote.fromJSON(object.voteA); + } else { + message.voteA = undefined; + } + if (object.voteB !== undefined && object.voteB !== null) { + message.voteB = Vote.fromJSON(object.voteB); + } else { + message.voteB = undefined; + } + if (object.totalVotingPower !== undefined && object.totalVotingPower !== null) { + message.totalVotingPower = Long.fromString(object.totalVotingPower); + } else { + message.totalVotingPower = Long.ZERO; + } + if (object.validatorPower !== undefined && object.validatorPower !== null) { + message.validatorPower = Long.fromString(object.validatorPower); + } else { + message.validatorPower = Long.ZERO; + } + if (object.timestamp !== undefined && object.timestamp !== null) { + message.timestamp = fromJsonTimestamp(object.timestamp); + } else { + message.timestamp = undefined; + } + return message; + }, + fromPartial(object: DeepPartial): DuplicateVoteEvidence { + const message = { ...baseDuplicateVoteEvidence } as DuplicateVoteEvidence; + if (object.voteA !== undefined && object.voteA !== null) { + message.voteA = Vote.fromPartial(object.voteA); + } else { + message.voteA = undefined; + } + if (object.voteB !== undefined && object.voteB !== null) { + message.voteB = Vote.fromPartial(object.voteB); + } else { + message.voteB = undefined; + } + if (object.totalVotingPower !== undefined && object.totalVotingPower !== null) { + message.totalVotingPower = object.totalVotingPower as Long; + } else { + message.totalVotingPower = Long.ZERO; + } + if (object.validatorPower !== undefined && object.validatorPower !== null) { + message.validatorPower = object.validatorPower as Long; + } else { + message.validatorPower = Long.ZERO; + } + if (object.timestamp !== undefined && object.timestamp !== null) { + message.timestamp = object.timestamp; + } else { + message.timestamp = undefined; + } + return message; + }, + toJSON(message: DuplicateVoteEvidence): unknown { + const obj: any = {}; + message.voteA !== undefined && (obj.voteA = message.voteA ? Vote.toJSON(message.voteA) : undefined); + message.voteB !== undefined && (obj.voteB = message.voteB ? Vote.toJSON(message.voteB) : undefined); + message.totalVotingPower !== undefined && (obj.totalVotingPower = (message.totalVotingPower || Long.ZERO).toString()); + message.validatorPower !== undefined && (obj.validatorPower = (message.validatorPower || Long.ZERO).toString()); + message.timestamp !== undefined && (obj.timestamp = message.timestamp !== undefined ? message.timestamp.toISOString() : null); + return obj; + }, +}; + +export const LightClientAttackEvidence = { + encode(message: LightClientAttackEvidence, writer: Writer = Writer.create()): Writer { + if (message.conflictingBlock !== undefined && message.conflictingBlock !== undefined) { + LightBlock.encode(message.conflictingBlock, writer.uint32(10).fork()).ldelim(); + } + writer.uint32(16).int64(message.commonHeight); + for (const v of message.byzantineValidators) { + Validator.encode(v!, writer.uint32(26).fork()).ldelim(); + } + writer.uint32(32).int64(message.totalVotingPower); + if (message.timestamp !== undefined && message.timestamp !== undefined) { + Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(42).fork()).ldelim(); + } + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): LightClientAttackEvidence { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseLightClientAttackEvidence } as LightClientAttackEvidence; + message.byzantineValidators = []; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.conflictingBlock = LightBlock.decode(reader, reader.uint32()); + break; + case 2: + message.commonHeight = reader.int64() as Long; + break; + case 3: + message.byzantineValidators.push(Validator.decode(reader, reader.uint32())); + break; + case 4: + message.totalVotingPower = reader.int64() as Long; + break; + case 5: + message.timestamp = fromTimestamp(Timestamp.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): LightClientAttackEvidence { + const message = { ...baseLightClientAttackEvidence } as LightClientAttackEvidence; + message.byzantineValidators = []; + if (object.conflictingBlock !== undefined && object.conflictingBlock !== null) { + message.conflictingBlock = LightBlock.fromJSON(object.conflictingBlock); + } else { + message.conflictingBlock = undefined; + } + if (object.commonHeight !== undefined && object.commonHeight !== null) { + message.commonHeight = Long.fromString(object.commonHeight); + } else { + message.commonHeight = Long.ZERO; + } + if (object.byzantineValidators !== undefined && object.byzantineValidators !== null) { + for (const e of object.byzantineValidators) { + message.byzantineValidators.push(Validator.fromJSON(e)); + } + } + if (object.totalVotingPower !== undefined && object.totalVotingPower !== null) { + message.totalVotingPower = Long.fromString(object.totalVotingPower); + } else { + message.totalVotingPower = Long.ZERO; + } + if (object.timestamp !== undefined && object.timestamp !== null) { + message.timestamp = fromJsonTimestamp(object.timestamp); + } else { + message.timestamp = undefined; + } + return message; + }, + fromPartial(object: DeepPartial): LightClientAttackEvidence { + const message = { ...baseLightClientAttackEvidence } as LightClientAttackEvidence; + message.byzantineValidators = []; + if (object.conflictingBlock !== undefined && object.conflictingBlock !== null) { + message.conflictingBlock = LightBlock.fromPartial(object.conflictingBlock); + } else { + message.conflictingBlock = undefined; + } + if (object.commonHeight !== undefined && object.commonHeight !== null) { + message.commonHeight = object.commonHeight as Long; + } else { + message.commonHeight = Long.ZERO; + } + if (object.byzantineValidators !== undefined && object.byzantineValidators !== null) { + for (const e of object.byzantineValidators) { + message.byzantineValidators.push(Validator.fromPartial(e)); + } + } + if (object.totalVotingPower !== undefined && object.totalVotingPower !== null) { + message.totalVotingPower = object.totalVotingPower as Long; + } else { + message.totalVotingPower = Long.ZERO; + } + if (object.timestamp !== undefined && object.timestamp !== null) { + message.timestamp = object.timestamp; + } else { + message.timestamp = undefined; + } + return message; + }, + toJSON(message: LightClientAttackEvidence): unknown { + const obj: any = {}; + message.conflictingBlock !== undefined && (obj.conflictingBlock = message.conflictingBlock ? LightBlock.toJSON(message.conflictingBlock) : undefined); + message.commonHeight !== undefined && (obj.commonHeight = (message.commonHeight || Long.ZERO).toString()); + if (message.byzantineValidators) { + obj.byzantineValidators = message.byzantineValidators.map(e => e ? Validator.toJSON(e) : undefined); + } else { + obj.byzantineValidators = []; + } + message.totalVotingPower !== undefined && (obj.totalVotingPower = (message.totalVotingPower || Long.ZERO).toString()); + message.timestamp !== undefined && (obj.timestamp = message.timestamp !== undefined ? message.timestamp.toISOString() : null); + return obj; + }, +}; + +export const EvidenceList = { + encode(message: EvidenceList, writer: Writer = Writer.create()): Writer { + for (const v of message.evidence) { + Evidence.encode(v!, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + decode(input: Uint8Array | Reader, length?: number): EvidenceList { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseEvidenceList } as EvidenceList; + message.evidence = []; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.evidence.push(Evidence.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromJSON(object: any): EvidenceList { + const message = { ...baseEvidenceList } as EvidenceList; + message.evidence = []; + if (object.evidence !== undefined && object.evidence !== null) { + for (const e of object.evidence) { + message.evidence.push(Evidence.fromJSON(e)); + } + } + return message; + }, + fromPartial(object: DeepPartial): EvidenceList { + const message = { ...baseEvidenceList } as EvidenceList; + message.evidence = []; + if (object.evidence !== undefined && object.evidence !== null) { + for (const e of object.evidence) { + message.evidence.push(Evidence.fromPartial(e)); + } + } + return message; + }, + toJSON(message: EvidenceList): unknown { + const obj: any = {}; + if (message.evidence) { + obj.evidence = message.evidence.map(e => e ? Evidence.toJSON(e) : undefined); + } else { + obj.evidence = []; + } + return obj; + }, +}; + +if (util.Long !== Long as any) { + util.Long = Long as any; + configure(); +} + +type Builtin = Date | Function | Uint8Array | string | number | undefined; +export type DeepPartial = T extends Builtin + ? T + : T extends Array + ? Array> + : T extends ReadonlyArray + ? ReadonlyArray> + : T extends {} + ? { [K in keyof T]?: DeepPartial } + : Partial; \ No newline at end of file diff --git a/packages/api/src/generated/third_party/confio/proofs.ts b/packages/api/src/generated/third_party/confio/proofs.ts deleted file mode 100644 index 052a2378..00000000 --- a/packages/api/src/generated/third_party/confio/proofs.ts +++ /dev/null @@ -1,1613 +0,0 @@ -/* eslint-disable */ -import { Writer, Reader } from 'protobufjs/minimal'; - - -/** - * * - * ExistenceProof takes a key and a value and a set of steps to perform on it. - * The result of peforming all these steps will provide a "root hash", which can - * be compared to the value in a header. - * - * Since it is computationally infeasible to produce a hash collission for any of the used - * cryptographic hash functions, if someone can provide a series of operations to transform - * a given key and value into a root hash that matches some trusted root, these key and values - * must be in the referenced merkle tree. - * - * The only possible issue is maliablity in LeafOp, such as providing extra prefix data, - * which should be controlled by a spec. Eg. with lengthOp as NONE, - * prefix = FOO, key = BAR, value = CHOICE - * and - * prefix = F, key = OOBAR, value = CHOICE - * would produce the same value. - * - * With LengthOp this is tricker but not impossible. Which is why the "leafPrefixEqual" field - * in the ProofSpec is valuable to prevent this mutability. And why all trees should - * length-prefix the data before hashing it. - */ -export interface ExistenceProof { - key: Uint8Array; - value: Uint8Array; - leaf?: LeafOp; - path: InnerOp[]; -} - -/** - * - * NonExistenceProof takes a proof of two neighbors, one left of the desired key, - * one right of the desired key. If both proofs are valid AND they are neighbors, - * then there is no valid proof for the given key. - */ -export interface NonExistenceProof { - /** - * TODO: remove this as unnecessary??? we prove a range - */ - key: Uint8Array; - left?: ExistenceProof; - right?: ExistenceProof; -} - -/** - * - * CommitmentProof is either an ExistenceProof or a NonExistenceProof, or a Batch of such messages - */ -export interface CommitmentProof { - exist?: ExistenceProof | undefined; - nonexist?: NonExistenceProof | undefined; - batch?: BatchProof | undefined; - compressed?: CompressedBatchProof | undefined; -} - -/** - * * - * LeafOp represents the raw key-value data we wish to prove, and - * must be flexible to represent the internal transformation from - * the original key-value pairs into the basis hash, for many existing - * merkle trees. - * - * key and value are passed in. So that the signature of this operation is: - * leafOp(key, value) -> output - * - * To process this, first prehash the keys and values if needed (ANY means no hash in this case): - * hkey = prehashKey(key) - * hvalue = prehashValue(value) - * - * Then combine the bytes, and hash it - * output = hash(prefix || length(hkey) || hkey || length(hvalue) || hvalue) - */ -export interface LeafOp { - hash: HashOp; - prehashKey: HashOp; - prehashValue: HashOp; - length: LengthOp; - /** - * prefix is a fixed bytes that may optionally be included at the beginning to differentiate - * a leaf node from an inner node. - */ - prefix: Uint8Array; -} - -/** - * * - * InnerOp represents a merkle-proof step that is not a leaf. - * It represents concatenating two children and hashing them to provide the next result. - * - * The result of the previous step is passed in, so the signature of this op is: - * innerOp(child) -> output - * - * The result of applying InnerOp should be: - * output = op.hash(op.prefix || child || op.suffix) - * - * where the || operator is concatenation of binary data, - * and child is the result of hashing all the tree below this step. - * - * Any special data, like prepending child with the length, or prepending the entire operation with - * some value to differentiate from leaf nodes, should be included in prefix and suffix. - * If either of prefix or suffix is empty, we just treat it as an empty string - */ -export interface InnerOp { - hash: HashOp; - prefix: Uint8Array; - suffix: Uint8Array; -} - -/** - * * - * ProofSpec defines what the expected parameters are for a given proof type. - * This can be stored in the client and used to validate any incoming proofs. - * - * verify(ProofSpec, Proof) -> Proof | Error - * - * As demonstrated in tests, if we don't fix the algorithm used to calculate the - * LeafHash for a given tree, there are many possible key-value pairs that can - * generate a given hash (by interpretting the preimage differently). - * We need this for proper security, requires client knows a priori what - * tree format server uses. But not in code, rather a configuration object. - */ -export interface ProofSpec { - /** - * any field in the ExistenceProof must be the same as in this spec. - * except Prefix, which is just the first bytes of prefix (spec can be longer) - */ - leafSpec?: LeafOp; - innerSpec?: InnerSpec; - /** - * max_depth (if > 0) is the maximum number of InnerOps allowed (mainly for fixed-depth tries) - */ - maxDepth: number; - /** - * min_depth (if > 0) is the minimum number of InnerOps allowed (mainly for fixed-depth tries) - */ - minDepth: number; -} - -/** - * - * InnerSpec contains all store-specific structure info to determine if two proofs from a - * given store are neighbors. - * - * This enables: - * - * isLeftMost(spec: InnerSpec, op: InnerOp) - * isRightMost(spec: InnerSpec, op: InnerOp) - * isLeftNeighbor(spec: InnerSpec, left: InnerOp, right: InnerOp) - */ -export interface InnerSpec { - /** - * Child order is the ordering of the children node, must count from 0 - * iavl tree is [0, 1] (left then right) - * merk is [0, 2, 1] (left, right, here) - */ - childOrder: number[]; - childSize: number; - minPrefixLength: number; - maxPrefixLength: number; - /** - * empty child is the prehash image that is used when one child is nil (eg. 20 bytes of 0) - */ - emptyChild: Uint8Array; - /** - * hash is the algorithm that must be used for each InnerOp - */ - hash: HashOp; -} - -/** - * - * BatchProof is a group of multiple proof types than can be compressed - */ -export interface BatchProof { - entries: BatchEntry[]; -} - -/** - * Use BatchEntry not CommitmentProof, to avoid recursion - */ -export interface BatchEntry { - exist?: ExistenceProof | undefined; - nonexist?: NonExistenceProof | undefined; -} - -export interface CompressedBatchProof { - entries: CompressedBatchEntry[]; - lookupInners: InnerOp[]; -} - -/** - * Use BatchEntry not CommitmentProof, to avoid recursion - */ -export interface CompressedBatchEntry { - exist?: CompressedExistenceProof | undefined; - nonexist?: CompressedNonExistenceProof | undefined; -} - -export interface CompressedExistenceProof { - key: Uint8Array; - value: Uint8Array; - leaf?: LeafOp; - /** - * these are indexes into the lookup_inners table in CompressedBatchProof - */ - path: number[]; -} - -export interface CompressedNonExistenceProof { - /** - * TODO: remove this as unnecessary??? we prove a range - */ - key: Uint8Array; - left?: CompressedExistenceProof; - right?: CompressedExistenceProof; -} - -const baseExistenceProof: object = { -}; - -const baseNonExistenceProof: object = { -}; - -const baseCommitmentProof: object = { -}; - -const baseLeafOp: object = { - hash: 0, - prehashKey: 0, - prehashValue: 0, - length: 0, -}; - -const baseInnerOp: object = { - hash: 0, -}; - -const baseProofSpec: object = { - maxDepth: 0, - minDepth: 0, -}; - -const baseInnerSpec: object = { - childOrder: 0, - childSize: 0, - minPrefixLength: 0, - maxPrefixLength: 0, - hash: 0, -}; - -const baseBatchProof: object = { -}; - -const baseBatchEntry: object = { -}; - -const baseCompressedBatchProof: object = { -}; - -const baseCompressedBatchEntry: object = { -}; - -const baseCompressedExistenceProof: object = { - path: 0, -}; - -const baseCompressedNonExistenceProof: object = { -}; - -export const protobufPackage = 'ics23' - -export enum HashOp { - /** NO_HASH - NO_HASH is the default if no data passed. Note this is an illegal argument some places. - */ - NO_HASH = 0, - SHA256 = 1, - SHA512 = 2, - KECCAK = 3, - RIPEMD160 = 4, - /** BITCOIN - ripemd160(sha256(x)) - */ - BITCOIN = 5, - UNRECOGNIZED = -1, -} - -export function hashOpFromJSON(object: any): HashOp { - switch (object) { - case 0: - case "NO_HASH": - return HashOp.NO_HASH; - case 1: - case "SHA256": - return HashOp.SHA256; - case 2: - case "SHA512": - return HashOp.SHA512; - case 3: - case "KECCAK": - return HashOp.KECCAK; - case 4: - case "RIPEMD160": - return HashOp.RIPEMD160; - case 5: - case "BITCOIN": - return HashOp.BITCOIN; - case -1: - case "UNRECOGNIZED": - default: - return HashOp.UNRECOGNIZED; - } -} - -export function hashOpToJSON(object: HashOp): string { - switch (object) { - case HashOp.NO_HASH: - return "NO_HASH"; - case HashOp.SHA256: - return "SHA256"; - case HashOp.SHA512: - return "SHA512"; - case HashOp.KECCAK: - return "KECCAK"; - case HashOp.RIPEMD160: - return "RIPEMD160"; - case HashOp.BITCOIN: - return "BITCOIN"; - default: - return "UNKNOWN"; - } -} - -/** * -LengthOp defines how to process the key and value of the LeafOp -to include length information. After encoding the length with the given -algorithm, the length will be prepended to the key and value bytes. -(Each one with it's own encoded length) - */ -export enum LengthOp { - /** NO_PREFIX - NO_PREFIX don't include any length info - */ - NO_PREFIX = 0, - /** VAR_PROTO - VAR_PROTO uses protobuf (and go-amino) varint encoding of the length - */ - VAR_PROTO = 1, - /** VAR_RLP - VAR_RLP uses rlp int encoding of the length - */ - VAR_RLP = 2, - /** FIXED32_BIG - FIXED32_BIG uses big-endian encoding of the length as a 32 bit integer - */ - FIXED32_BIG = 3, - /** FIXED32_LITTLE - FIXED32_LITTLE uses little-endian encoding of the length as a 32 bit integer - */ - FIXED32_LITTLE = 4, - /** FIXED64_BIG - FIXED64_BIG uses big-endian encoding of the length as a 64 bit integer - */ - FIXED64_BIG = 5, - /** FIXED64_LITTLE - FIXED64_LITTLE uses little-endian encoding of the length as a 64 bit integer - */ - FIXED64_LITTLE = 6, - /** REQUIRE_32_BYTES - REQUIRE_32_BYTES is like NONE, but will fail if the input is not exactly 32 bytes (sha256 output) - */ - REQUIRE_32_BYTES = 7, - /** REQUIRE_64_BYTES - REQUIRE_64_BYTES is like NONE, but will fail if the input is not exactly 64 bytes (sha512 output) - */ - REQUIRE_64_BYTES = 8, - UNRECOGNIZED = -1, -} - -export function lengthOpFromJSON(object: any): LengthOp { - switch (object) { - case 0: - case "NO_PREFIX": - return LengthOp.NO_PREFIX; - case 1: - case "VAR_PROTO": - return LengthOp.VAR_PROTO; - case 2: - case "VAR_RLP": - return LengthOp.VAR_RLP; - case 3: - case "FIXED32_BIG": - return LengthOp.FIXED32_BIG; - case 4: - case "FIXED32_LITTLE": - return LengthOp.FIXED32_LITTLE; - case 5: - case "FIXED64_BIG": - return LengthOp.FIXED64_BIG; - case 6: - case "FIXED64_LITTLE": - return LengthOp.FIXED64_LITTLE; - case 7: - case "REQUIRE_32_BYTES": - return LengthOp.REQUIRE_32_BYTES; - case 8: - case "REQUIRE_64_BYTES": - return LengthOp.REQUIRE_64_BYTES; - case -1: - case "UNRECOGNIZED": - default: - return LengthOp.UNRECOGNIZED; - } -} - -export function lengthOpToJSON(object: LengthOp): string { - switch (object) { - case LengthOp.NO_PREFIX: - return "NO_PREFIX"; - case LengthOp.VAR_PROTO: - return "VAR_PROTO"; - case LengthOp.VAR_RLP: - return "VAR_RLP"; - case LengthOp.FIXED32_BIG: - return "FIXED32_BIG"; - case LengthOp.FIXED32_LITTLE: - return "FIXED32_LITTLE"; - case LengthOp.FIXED64_BIG: - return "FIXED64_BIG"; - case LengthOp.FIXED64_LITTLE: - return "FIXED64_LITTLE"; - case LengthOp.REQUIRE_32_BYTES: - return "REQUIRE_32_BYTES"; - case LengthOp.REQUIRE_64_BYTES: - return "REQUIRE_64_BYTES"; - default: - return "UNKNOWN"; - } -} - -export const ExistenceProof = { - encode(message: ExistenceProof, writer: Writer = Writer.create()): Writer { - writer.uint32(10).bytes(message.key); - writer.uint32(18).bytes(message.value); - if (message.leaf !== undefined && message.leaf !== undefined) { - LeafOp.encode(message.leaf, writer.uint32(26).fork()).ldelim(); - } - for (const v of message.path) { - InnerOp.encode(v!, writer.uint32(34).fork()).ldelim(); - } - return writer; - }, - decode(input: Uint8Array | Reader, length?: number): ExistenceProof { - const reader = input instanceof Uint8Array ? new Reader(input) : input; - let end = length === undefined ? reader.len : reader.pos + length; - const message = { ...baseExistenceProof } as ExistenceProof; - message.path = []; - while (reader.pos < end) { - const tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - message.key = reader.bytes(); - break; - case 2: - message.value = reader.bytes(); - break; - case 3: - message.leaf = LeafOp.decode(reader, reader.uint32()); - break; - case 4: - message.path.push(InnerOp.decode(reader, reader.uint32())); - break; - default: - reader.skipType(tag & 7); - break; - } - } - return message; - }, - fromJSON(object: any): ExistenceProof { - const message = { ...baseExistenceProof } as ExistenceProof; - message.path = []; - if (object.key !== undefined && object.key !== null) { - message.key = bytesFromBase64(object.key); - } - if (object.value !== undefined && object.value !== null) { - message.value = bytesFromBase64(object.value); - } - if (object.leaf !== undefined && object.leaf !== null) { - message.leaf = LeafOp.fromJSON(object.leaf); - } else { - message.leaf = undefined; - } - if (object.path !== undefined && object.path !== null) { - for (const e of object.path) { - message.path.push(InnerOp.fromJSON(e)); - } - } - return message; - }, - fromPartial(object: DeepPartial): ExistenceProof { - const message = { ...baseExistenceProof } as ExistenceProof; - message.path = []; - if (object.key !== undefined && object.key !== null) { - message.key = object.key; - } else { - message.key = new Uint8Array(); - } - if (object.value !== undefined && object.value !== null) { - message.value = object.value; - } else { - message.value = new Uint8Array(); - } - if (object.leaf !== undefined && object.leaf !== null) { - message.leaf = LeafOp.fromPartial(object.leaf); - } else { - message.leaf = undefined; - } - if (object.path !== undefined && object.path !== null) { - for (const e of object.path) { - message.path.push(InnerOp.fromPartial(e)); - } - } - return message; - }, - toJSON(message: ExistenceProof): unknown { - const obj: any = {}; - message.key !== undefined && (obj.key = base64FromBytes(message.key !== undefined ? message.key : new Uint8Array())); - message.value !== undefined && (obj.value = base64FromBytes(message.value !== undefined ? message.value : new Uint8Array())); - message.leaf !== undefined && (obj.leaf = message.leaf ? LeafOp.toJSON(message.leaf) : undefined); - if (message.path) { - obj.path = message.path.map(e => e ? InnerOp.toJSON(e) : undefined); - } else { - obj.path = []; - } - return obj; - }, -}; - -export const NonExistenceProof = { - encode(message: NonExistenceProof, writer: Writer = Writer.create()): Writer { - writer.uint32(10).bytes(message.key); - if (message.left !== undefined && message.left !== undefined) { - ExistenceProof.encode(message.left, writer.uint32(18).fork()).ldelim(); - } - if (message.right !== undefined && message.right !== undefined) { - ExistenceProof.encode(message.right, writer.uint32(26).fork()).ldelim(); - } - return writer; - }, - decode(input: Uint8Array | Reader, length?: number): NonExistenceProof { - const reader = input instanceof Uint8Array ? new Reader(input) : input; - let end = length === undefined ? reader.len : reader.pos + length; - const message = { ...baseNonExistenceProof } as NonExistenceProof; - while (reader.pos < end) { - const tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - message.key = reader.bytes(); - break; - case 2: - message.left = ExistenceProof.decode(reader, reader.uint32()); - break; - case 3: - message.right = ExistenceProof.decode(reader, reader.uint32()); - break; - default: - reader.skipType(tag & 7); - break; - } - } - return message; - }, - fromJSON(object: any): NonExistenceProof { - const message = { ...baseNonExistenceProof } as NonExistenceProof; - if (object.key !== undefined && object.key !== null) { - message.key = bytesFromBase64(object.key); - } - if (object.left !== undefined && object.left !== null) { - message.left = ExistenceProof.fromJSON(object.left); - } else { - message.left = undefined; - } - if (object.right !== undefined && object.right !== null) { - message.right = ExistenceProof.fromJSON(object.right); - } else { - message.right = undefined; - } - return message; - }, - fromPartial(object: DeepPartial): NonExistenceProof { - const message = { ...baseNonExistenceProof } as NonExistenceProof; - if (object.key !== undefined && object.key !== null) { - message.key = object.key; - } else { - message.key = new Uint8Array(); - } - if (object.left !== undefined && object.left !== null) { - message.left = ExistenceProof.fromPartial(object.left); - } else { - message.left = undefined; - } - if (object.right !== undefined && object.right !== null) { - message.right = ExistenceProof.fromPartial(object.right); - } else { - message.right = undefined; - } - return message; - }, - toJSON(message: NonExistenceProof): unknown { - const obj: any = {}; - message.key !== undefined && (obj.key = base64FromBytes(message.key !== undefined ? message.key : new Uint8Array())); - message.left !== undefined && (obj.left = message.left ? ExistenceProof.toJSON(message.left) : undefined); - message.right !== undefined && (obj.right = message.right ? ExistenceProof.toJSON(message.right) : undefined); - return obj; - }, -}; - -export const CommitmentProof = { - encode(message: CommitmentProof, writer: Writer = Writer.create()): Writer { - if (message.exist !== undefined) { - ExistenceProof.encode(message.exist, writer.uint32(10).fork()).ldelim(); - } - if (message.nonexist !== undefined) { - NonExistenceProof.encode(message.nonexist, writer.uint32(18).fork()).ldelim(); - } - if (message.batch !== undefined) { - BatchProof.encode(message.batch, writer.uint32(26).fork()).ldelim(); - } - if (message.compressed !== undefined) { - CompressedBatchProof.encode(message.compressed, writer.uint32(34).fork()).ldelim(); - } - return writer; - }, - decode(input: Uint8Array | Reader, length?: number): CommitmentProof { - const reader = input instanceof Uint8Array ? new Reader(input) : input; - let end = length === undefined ? reader.len : reader.pos + length; - const message = { ...baseCommitmentProof } as CommitmentProof; - while (reader.pos < end) { - const tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - message.exist = ExistenceProof.decode(reader, reader.uint32()); - break; - case 2: - message.nonexist = NonExistenceProof.decode(reader, reader.uint32()); - break; - case 3: - message.batch = BatchProof.decode(reader, reader.uint32()); - break; - case 4: - message.compressed = CompressedBatchProof.decode(reader, reader.uint32()); - break; - default: - reader.skipType(tag & 7); - break; - } - } - return message; - }, - fromJSON(object: any): CommitmentProof { - const message = { ...baseCommitmentProof } as CommitmentProof; - if (object.exist !== undefined && object.exist !== null) { - message.exist = ExistenceProof.fromJSON(object.exist); - } else { - message.exist = undefined; - } - if (object.nonexist !== undefined && object.nonexist !== null) { - message.nonexist = NonExistenceProof.fromJSON(object.nonexist); - } else { - message.nonexist = undefined; - } - if (object.batch !== undefined && object.batch !== null) { - message.batch = BatchProof.fromJSON(object.batch); - } else { - message.batch = undefined; - } - if (object.compressed !== undefined && object.compressed !== null) { - message.compressed = CompressedBatchProof.fromJSON(object.compressed); - } else { - message.compressed = undefined; - } - return message; - }, - fromPartial(object: DeepPartial): CommitmentProof { - const message = { ...baseCommitmentProof } as CommitmentProof; - if (object.exist !== undefined && object.exist !== null) { - message.exist = ExistenceProof.fromPartial(object.exist); - } else { - message.exist = undefined; - } - if (object.nonexist !== undefined && object.nonexist !== null) { - message.nonexist = NonExistenceProof.fromPartial(object.nonexist); - } else { - message.nonexist = undefined; - } - if (object.batch !== undefined && object.batch !== null) { - message.batch = BatchProof.fromPartial(object.batch); - } else { - message.batch = undefined; - } - if (object.compressed !== undefined && object.compressed !== null) { - message.compressed = CompressedBatchProof.fromPartial(object.compressed); - } else { - message.compressed = undefined; - } - return message; - }, - toJSON(message: CommitmentProof): unknown { - const obj: any = {}; - message.exist !== undefined && (obj.exist = message.exist ? ExistenceProof.toJSON(message.exist) : undefined); - message.nonexist !== undefined && (obj.nonexist = message.nonexist ? NonExistenceProof.toJSON(message.nonexist) : undefined); - message.batch !== undefined && (obj.batch = message.batch ? BatchProof.toJSON(message.batch) : undefined); - message.compressed !== undefined && (obj.compressed = message.compressed ? CompressedBatchProof.toJSON(message.compressed) : undefined); - return obj; - }, -}; - -export const LeafOp = { - encode(message: LeafOp, writer: Writer = Writer.create()): Writer { - writer.uint32(8).int32(message.hash); - writer.uint32(16).int32(message.prehashKey); - writer.uint32(24).int32(message.prehashValue); - writer.uint32(32).int32(message.length); - writer.uint32(42).bytes(message.prefix); - return writer; - }, - decode(input: Uint8Array | Reader, length?: number): LeafOp { - const reader = input instanceof Uint8Array ? new Reader(input) : input; - let end = length === undefined ? reader.len : reader.pos + length; - const message = { ...baseLeafOp } as LeafOp; - while (reader.pos < end) { - const tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - message.hash = reader.int32() as any; - break; - case 2: - message.prehashKey = reader.int32() as any; - break; - case 3: - message.prehashValue = reader.int32() as any; - break; - case 4: - message.length = reader.int32() as any; - break; - case 5: - message.prefix = reader.bytes(); - break; - default: - reader.skipType(tag & 7); - break; - } - } - return message; - }, - fromJSON(object: any): LeafOp { - const message = { ...baseLeafOp } as LeafOp; - if (object.hash !== undefined && object.hash !== null) { - message.hash = hashOpFromJSON(object.hash); - } else { - message.hash = 0; - } - if (object.prehashKey !== undefined && object.prehashKey !== null) { - message.prehashKey = hashOpFromJSON(object.prehashKey); - } else { - message.prehashKey = 0; - } - if (object.prehashValue !== undefined && object.prehashValue !== null) { - message.prehashValue = hashOpFromJSON(object.prehashValue); - } else { - message.prehashValue = 0; - } - if (object.length !== undefined && object.length !== null) { - message.length = lengthOpFromJSON(object.length); - } else { - message.length = 0; - } - if (object.prefix !== undefined && object.prefix !== null) { - message.prefix = bytesFromBase64(object.prefix); - } - return message; - }, - fromPartial(object: DeepPartial): LeafOp { - const message = { ...baseLeafOp } as LeafOp; - if (object.hash !== undefined && object.hash !== null) { - message.hash = object.hash; - } else { - message.hash = 0; - } - if (object.prehashKey !== undefined && object.prehashKey !== null) { - message.prehashKey = object.prehashKey; - } else { - message.prehashKey = 0; - } - if (object.prehashValue !== undefined && object.prehashValue !== null) { - message.prehashValue = object.prehashValue; - } else { - message.prehashValue = 0; - } - if (object.length !== undefined && object.length !== null) { - message.length = object.length; - } else { - message.length = 0; - } - if (object.prefix !== undefined && object.prefix !== null) { - message.prefix = object.prefix; - } else { - message.prefix = new Uint8Array(); - } - return message; - }, - toJSON(message: LeafOp): unknown { - const obj: any = {}; - message.hash !== undefined && (obj.hash = hashOpToJSON(message.hash)); - message.prehashKey !== undefined && (obj.prehashKey = hashOpToJSON(message.prehashKey)); - message.prehashValue !== undefined && (obj.prehashValue = hashOpToJSON(message.prehashValue)); - message.length !== undefined && (obj.length = lengthOpToJSON(message.length)); - message.prefix !== undefined && (obj.prefix = base64FromBytes(message.prefix !== undefined ? message.prefix : new Uint8Array())); - return obj; - }, -}; - -export const InnerOp = { - encode(message: InnerOp, writer: Writer = Writer.create()): Writer { - writer.uint32(8).int32(message.hash); - writer.uint32(18).bytes(message.prefix); - writer.uint32(26).bytes(message.suffix); - return writer; - }, - decode(input: Uint8Array | Reader, length?: number): InnerOp { - const reader = input instanceof Uint8Array ? new Reader(input) : input; - let end = length === undefined ? reader.len : reader.pos + length; - const message = { ...baseInnerOp } as InnerOp; - while (reader.pos < end) { - const tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - message.hash = reader.int32() as any; - break; - case 2: - message.prefix = reader.bytes(); - break; - case 3: - message.suffix = reader.bytes(); - break; - default: - reader.skipType(tag & 7); - break; - } - } - return message; - }, - fromJSON(object: any): InnerOp { - const message = { ...baseInnerOp } as InnerOp; - if (object.hash !== undefined && object.hash !== null) { - message.hash = hashOpFromJSON(object.hash); - } else { - message.hash = 0; - } - if (object.prefix !== undefined && object.prefix !== null) { - message.prefix = bytesFromBase64(object.prefix); - } - if (object.suffix !== undefined && object.suffix !== null) { - message.suffix = bytesFromBase64(object.suffix); - } - return message; - }, - fromPartial(object: DeepPartial): InnerOp { - const message = { ...baseInnerOp } as InnerOp; - if (object.hash !== undefined && object.hash !== null) { - message.hash = object.hash; - } else { - message.hash = 0; - } - if (object.prefix !== undefined && object.prefix !== null) { - message.prefix = object.prefix; - } else { - message.prefix = new Uint8Array(); - } - if (object.suffix !== undefined && object.suffix !== null) { - message.suffix = object.suffix; - } else { - message.suffix = new Uint8Array(); - } - return message; - }, - toJSON(message: InnerOp): unknown { - const obj: any = {}; - message.hash !== undefined && (obj.hash = hashOpToJSON(message.hash)); - message.prefix !== undefined && (obj.prefix = base64FromBytes(message.prefix !== undefined ? message.prefix : new Uint8Array())); - message.suffix !== undefined && (obj.suffix = base64FromBytes(message.suffix !== undefined ? message.suffix : new Uint8Array())); - return obj; - }, -}; - -export const ProofSpec = { - encode(message: ProofSpec, writer: Writer = Writer.create()): Writer { - if (message.leafSpec !== undefined && message.leafSpec !== undefined) { - LeafOp.encode(message.leafSpec, writer.uint32(10).fork()).ldelim(); - } - if (message.innerSpec !== undefined && message.innerSpec !== undefined) { - InnerSpec.encode(message.innerSpec, writer.uint32(18).fork()).ldelim(); - } - writer.uint32(24).int32(message.maxDepth); - writer.uint32(32).int32(message.minDepth); - return writer; - }, - decode(input: Uint8Array | Reader, length?: number): ProofSpec { - const reader = input instanceof Uint8Array ? new Reader(input) : input; - let end = length === undefined ? reader.len : reader.pos + length; - const message = { ...baseProofSpec } as ProofSpec; - while (reader.pos < end) { - const tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - message.leafSpec = LeafOp.decode(reader, reader.uint32()); - break; - case 2: - message.innerSpec = InnerSpec.decode(reader, reader.uint32()); - break; - case 3: - message.maxDepth = reader.int32(); - break; - case 4: - message.minDepth = reader.int32(); - break; - default: - reader.skipType(tag & 7); - break; - } - } - return message; - }, - fromJSON(object: any): ProofSpec { - const message = { ...baseProofSpec } as ProofSpec; - if (object.leafSpec !== undefined && object.leafSpec !== null) { - message.leafSpec = LeafOp.fromJSON(object.leafSpec); - } else { - message.leafSpec = undefined; - } - if (object.innerSpec !== undefined && object.innerSpec !== null) { - message.innerSpec = InnerSpec.fromJSON(object.innerSpec); - } else { - message.innerSpec = undefined; - } - if (object.maxDepth !== undefined && object.maxDepth !== null) { - message.maxDepth = Number(object.maxDepth); - } else { - message.maxDepth = 0; - } - if (object.minDepth !== undefined && object.minDepth !== null) { - message.minDepth = Number(object.minDepth); - } else { - message.minDepth = 0; - } - return message; - }, - fromPartial(object: DeepPartial): ProofSpec { - const message = { ...baseProofSpec } as ProofSpec; - if (object.leafSpec !== undefined && object.leafSpec !== null) { - message.leafSpec = LeafOp.fromPartial(object.leafSpec); - } else { - message.leafSpec = undefined; - } - if (object.innerSpec !== undefined && object.innerSpec !== null) { - message.innerSpec = InnerSpec.fromPartial(object.innerSpec); - } else { - message.innerSpec = undefined; - } - if (object.maxDepth !== undefined && object.maxDepth !== null) { - message.maxDepth = object.maxDepth; - } else { - message.maxDepth = 0; - } - if (object.minDepth !== undefined && object.minDepth !== null) { - message.minDepth = object.minDepth; - } else { - message.minDepth = 0; - } - return message; - }, - toJSON(message: ProofSpec): unknown { - const obj: any = {}; - message.leafSpec !== undefined && (obj.leafSpec = message.leafSpec ? LeafOp.toJSON(message.leafSpec) : undefined); - message.innerSpec !== undefined && (obj.innerSpec = message.innerSpec ? InnerSpec.toJSON(message.innerSpec) : undefined); - message.maxDepth !== undefined && (obj.maxDepth = message.maxDepth); - message.minDepth !== undefined && (obj.minDepth = message.minDepth); - return obj; - }, -}; - -export const InnerSpec = { - encode(message: InnerSpec, writer: Writer = Writer.create()): Writer { - writer.uint32(10).fork(); - for (const v of message.childOrder) { - writer.int32(v); - } - writer.ldelim(); - writer.uint32(16).int32(message.childSize); - writer.uint32(24).int32(message.minPrefixLength); - writer.uint32(32).int32(message.maxPrefixLength); - writer.uint32(42).bytes(message.emptyChild); - writer.uint32(48).int32(message.hash); - return writer; - }, - decode(input: Uint8Array | Reader, length?: number): InnerSpec { - const reader = input instanceof Uint8Array ? new Reader(input) : input; - let end = length === undefined ? reader.len : reader.pos + length; - const message = { ...baseInnerSpec } as InnerSpec; - message.childOrder = []; - while (reader.pos < end) { - const tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - if ((tag & 7) === 2) { - const end2 = reader.uint32() + reader.pos; - while (reader.pos < end2) { - message.childOrder.push(reader.int32()); - } - } else { - message.childOrder.push(reader.int32()); - } - break; - case 2: - message.childSize = reader.int32(); - break; - case 3: - message.minPrefixLength = reader.int32(); - break; - case 4: - message.maxPrefixLength = reader.int32(); - break; - case 5: - message.emptyChild = reader.bytes(); - break; - case 6: - message.hash = reader.int32() as any; - break; - default: - reader.skipType(tag & 7); - break; - } - } - return message; - }, - fromJSON(object: any): InnerSpec { - const message = { ...baseInnerSpec } as InnerSpec; - message.childOrder = []; - if (object.childOrder !== undefined && object.childOrder !== null) { - for (const e of object.childOrder) { - message.childOrder.push(Number(e)); - } - } - if (object.childSize !== undefined && object.childSize !== null) { - message.childSize = Number(object.childSize); - } else { - message.childSize = 0; - } - if (object.minPrefixLength !== undefined && object.minPrefixLength !== null) { - message.minPrefixLength = Number(object.minPrefixLength); - } else { - message.minPrefixLength = 0; - } - if (object.maxPrefixLength !== undefined && object.maxPrefixLength !== null) { - message.maxPrefixLength = Number(object.maxPrefixLength); - } else { - message.maxPrefixLength = 0; - } - if (object.emptyChild !== undefined && object.emptyChild !== null) { - message.emptyChild = bytesFromBase64(object.emptyChild); - } - if (object.hash !== undefined && object.hash !== null) { - message.hash = hashOpFromJSON(object.hash); - } else { - message.hash = 0; - } - return message; - }, - fromPartial(object: DeepPartial): InnerSpec { - const message = { ...baseInnerSpec } as InnerSpec; - message.childOrder = []; - if (object.childOrder !== undefined && object.childOrder !== null) { - for (const e of object.childOrder) { - message.childOrder.push(e); - } - } - if (object.childSize !== undefined && object.childSize !== null) { - message.childSize = object.childSize; - } else { - message.childSize = 0; - } - if (object.minPrefixLength !== undefined && object.minPrefixLength !== null) { - message.minPrefixLength = object.minPrefixLength; - } else { - message.minPrefixLength = 0; - } - if (object.maxPrefixLength !== undefined && object.maxPrefixLength !== null) { - message.maxPrefixLength = object.maxPrefixLength; - } else { - message.maxPrefixLength = 0; - } - if (object.emptyChild !== undefined && object.emptyChild !== null) { - message.emptyChild = object.emptyChild; - } else { - message.emptyChild = new Uint8Array(); - } - if (object.hash !== undefined && object.hash !== null) { - message.hash = object.hash; - } else { - message.hash = 0; - } - return message; - }, - toJSON(message: InnerSpec): unknown { - const obj: any = {}; - if (message.childOrder) { - obj.childOrder = message.childOrder.map(e => e); - } else { - obj.childOrder = []; - } - message.childSize !== undefined && (obj.childSize = message.childSize); - message.minPrefixLength !== undefined && (obj.minPrefixLength = message.minPrefixLength); - message.maxPrefixLength !== undefined && (obj.maxPrefixLength = message.maxPrefixLength); - message.emptyChild !== undefined && (obj.emptyChild = base64FromBytes(message.emptyChild !== undefined ? message.emptyChild : new Uint8Array())); - message.hash !== undefined && (obj.hash = hashOpToJSON(message.hash)); - return obj; - }, -}; - -export const BatchProof = { - encode(message: BatchProof, writer: Writer = Writer.create()): Writer { - for (const v of message.entries) { - BatchEntry.encode(v!, writer.uint32(10).fork()).ldelim(); - } - return writer; - }, - decode(input: Uint8Array | Reader, length?: number): BatchProof { - const reader = input instanceof Uint8Array ? new Reader(input) : input; - let end = length === undefined ? reader.len : reader.pos + length; - const message = { ...baseBatchProof } as BatchProof; - message.entries = []; - while (reader.pos < end) { - const tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - message.entries.push(BatchEntry.decode(reader, reader.uint32())); - break; - default: - reader.skipType(tag & 7); - break; - } - } - return message; - }, - fromJSON(object: any): BatchProof { - const message = { ...baseBatchProof } as BatchProof; - message.entries = []; - if (object.entries !== undefined && object.entries !== null) { - for (const e of object.entries) { - message.entries.push(BatchEntry.fromJSON(e)); - } - } - return message; - }, - fromPartial(object: DeepPartial): BatchProof { - const message = { ...baseBatchProof } as BatchProof; - message.entries = []; - if (object.entries !== undefined && object.entries !== null) { - for (const e of object.entries) { - message.entries.push(BatchEntry.fromPartial(e)); - } - } - return message; - }, - toJSON(message: BatchProof): unknown { - const obj: any = {}; - if (message.entries) { - obj.entries = message.entries.map(e => e ? BatchEntry.toJSON(e) : undefined); - } else { - obj.entries = []; - } - return obj; - }, -}; - -export const BatchEntry = { - encode(message: BatchEntry, writer: Writer = Writer.create()): Writer { - if (message.exist !== undefined) { - ExistenceProof.encode(message.exist, writer.uint32(10).fork()).ldelim(); - } - if (message.nonexist !== undefined) { - NonExistenceProof.encode(message.nonexist, writer.uint32(18).fork()).ldelim(); - } - return writer; - }, - decode(input: Uint8Array | Reader, length?: number): BatchEntry { - const reader = input instanceof Uint8Array ? new Reader(input) : input; - let end = length === undefined ? reader.len : reader.pos + length; - const message = { ...baseBatchEntry } as BatchEntry; - while (reader.pos < end) { - const tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - message.exist = ExistenceProof.decode(reader, reader.uint32()); - break; - case 2: - message.nonexist = NonExistenceProof.decode(reader, reader.uint32()); - break; - default: - reader.skipType(tag & 7); - break; - } - } - return message; - }, - fromJSON(object: any): BatchEntry { - const message = { ...baseBatchEntry } as BatchEntry; - if (object.exist !== undefined && object.exist !== null) { - message.exist = ExistenceProof.fromJSON(object.exist); - } else { - message.exist = undefined; - } - if (object.nonexist !== undefined && object.nonexist !== null) { - message.nonexist = NonExistenceProof.fromJSON(object.nonexist); - } else { - message.nonexist = undefined; - } - return message; - }, - fromPartial(object: DeepPartial): BatchEntry { - const message = { ...baseBatchEntry } as BatchEntry; - if (object.exist !== undefined && object.exist !== null) { - message.exist = ExistenceProof.fromPartial(object.exist); - } else { - message.exist = undefined; - } - if (object.nonexist !== undefined && object.nonexist !== null) { - message.nonexist = NonExistenceProof.fromPartial(object.nonexist); - } else { - message.nonexist = undefined; - } - return message; - }, - toJSON(message: BatchEntry): unknown { - const obj: any = {}; - message.exist !== undefined && (obj.exist = message.exist ? ExistenceProof.toJSON(message.exist) : undefined); - message.nonexist !== undefined && (obj.nonexist = message.nonexist ? NonExistenceProof.toJSON(message.nonexist) : undefined); - return obj; - }, -}; - -export const CompressedBatchProof = { - encode(message: CompressedBatchProof, writer: Writer = Writer.create()): Writer { - for (const v of message.entries) { - CompressedBatchEntry.encode(v!, writer.uint32(10).fork()).ldelim(); - } - for (const v of message.lookupInners) { - InnerOp.encode(v!, writer.uint32(18).fork()).ldelim(); - } - return writer; - }, - decode(input: Uint8Array | Reader, length?: number): CompressedBatchProof { - const reader = input instanceof Uint8Array ? new Reader(input) : input; - let end = length === undefined ? reader.len : reader.pos + length; - const message = { ...baseCompressedBatchProof } as CompressedBatchProof; - message.entries = []; - message.lookupInners = []; - while (reader.pos < end) { - const tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - message.entries.push(CompressedBatchEntry.decode(reader, reader.uint32())); - break; - case 2: - message.lookupInners.push(InnerOp.decode(reader, reader.uint32())); - break; - default: - reader.skipType(tag & 7); - break; - } - } - return message; - }, - fromJSON(object: any): CompressedBatchProof { - const message = { ...baseCompressedBatchProof } as CompressedBatchProof; - message.entries = []; - message.lookupInners = []; - if (object.entries !== undefined && object.entries !== null) { - for (const e of object.entries) { - message.entries.push(CompressedBatchEntry.fromJSON(e)); - } - } - if (object.lookupInners !== undefined && object.lookupInners !== null) { - for (const e of object.lookupInners) { - message.lookupInners.push(InnerOp.fromJSON(e)); - } - } - return message; - }, - fromPartial(object: DeepPartial): CompressedBatchProof { - const message = { ...baseCompressedBatchProof } as CompressedBatchProof; - message.entries = []; - message.lookupInners = []; - if (object.entries !== undefined && object.entries !== null) { - for (const e of object.entries) { - message.entries.push(CompressedBatchEntry.fromPartial(e)); - } - } - if (object.lookupInners !== undefined && object.lookupInners !== null) { - for (const e of object.lookupInners) { - message.lookupInners.push(InnerOp.fromPartial(e)); - } - } - return message; - }, - toJSON(message: CompressedBatchProof): unknown { - const obj: any = {}; - if (message.entries) { - obj.entries = message.entries.map(e => e ? CompressedBatchEntry.toJSON(e) : undefined); - } else { - obj.entries = []; - } - if (message.lookupInners) { - obj.lookupInners = message.lookupInners.map(e => e ? InnerOp.toJSON(e) : undefined); - } else { - obj.lookupInners = []; - } - return obj; - }, -}; - -export const CompressedBatchEntry = { - encode(message: CompressedBatchEntry, writer: Writer = Writer.create()): Writer { - if (message.exist !== undefined) { - CompressedExistenceProof.encode(message.exist, writer.uint32(10).fork()).ldelim(); - } - if (message.nonexist !== undefined) { - CompressedNonExistenceProof.encode(message.nonexist, writer.uint32(18).fork()).ldelim(); - } - return writer; - }, - decode(input: Uint8Array | Reader, length?: number): CompressedBatchEntry { - const reader = input instanceof Uint8Array ? new Reader(input) : input; - let end = length === undefined ? reader.len : reader.pos + length; - const message = { ...baseCompressedBatchEntry } as CompressedBatchEntry; - while (reader.pos < end) { - const tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - message.exist = CompressedExistenceProof.decode(reader, reader.uint32()); - break; - case 2: - message.nonexist = CompressedNonExistenceProof.decode(reader, reader.uint32()); - break; - default: - reader.skipType(tag & 7); - break; - } - } - return message; - }, - fromJSON(object: any): CompressedBatchEntry { - const message = { ...baseCompressedBatchEntry } as CompressedBatchEntry; - if (object.exist !== undefined && object.exist !== null) { - message.exist = CompressedExistenceProof.fromJSON(object.exist); - } else { - message.exist = undefined; - } - if (object.nonexist !== undefined && object.nonexist !== null) { - message.nonexist = CompressedNonExistenceProof.fromJSON(object.nonexist); - } else { - message.nonexist = undefined; - } - return message; - }, - fromPartial(object: DeepPartial): CompressedBatchEntry { - const message = { ...baseCompressedBatchEntry } as CompressedBatchEntry; - if (object.exist !== undefined && object.exist !== null) { - message.exist = CompressedExistenceProof.fromPartial(object.exist); - } else { - message.exist = undefined; - } - if (object.nonexist !== undefined && object.nonexist !== null) { - message.nonexist = CompressedNonExistenceProof.fromPartial(object.nonexist); - } else { - message.nonexist = undefined; - } - return message; - }, - toJSON(message: CompressedBatchEntry): unknown { - const obj: any = {}; - message.exist !== undefined && (obj.exist = message.exist ? CompressedExistenceProof.toJSON(message.exist) : undefined); - message.nonexist !== undefined && (obj.nonexist = message.nonexist ? CompressedNonExistenceProof.toJSON(message.nonexist) : undefined); - return obj; - }, -}; - -export const CompressedExistenceProof = { - encode(message: CompressedExistenceProof, writer: Writer = Writer.create()): Writer { - writer.uint32(10).bytes(message.key); - writer.uint32(18).bytes(message.value); - if (message.leaf !== undefined && message.leaf !== undefined) { - LeafOp.encode(message.leaf, writer.uint32(26).fork()).ldelim(); - } - writer.uint32(34).fork(); - for (const v of message.path) { - writer.int32(v); - } - writer.ldelim(); - return writer; - }, - decode(input: Uint8Array | Reader, length?: number): CompressedExistenceProof { - const reader = input instanceof Uint8Array ? new Reader(input) : input; - let end = length === undefined ? reader.len : reader.pos + length; - const message = { ...baseCompressedExistenceProof } as CompressedExistenceProof; - message.path = []; - while (reader.pos < end) { - const tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - message.key = reader.bytes(); - break; - case 2: - message.value = reader.bytes(); - break; - case 3: - message.leaf = LeafOp.decode(reader, reader.uint32()); - break; - case 4: - if ((tag & 7) === 2) { - const end2 = reader.uint32() + reader.pos; - while (reader.pos < end2) { - message.path.push(reader.int32()); - } - } else { - message.path.push(reader.int32()); - } - break; - default: - reader.skipType(tag & 7); - break; - } - } - return message; - }, - fromJSON(object: any): CompressedExistenceProof { - const message = { ...baseCompressedExistenceProof } as CompressedExistenceProof; - message.path = []; - if (object.key !== undefined && object.key !== null) { - message.key = bytesFromBase64(object.key); - } - if (object.value !== undefined && object.value !== null) { - message.value = bytesFromBase64(object.value); - } - if (object.leaf !== undefined && object.leaf !== null) { - message.leaf = LeafOp.fromJSON(object.leaf); - } else { - message.leaf = undefined; - } - if (object.path !== undefined && object.path !== null) { - for (const e of object.path) { - message.path.push(Number(e)); - } - } - return message; - }, - fromPartial(object: DeepPartial): CompressedExistenceProof { - const message = { ...baseCompressedExistenceProof } as CompressedExistenceProof; - message.path = []; - if (object.key !== undefined && object.key !== null) { - message.key = object.key; - } else { - message.key = new Uint8Array(); - } - if (object.value !== undefined && object.value !== null) { - message.value = object.value; - } else { - message.value = new Uint8Array(); - } - if (object.leaf !== undefined && object.leaf !== null) { - message.leaf = LeafOp.fromPartial(object.leaf); - } else { - message.leaf = undefined; - } - if (object.path !== undefined && object.path !== null) { - for (const e of object.path) { - message.path.push(e); - } - } - return message; - }, - toJSON(message: CompressedExistenceProof): unknown { - const obj: any = {}; - message.key !== undefined && (obj.key = base64FromBytes(message.key !== undefined ? message.key : new Uint8Array())); - message.value !== undefined && (obj.value = base64FromBytes(message.value !== undefined ? message.value : new Uint8Array())); - message.leaf !== undefined && (obj.leaf = message.leaf ? LeafOp.toJSON(message.leaf) : undefined); - if (message.path) { - obj.path = message.path.map(e => e); - } else { - obj.path = []; - } - return obj; - }, -}; - -export const CompressedNonExistenceProof = { - encode(message: CompressedNonExistenceProof, writer: Writer = Writer.create()): Writer { - writer.uint32(10).bytes(message.key); - if (message.left !== undefined && message.left !== undefined) { - CompressedExistenceProof.encode(message.left, writer.uint32(18).fork()).ldelim(); - } - if (message.right !== undefined && message.right !== undefined) { - CompressedExistenceProof.encode(message.right, writer.uint32(26).fork()).ldelim(); - } - return writer; - }, - decode(input: Uint8Array | Reader, length?: number): CompressedNonExistenceProof { - const reader = input instanceof Uint8Array ? new Reader(input) : input; - let end = length === undefined ? reader.len : reader.pos + length; - const message = { ...baseCompressedNonExistenceProof } as CompressedNonExistenceProof; - while (reader.pos < end) { - const tag = reader.uint32(); - switch (tag >>> 3) { - case 1: - message.key = reader.bytes(); - break; - case 2: - message.left = CompressedExistenceProof.decode(reader, reader.uint32()); - break; - case 3: - message.right = CompressedExistenceProof.decode(reader, reader.uint32()); - break; - default: - reader.skipType(tag & 7); - break; - } - } - return message; - }, - fromJSON(object: any): CompressedNonExistenceProof { - const message = { ...baseCompressedNonExistenceProof } as CompressedNonExistenceProof; - if (object.key !== undefined && object.key !== null) { - message.key = bytesFromBase64(object.key); - } - if (object.left !== undefined && object.left !== null) { - message.left = CompressedExistenceProof.fromJSON(object.left); - } else { - message.left = undefined; - } - if (object.right !== undefined && object.right !== null) { - message.right = CompressedExistenceProof.fromJSON(object.right); - } else { - message.right = undefined; - } - return message; - }, - fromPartial(object: DeepPartial): CompressedNonExistenceProof { - const message = { ...baseCompressedNonExistenceProof } as CompressedNonExistenceProof; - if (object.key !== undefined && object.key !== null) { - message.key = object.key; - } else { - message.key = new Uint8Array(); - } - if (object.left !== undefined && object.left !== null) { - message.left = CompressedExistenceProof.fromPartial(object.left); - } else { - message.left = undefined; - } - if (object.right !== undefined && object.right !== null) { - message.right = CompressedExistenceProof.fromPartial(object.right); - } else { - message.right = undefined; - } - return message; - }, - toJSON(message: CompressedNonExistenceProof): unknown { - const obj: any = {}; - message.key !== undefined && (obj.key = base64FromBytes(message.key !== undefined ? message.key : new Uint8Array())); - message.left !== undefined && (obj.left = message.left ? CompressedExistenceProof.toJSON(message.left) : undefined); - message.right !== undefined && (obj.right = message.right ? CompressedExistenceProof.toJSON(message.right) : undefined); - return obj; - }, -}; - -interface WindowBase64 { - atob(b64: string): string; - btoa(bin: string): string; -} - -const windowBase64 = (globalThis as unknown as WindowBase64); -const atob = windowBase64.atob || ((b64: string) => Buffer.from(b64, 'base64').toString('binary')); -const btoa = windowBase64.btoa || ((bin: string) => Buffer.from(bin, 'binary').toString('base64')); - -function bytesFromBase64(b64: string): Uint8Array { - const bin = atob(b64); - const arr = new Uint8Array(bin.length); - for (let i = 0; i < bin.length; ++i) { - arr[i] = bin.charCodeAt(i); - } - return arr; -} - -function base64FromBytes(arr: Uint8Array): string { - const bin: string[] = []; - for (let i = 0; i < arr.byteLength; ++i) { - bin.push(String.fromCharCode(arr[i])); - } - return btoa(bin.join('')); -} -type Builtin = Date | Function | Uint8Array | string | number | undefined; -export type DeepPartial = T extends Builtin - ? T - : T extends Array - ? Array> - : T extends ReadonlyArray - ? ReadonlyArray> - : T extends {} - ? { [K in keyof T]?: DeepPartial } - : Partial; \ No newline at end of file diff --git a/packages/api/src/generated/third_party/cosmos_proto/cosmos.ts b/packages/api/src/generated/third_party/cosmos_proto/cosmos.ts deleted file mode 100644 index 9d35002b..00000000 --- a/packages/api/src/generated/third_party/cosmos_proto/cosmos.ts +++ /dev/null @@ -1,3 +0,0 @@ -/* eslint-disable */ - -export const protobufPackage = 'cosmos_proto' diff --git a/packages/api/src/generated/third_party/gogoproto/gogo.ts b/packages/api/src/generated/third_party/gogoproto/gogo.ts deleted file mode 100644 index 0298b8e0..00000000 --- a/packages/api/src/generated/third_party/gogoproto/gogo.ts +++ /dev/null @@ -1,3 +0,0 @@ -/* eslint-disable */ - -export const protobufPackage = 'gogoproto' diff --git a/packages/api/proto/third_party/confio/proofs.proto b/packages/api/third_party/proto/confio/proofs.proto similarity index 100% rename from packages/api/proto/third_party/confio/proofs.proto rename to packages/api/third_party/proto/confio/proofs.proto diff --git a/packages/api/proto/third_party/cosmos_proto/cosmos.proto b/packages/api/third_party/proto/cosmos_proto/cosmos.proto similarity index 100% rename from packages/api/proto/third_party/cosmos_proto/cosmos.proto rename to packages/api/third_party/proto/cosmos_proto/cosmos.proto diff --git a/packages/api/proto/third_party/gogoproto/gogo.proto b/packages/api/third_party/proto/gogoproto/gogo.proto similarity index 100% rename from packages/api/proto/third_party/gogoproto/gogo.proto rename to packages/api/third_party/proto/gogoproto/gogo.proto diff --git a/packages/api/proto/third_party/google/api/annotations.proto b/packages/api/third_party/proto/google/api/annotations.proto similarity index 100% rename from packages/api/proto/third_party/google/api/annotations.proto rename to packages/api/third_party/proto/google/api/annotations.proto diff --git a/packages/api/proto/third_party/google/api/http.proto b/packages/api/third_party/proto/google/api/http.proto similarity index 100% rename from packages/api/proto/third_party/google/api/http.proto rename to packages/api/third_party/proto/google/api/http.proto diff --git a/packages/api/proto/third_party/google/api/httpbody.proto b/packages/api/third_party/proto/google/api/httpbody.proto similarity index 100% rename from packages/api/proto/third_party/google/api/httpbody.proto rename to packages/api/third_party/proto/google/api/httpbody.proto diff --git a/packages/api/proto/third_party/google/protobuf/any.proto b/packages/api/third_party/proto/google/protobuf/any.proto similarity index 100% rename from packages/api/proto/third_party/google/protobuf/any.proto rename to packages/api/third_party/proto/google/protobuf/any.proto diff --git a/packages/api/proto/third_party/tendermint/abci/types.proto b/packages/api/third_party/proto/tendermint/abci/types.proto similarity index 100% rename from packages/api/proto/third_party/tendermint/abci/types.proto rename to packages/api/third_party/proto/tendermint/abci/types.proto diff --git a/packages/api/proto/third_party/tendermint/crypto/keys.proto b/packages/api/third_party/proto/tendermint/crypto/keys.proto similarity index 100% rename from packages/api/proto/third_party/tendermint/crypto/keys.proto rename to packages/api/third_party/proto/tendermint/crypto/keys.proto diff --git a/packages/api/proto/third_party/tendermint/crypto/proof.proto b/packages/api/third_party/proto/tendermint/crypto/proof.proto similarity index 100% rename from packages/api/proto/third_party/tendermint/crypto/proof.proto rename to packages/api/third_party/proto/tendermint/crypto/proof.proto diff --git a/packages/api/proto/third_party/tendermint/libs/bits/types.proto b/packages/api/third_party/proto/tendermint/libs/bits/types.proto similarity index 100% rename from packages/api/proto/third_party/tendermint/libs/bits/types.proto rename to packages/api/third_party/proto/tendermint/libs/bits/types.proto diff --git a/packages/api/third_party/proto/tendermint/p2p/types.proto b/packages/api/third_party/proto/tendermint/p2p/types.proto new file mode 100644 index 00000000..0d42ea40 --- /dev/null +++ b/packages/api/third_party/proto/tendermint/p2p/types.proto @@ -0,0 +1,34 @@ +syntax = "proto3"; +package tendermint.p2p; + +option go_package = "github.com/tendermint/tendermint/proto/tendermint/p2p"; + +import "gogoproto/gogo.proto"; + +message NetAddress { + string id = 1 [(gogoproto.customname) = "ID"]; + string ip = 2 [(gogoproto.customname) = "IP"]; + uint32 port = 3; +} + +message ProtocolVersion { + uint64 p2p = 1 [(gogoproto.customname) = "P2P"]; + uint64 block = 2; + uint64 app = 3; +} + +message DefaultNodeInfo { + ProtocolVersion protocol_version = 1 [(gogoproto.nullable) = false]; + string default_node_id = 2 [(gogoproto.customname) = "DefaultNodeID"]; + string listen_addr = 3; + string network = 4; + string version = 5; + bytes channels = 6; + string moniker = 7; + DefaultNodeInfoOther other = 8 [(gogoproto.nullable) = false]; +} + +message DefaultNodeInfoOther { + string tx_index = 1; + string rpc_address = 2 [(gogoproto.customname) = "RPCAddress"]; +} diff --git a/packages/api/third_party/proto/tendermint/types/block.proto b/packages/api/third_party/proto/tendermint/types/block.proto new file mode 100644 index 00000000..84e9bb15 --- /dev/null +++ b/packages/api/third_party/proto/tendermint/types/block.proto @@ -0,0 +1,15 @@ +syntax = "proto3"; +package tendermint.types; + +option go_package = "github.com/tendermint/tendermint/proto/tendermint/types"; + +import "gogoproto/gogo.proto"; +import "tendermint/types/types.proto"; +import "tendermint/types/evidence.proto"; + +message Block { + Header header = 1 [(gogoproto.nullable) = false]; + Data data = 2 [(gogoproto.nullable) = false]; + tendermint.types.EvidenceList evidence = 3 [(gogoproto.nullable) = false]; + Commit last_commit = 4; +} diff --git a/packages/api/proto/third_party/tendermint/types/evidence.proto b/packages/api/third_party/proto/tendermint/types/evidence.proto similarity index 100% rename from packages/api/proto/third_party/tendermint/types/evidence.proto rename to packages/api/third_party/proto/tendermint/types/evidence.proto diff --git a/packages/api/proto/third_party/tendermint/types/params.proto b/packages/api/third_party/proto/tendermint/types/params.proto similarity index 100% rename from packages/api/proto/third_party/tendermint/types/params.proto rename to packages/api/third_party/proto/tendermint/types/params.proto diff --git a/packages/api/proto/third_party/tendermint/types/types.proto b/packages/api/third_party/proto/tendermint/types/types.proto similarity index 100% rename from packages/api/proto/third_party/tendermint/types/types.proto rename to packages/api/third_party/proto/tendermint/types/types.proto diff --git a/packages/api/proto/third_party/tendermint/types/validator.proto b/packages/api/third_party/proto/tendermint/types/validator.proto similarity index 100% rename from packages/api/proto/third_party/tendermint/types/validator.proto rename to packages/api/third_party/proto/tendermint/types/validator.proto diff --git a/packages/api/proto/third_party/tendermint/version/types.proto b/packages/api/third_party/proto/tendermint/version/types.proto similarity index 100% rename from packages/api/proto/third_party/tendermint/version/types.proto rename to packages/api/third_party/proto/tendermint/version/types.proto