mjs/nebula
mjs/nebula
1
0
Fork 0
mirror of https://github.com/onsonr/nebula.git synced 2025-03-10 17:29:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: add cosmos/ics23/v1/proofs protobufs

Browse Source
This commit is contained in:
Prad Nukala 2025-01-07 15:07:30 -05:00
parent c1c1a608c2
commit 3dc19f4904
104 changed files with 29768 additions and 239 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
libs/es-client/src/client/index.ts
View File

@ -22,10 +22,7 @@ export {
export { simulateTx, type SimulateTxParams } from "./apis/simulateTx"; export { simulateTx, type SimulateTxParams } from "./apis/simulateTx";
export { RpcClient } from "./clients/RpcClient"; export { RpcClient } from "./clients/RpcClient";
export { type Adapter } from "./models/Adapter"; export { type Adapter } from "./models/Adapter";
export { MsgExecuteContract } from "./models/MsgExecuteContract";
export { MsgInstantiateContract } from "./models/MsgInstantiateContract";
export { MsgStoreCode } from "./models/MsgStoreCode"; export { MsgStoreCode } from "./models/MsgStoreCode";
export { MsgMigrateContract } from "./models/MsgMigrateContract";
export { MsgIbcTransfer } from "./models/MsgIbcTransfer"; export { MsgIbcTransfer } from "./models/MsgIbcTransfer";
export { MsgSend } from "./models/MsgSend"; export { MsgSend } from "./models/MsgSend";
export { MsgDelegate } from "./models/MsgDelegate"; export { MsgDelegate } from "./models/MsgDelegate";

5
libs/es-client/src/client/models/MsgBeginRedelegate.ts
View File

@ -1,5 +1,5 @@
import { PlainMessage } from "@bufbuild/protobuf"; import { PlainMessage } from "@bufbuild/protobuf";
import { CosmosStakingV1beta1MsgBeginRedelegate as ProtoMsgBeginRedelegate } from "@onsonr/es/protobufs"; import { CosmosStakingV1beta1MsgBeginRedelegate as ProtoMsgBeginRedelegate } from "../../protobufs";
import { DeepPrettify } from "../../typeutils/prettify"; import { DeepPrettify } from "../../typeutils/prettify";
import { Adapter } from "./Adapter"; import { Adapter } from "./Adapter";
@ -25,7 +25,8 @@ export class MsgBeginRedelegate implements Adapter {
validator_src_address: this.data.validatorSrcAddress, validator_src_address: this.data.validatorSrcAddress,
validator_dst_address: this.data.validatorDstAddress, validator_dst_address: this.data.validatorDstAddress,
amount: this.data.amount, amount: this.data.amount,
}, },
}; };
} }
} }

5
libs/es-client/src/client/models/MsgDelegate.ts
View File

@ -1,5 +1,5 @@
import { PlainMessage } from "@bufbuild/protobuf"; import { PlainMessage } from "@bufbuild/protobuf";
import { CosmosStakingV1beta1MsgDelegate as ProtoMsgDelegate } from "@onsonr/es/protobufs"; import { CosmosStakingV1beta1MsgDelegate as ProtoMsgDelegate } from "../..//protobufs";
import { DeepPrettify } from "../../typeutils/prettify"; import { DeepPrettify } from "../../typeutils/prettify";
import { Adapter } from "./Adapter"; import { Adapter } from "./Adapter";
@ -24,7 +24,8 @@ export class MsgDelegate implements Adapter {
delegator_address: this.data.delegatorAddress, delegator_address: this.data.delegatorAddress,
validator_address: this.data.validatorAddress, validator_address: this.data.validatorAddress,
amount: this.data.amount, amount: this.data.amount,
}, },
}; };
} }
} }

34
libs/es-client/src/client/models/MsgExecuteContract.ts
View File

@ -1,34 +0,0 @@
import { PlainMessage } from "@bufbuild/protobuf";
import { utf8 } from "@onsonr/es/codec";
import { CosmwasmWasmV1MsgExecuteContract as ProtoMsgExecuteContract } from "@onsonr/es/protobufs";
import { DeepPrettify, Prettify } from "../../typeutils/prettify";
import { Adapter } from "./Adapter";
type Data<T> = Prettify<
DeepPrettify<Omit<PlainMessage<ProtoMsgExecuteContract>, "msg">> & {
msg: T;
}
>;
export class MsgExecuteContract<T> implements Adapter {
private readonly data: Data<T>;
constructor(data: Data<T>) {
this.data = data;
}
public toProto() {
return new ProtoMsgExecuteContract({
...this.data,
msg: utf8.decode(JSON.stringify(this.data.msg)),
});
}
public toAmino() {
return {
type: "wasm/MsgExecuteContract",
value: this.data,
};
}
}

2
libs/es-client/src/client/models/MsgIbcTransfer.ts
View File

@ -1,5 +1,5 @@
import { PlainMessage } from "@bufbuild/protobuf"; import { PlainMessage } from "@bufbuild/protobuf";
import { IbcApplicationsTransferV1MsgTransfer as ProtoMsgIbcTransfer } from "@onsonr/es/protobufs"; import { IbcApplicationsTransferV1MsgTransfer as ProtoMsgIbcTransfer } from "../../protobufs";
import { DeepPrettify } from "../../typeutils/prettify"; import { DeepPrettify } from "../../typeutils/prettify";
import { Adapter } from "./Adapter"; import { Adapter } from "./Adapter";

41
libs/es-client/src/client/models/MsgInstantiateContract.ts
View File

@ -1,41 +0,0 @@
import { PlainMessage } from "@bufbuild/protobuf";
import { utf8 } from "@onsonr/es/codec";
import { CosmwasmWasmV1MsgInstantiateContract as ProtoMsgInstantiateContract } from "@onsonr/es/protobufs";
import { DeepPrettify, Prettify } from "../../typeutils/prettify";
import { Adapter } from "./Adapter";
type Data<T> = Prettify<
DeepPrettify<Omit<PlainMessage<ProtoMsgInstantiateContract>, "msg">> & {
msg: T;
}
>;
export class MsgInstantiateContract<T> implements Adapter {
private readonly data: Data<T>;
constructor(data: Data<T>) {
this.data = data;
}
public toProto() {
return new ProtoMsgInstantiateContract({
...this.data,
msg: utf8.decode(JSON.stringify(this.data.msg)),
});
}
public toAmino() {
return {
type: "wasm/MsgInstantiateContract",
value: {
sender: this.data.sender,
admin: this.data.admin,
code_id: this.data.codeId.toString(),
label: this.data.label,
msg: this.data.msg,
funds: this.data.funds,
},
};
}
}

39
libs/es-client/src/client/models/MsgMigrateContract.ts
View File

@ -1,39 +0,0 @@
import { PlainMessage } from "@bufbuild/protobuf";
import { utf8 } from "@onsonr/es/codec";
import { CosmwasmWasmV1MsgMigrateContract as ProtoMsgMigrateContract } from "@onsonr/es/protobufs";
import { DeepPrettify, Prettify } from "../../typeutils/prettify";
import { Adapter } from "./Adapter";
type Data<T> = Prettify<
DeepPrettify<Omit<PlainMessage<ProtoMsgMigrateContract>, "msg">> & {
msg: T;
}
>;
export class MsgMigrateContract<T> implements Adapter {
private readonly data: Data<T>;
constructor(data: Data<T>) {
this.data = data;
}
public toProto() {
return new ProtoMsgMigrateContract({
...this.data,
msg: utf8.decode(JSON.stringify(this.data.msg)),
});
}
public toAmino() {
return {
type: "wasm/MsgMigrateContract",
value: {
sender: this.data.sender,
code_id: this.data.codeId,
contract: this.data.contract,
msg: this.data.msg,
}
};
}
}

978
libs/es-client/src/protobufs/cosmos/ics23/v1/proofs_pb.ts Normal file
View File

@ -0,0 +1,978 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file cosmos/ics23/v1/proofs.proto (package cosmos.ics23.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
/**
* @generated from enum cosmos.ics23.v1.HashOp
*/
export enum HashOp {
/**
* NO_HASH is the default if no data passed. Note this is an illegal argument some places.
*
* @generated from enum value: NO_HASH = 0;
*/
NO_HASH = 0,
/**
* @generated from enum value: SHA256 = 1;
*/
SHA256 = 1,
/**
* @generated from enum value: SHA512 = 2;
*/
SHA512 = 2,
/**
* @generated from enum value: KECCAK256 = 3;
*/
KECCAK256 = 3,
/**
* @generated from enum value: RIPEMD160 = 4;
*/
RIPEMD160 = 4,
/**
* ripemd160(sha256(x))
*
* @generated from enum value: BITCOIN = 5;
*/
BITCOIN = 5,
/**
* @generated from enum value: SHA512_256 = 6;
*/
SHA512_256 = 6,
/**
* @generated from enum value: BLAKE2B_512 = 7;
*/
BLAKE2B_512 = 7,
/**
* @generated from enum value: BLAKE2S_256 = 8;
*/
BLAKE2S_256 = 8,
/**
* @generated from enum value: BLAKE3 = 9;
*/
BLAKE3 = 9,
}
// Retrieve enum metadata with: proto3.getEnumType(HashOp)
proto3.util.setEnumType(HashOp, "cosmos.ics23.v1.HashOp", [
{ no: 0, name: "NO_HASH" },
{ no: 1, name: "SHA256" },
{ no: 2, name: "SHA512" },
{ no: 3, name: "KECCAK256" },
{ no: 4, name: "RIPEMD160" },
{ no: 5, name: "BITCOIN" },
{ no: 6, name: "SHA512_256" },
{ no: 7, name: "BLAKE2B_512" },
{ no: 8, name: "BLAKE2S_256" },
{ no: 9, name: "BLAKE3" },
]);
/**
* *
* 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)
*
* @generated from enum cosmos.ics23.v1.LengthOp
*/
export enum LengthOp {
/**
* NO_PREFIX don't include any length info
*
* @generated from enum value: NO_PREFIX = 0;
*/
NO_PREFIX = 0,
/**
* VAR_PROTO uses protobuf (and go-amino) varint encoding of the length
*
* @generated from enum value: VAR_PROTO = 1;
*/
VAR_PROTO = 1,
/**
* VAR_RLP uses rlp int encoding of the length
*
* @generated from enum value: VAR_RLP = 2;
*/
VAR_RLP = 2,
/**
* FIXED32_BIG uses big-endian encoding of the length as a 32 bit integer
*
* @generated from enum value: FIXED32_BIG = 3;
*/
FIXED32_BIG = 3,
/**
* FIXED32_LITTLE uses little-endian encoding of the length as a 32 bit integer
*
* @generated from enum value: FIXED32_LITTLE = 4;
*/
FIXED32_LITTLE = 4,
/**
* FIXED64_BIG uses big-endian encoding of the length as a 64 bit integer
*
* @generated from enum value: FIXED64_BIG = 5;
*/
FIXED64_BIG = 5,
/**
* FIXED64_LITTLE uses little-endian encoding of the length as a 64 bit integer
*
* @generated from enum value: FIXED64_LITTLE = 6;
*/
FIXED64_LITTLE = 6,
/**
* REQUIRE_32_BYTES is like NONE, but will fail if the input is not exactly 32 bytes (sha256 output)
*
* @generated from enum value: REQUIRE_32_BYTES = 7;
*/
REQUIRE_32_BYTES = 7,
/**
* REQUIRE_64_BYTES is like NONE, but will fail if the input is not exactly 64 bytes (sha512 output)
*
* @generated from enum value: REQUIRE_64_BYTES = 8;
*/
REQUIRE_64_BYTES = 8,
}
// Retrieve enum metadata with: proto3.getEnumType(LengthOp)
proto3.util.setEnumType(LengthOp, "cosmos.ics23.v1.LengthOp", [
{ no: 0, name: "NO_PREFIX" },
{ no: 1, name: "VAR_PROTO" },
{ no: 2, name: "VAR_RLP" },
{ no: 3, name: "FIXED32_BIG" },
{ no: 4, name: "FIXED32_LITTLE" },
{ no: 5, name: "FIXED64_BIG" },
{ no: 6, name: "FIXED64_LITTLE" },
{ no: 7, name: "REQUIRE_32_BYTES" },
{ no: 8, name: "REQUIRE_64_BYTES" },
]);
/**
* *
* 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.
*
* @generated from message cosmos.ics23.v1.ExistenceProof
*/
export class ExistenceProof extends Message<ExistenceProof> {
/**
* @generated from field: bytes key = 1;
*/
key = new Uint8Array(0);
/**
* @generated from field: bytes value = 2;
*/
value = new Uint8Array(0);
/**
* @generated from field: cosmos.ics23.v1.LeafOp leaf = 3;
*/
leaf?: LeafOp;
/**
* @generated from field: repeated cosmos.ics23.v1.InnerOp path = 4;
*/
path: InnerOp[] = [];
constructor(data?: PartialMessage<ExistenceProof>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmos.ics23.v1.ExistenceProof";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "key", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "value", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 3, name: "leaf", kind: "message", T: LeafOp },
{ no: 4, name: "path", kind: "message", T: InnerOp, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ExistenceProof {
return new ExistenceProof().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ExistenceProof {
return new ExistenceProof().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ExistenceProof {
return new ExistenceProof().fromJsonString(jsonString, options);
}
static equals(a: ExistenceProof | PlainMessage<ExistenceProof> | undefined, b: ExistenceProof | PlainMessage<ExistenceProof> | undefined): boolean {
return proto3.util.equals(ExistenceProof, a, b);
}
}
/**
*
* 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.
*
* @generated from message cosmos.ics23.v1.NonExistenceProof
*/
export class NonExistenceProof extends Message<NonExistenceProof> {
/**
* TODO: remove this as unnecessary??? we prove a range
*
* @generated from field: bytes key = 1;
*/
key = new Uint8Array(0);
/**
* @generated from field: cosmos.ics23.v1.ExistenceProof left = 2;
*/
left?: ExistenceProof;
/**
* @generated from field: cosmos.ics23.v1.ExistenceProof right = 3;
*/
right?: ExistenceProof;
constructor(data?: PartialMessage<NonExistenceProof>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmos.ics23.v1.NonExistenceProof";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "key", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "left", kind: "message", T: ExistenceProof },
{ no: 3, name: "right", kind: "message", T: ExistenceProof },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): NonExistenceProof {
return new NonExistenceProof().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): NonExistenceProof {
return new NonExistenceProof().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): NonExistenceProof {
return new NonExistenceProof().fromJsonString(jsonString, options);
}
static equals(a: NonExistenceProof | PlainMessage<NonExistenceProof> | undefined, b: NonExistenceProof | PlainMessage<NonExistenceProof> | undefined): boolean {
return proto3.util.equals(NonExistenceProof, a, b);
}
}
/**
*
* CommitmentProof is either an ExistenceProof or a NonExistenceProof, or a Batch of such messages
*
* @generated from message cosmos.ics23.v1.CommitmentProof
*/
export class CommitmentProof extends Message<CommitmentProof> {
/**
* @generated from oneof cosmos.ics23.v1.CommitmentProof.proof
*/
proof: {
/**
* @generated from field: cosmos.ics23.v1.ExistenceProof exist = 1;
*/
value: ExistenceProof;
case: "exist";
} | {
/**
* @generated from field: cosmos.ics23.v1.NonExistenceProof nonexist = 2;
*/
value: NonExistenceProof;
case: "nonexist";
} | {
/**
* @generated from field: cosmos.ics23.v1.BatchProof batch = 3;
*/
value: BatchProof;
case: "batch";
} | {
/**
* @generated from field: cosmos.ics23.v1.CompressedBatchProof compressed = 4;
*/
value: CompressedBatchProof;
case: "compressed";
} | { case: undefined; value?: undefined } = { case: undefined };
constructor(data?: PartialMessage<CommitmentProof>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmos.ics23.v1.CommitmentProof";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "exist", kind: "message", T: ExistenceProof, oneof: "proof" },
{ no: 2, name: "nonexist", kind: "message", T: NonExistenceProof, oneof: "proof" },
{ no: 3, name: "batch", kind: "message", T: BatchProof, oneof: "proof" },
{ no: 4, name: "compressed", kind: "message", T: CompressedBatchProof, oneof: "proof" },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CommitmentProof {
return new CommitmentProof().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CommitmentProof {
return new CommitmentProof().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CommitmentProof {
return new CommitmentProof().fromJsonString(jsonString, options);
}
static equals(a: CommitmentProof | PlainMessage<CommitmentProof> | undefined, b: CommitmentProof | PlainMessage<CommitmentProof> | undefined): boolean {
return proto3.util.equals(CommitmentProof, a, b);
}
}
/**
* *
* 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)
*
* @generated from message cosmos.ics23.v1.LeafOp
*/
export class LeafOp extends Message<LeafOp> {
/**
* @generated from field: cosmos.ics23.v1.HashOp hash = 1;
*/
hash = HashOp.NO_HASH;
/**
* @generated from field: cosmos.ics23.v1.HashOp prehash_key = 2;
*/
prehashKey = HashOp.NO_HASH;
/**
* @generated from field: cosmos.ics23.v1.HashOp prehash_value = 3;
*/
prehashValue = HashOp.NO_HASH;
/**
* @generated from field: cosmos.ics23.v1.LengthOp length = 4;
*/
length = LengthOp.NO_PREFIX;
/**
* prefix is a fixed bytes that may optionally be included at the beginning to differentiate
* a leaf node from an inner node.
*
* @generated from field: bytes prefix = 5;
*/
prefix = new Uint8Array(0);
constructor(data?: PartialMessage<LeafOp>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmos.ics23.v1.LeafOp";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "hash", kind: "enum", T: proto3.getEnumType(HashOp) },
{ no: 2, name: "prehash_key", kind: "enum", T: proto3.getEnumType(HashOp) },
{ no: 3, name: "prehash_value", kind: "enum", T: proto3.getEnumType(HashOp) },
{ no: 4, name: "length", kind: "enum", T: proto3.getEnumType(LengthOp) },
{ no: 5, name: "prefix", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LeafOp {
return new LeafOp().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LeafOp {
return new LeafOp().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LeafOp {
return new LeafOp().fromJsonString(jsonString, options);
}
static equals(a: LeafOp | PlainMessage<LeafOp> | undefined, b: LeafOp | PlainMessage<LeafOp> | undefined): boolean {
return proto3.util.equals(LeafOp, a, b);
}
}
/**
* *
* 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
*
* @generated from message cosmos.ics23.v1.InnerOp
*/
export class InnerOp extends Message<InnerOp> {
/**
* @generated from field: cosmos.ics23.v1.HashOp hash = 1;
*/
hash = HashOp.NO_HASH;
/**
* @generated from field: bytes prefix = 2;
*/
prefix = new Uint8Array(0);
/**
* @generated from field: bytes suffix = 3;
*/
suffix = new Uint8Array(0);
constructor(data?: PartialMessage<InnerOp>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmos.ics23.v1.InnerOp";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "hash", kind: "enum", T: proto3.getEnumType(HashOp) },
{ no: 2, name: "prefix", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 3, name: "suffix", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InnerOp {
return new InnerOp().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InnerOp {
return new InnerOp().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InnerOp {
return new InnerOp().fromJsonString(jsonString, options);
}
static equals(a: InnerOp | PlainMessage<InnerOp> | undefined, b: InnerOp | PlainMessage<InnerOp> | undefined): boolean {
return proto3.util.equals(InnerOp, a, b);
}
}
/**
* *
* 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.
*
* @generated from message cosmos.ics23.v1.ProofSpec
*/
export class ProofSpec extends Message<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)
*
* @generated from field: cosmos.ics23.v1.LeafOp leaf_spec = 1;
*/
leafSpec?: LeafOp;
/**
* @generated from field: cosmos.ics23.v1.InnerSpec inner_spec = 2;
*/
innerSpec?: InnerSpec;
/**
* max_depth (if > 0) is the maximum number of InnerOps allowed (mainly for fixed-depth tries)
* the max_depth is interpreted as 128 if set to 0
*
* @generated from field: int32 max_depth = 3;
*/
maxDepth = 0;
/**
* min_depth (if > 0) is the minimum number of InnerOps allowed (mainly for fixed-depth tries)
*
* @generated from field: int32 min_depth = 4;
*/
minDepth = 0;
/**
* prehash_key_before_comparison is a flag that indicates whether to use the
* prehash_key specified by LeafOp to compare lexical ordering of keys for
* non-existence proofs.
*
* @generated from field: bool prehash_key_before_comparison = 5;
*/
prehashKeyBeforeComparison = false;
constructor(data?: PartialMessage<ProofSpec>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmos.ics23.v1.ProofSpec";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "leaf_spec", kind: "message", T: LeafOp },
{ no: 2, name: "inner_spec", kind: "message", T: InnerSpec },
{ no: 3, name: "max_depth", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
{ no: 4, name: "min_depth", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
{ no: 5, name: "prehash_key_before_comparison", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ProofSpec {
return new ProofSpec().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ProofSpec {
return new ProofSpec().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ProofSpec {
return new ProofSpec().fromJsonString(jsonString, options);
}
static equals(a: ProofSpec | PlainMessage<ProofSpec> | undefined, b: ProofSpec | PlainMessage<ProofSpec> | undefined): boolean {
return proto3.util.equals(ProofSpec, a, b);
}
}
/**
*
* 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)
*
* @generated from message cosmos.ics23.v1.InnerSpec
*/
export class InnerSpec extends Message<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)
*
* @generated from field: repeated int32 child_order = 1;
*/
childOrder: number[] = [];
/**
* @generated from field: int32 child_size = 2;
*/
childSize = 0;
/**
* @generated from field: int32 min_prefix_length = 3;
*/
minPrefixLength = 0;
/**
* the max prefix length must be less than the minimum prefix length + child size
*
* @generated from field: int32 max_prefix_length = 4;
*/
maxPrefixLength = 0;
/**
* empty child is the prehash image that is used when one child is nil (eg. 20 bytes of 0)
*
* @generated from field: bytes empty_child = 5;
*/
emptyChild = new Uint8Array(0);
/**
* hash is the algorithm that must be used for each InnerOp
*
* @generated from field: cosmos.ics23.v1.HashOp hash = 6;
*/
hash = HashOp.NO_HASH;
constructor(data?: PartialMessage<InnerSpec>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmos.ics23.v1.InnerSpec";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "child_order", kind: "scalar", T: 5 /* ScalarType.INT32 */, repeated: true },
{ no: 2, name: "child_size", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
{ no: 3, name: "min_prefix_length", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
{ no: 4, name: "max_prefix_length", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
{ no: 5, name: "empty_child", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 6, name: "hash", kind: "enum", T: proto3.getEnumType(HashOp) },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InnerSpec {
return new InnerSpec().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InnerSpec {
return new InnerSpec().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InnerSpec {
return new InnerSpec().fromJsonString(jsonString, options);
}
static equals(a: InnerSpec | PlainMessage<InnerSpec> | undefined, b: InnerSpec | PlainMessage<InnerSpec> | undefined): boolean {
return proto3.util.equals(InnerSpec, a, b);
}
}
/**
*
* BatchProof is a group of multiple proof types than can be compressed
*
* @generated from message cosmos.ics23.v1.BatchProof
*/
export class BatchProof extends Message<BatchProof> {
/**
* @generated from field: repeated cosmos.ics23.v1.BatchEntry entries = 1;
*/
entries: BatchEntry[] = [];
constructor(data?: PartialMessage<BatchProof>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmos.ics23.v1.BatchProof";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "entries", kind: "message", T: BatchEntry, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BatchProof {
return new BatchProof().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BatchProof {
return new BatchProof().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BatchProof {
return new BatchProof().fromJsonString(jsonString, options);
}
static equals(a: BatchProof | PlainMessage<BatchProof> | undefined, b: BatchProof | PlainMessage<BatchProof> | undefined): boolean {
return proto3.util.equals(BatchProof, a, b);
}
}
/**
* Use BatchEntry not CommitmentProof, to avoid recursion
*
* @generated from message cosmos.ics23.v1.BatchEntry
*/
export class BatchEntry extends Message<BatchEntry> {
/**
* @generated from oneof cosmos.ics23.v1.BatchEntry.proof
*/
proof: {
/**
* @generated from field: cosmos.ics23.v1.ExistenceProof exist = 1;
*/
value: ExistenceProof;
case: "exist";
} | {
/**
* @generated from field: cosmos.ics23.v1.NonExistenceProof nonexist = 2;
*/
value: NonExistenceProof;
case: "nonexist";
} | { case: undefined; value?: undefined } = { case: undefined };
constructor(data?: PartialMessage<BatchEntry>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmos.ics23.v1.BatchEntry";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "exist", kind: "message", T: ExistenceProof, oneof: "proof" },
{ no: 2, name: "nonexist", kind: "message", T: NonExistenceProof, oneof: "proof" },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BatchEntry {
return new BatchEntry().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BatchEntry {
return new BatchEntry().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BatchEntry {
return new BatchEntry().fromJsonString(jsonString, options);
}
static equals(a: BatchEntry | PlainMessage<BatchEntry> | undefined, b: BatchEntry | PlainMessage<BatchEntry> | undefined): boolean {
return proto3.util.equals(BatchEntry, a, b);
}
}
/**
* @generated from message cosmos.ics23.v1.CompressedBatchProof
*/
export class CompressedBatchProof extends Message<CompressedBatchProof> {
/**
* @generated from field: repeated cosmos.ics23.v1.CompressedBatchEntry entries = 1;
*/
entries: CompressedBatchEntry[] = [];
/**
* @generated from field: repeated cosmos.ics23.v1.InnerOp lookup_inners = 2;
*/
lookupInners: InnerOp[] = [];
constructor(data?: PartialMessage<CompressedBatchProof>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmos.ics23.v1.CompressedBatchProof";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "entries", kind: "message", T: CompressedBatchEntry, repeated: true },
{ no: 2, name: "lookup_inners", kind: "message", T: InnerOp, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CompressedBatchProof {
return new CompressedBatchProof().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CompressedBatchProof {
return new CompressedBatchProof().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CompressedBatchProof {
return new CompressedBatchProof().fromJsonString(jsonString, options);
}
static equals(a: CompressedBatchProof | PlainMessage<CompressedBatchProof> | undefined, b: CompressedBatchProof | PlainMessage<CompressedBatchProof> | undefined): boolean {
return proto3.util.equals(CompressedBatchProof, a, b);
}
}
/**
* Use BatchEntry not CommitmentProof, to avoid recursion
*
* @generated from message cosmos.ics23.v1.CompressedBatchEntry
*/
export class CompressedBatchEntry extends Message<CompressedBatchEntry> {
/**
* @generated from oneof cosmos.ics23.v1.CompressedBatchEntry.proof
*/
proof: {
/**
* @generated from field: cosmos.ics23.v1.CompressedExistenceProof exist = 1;
*/
value: CompressedExistenceProof;
case: "exist";
} | {
/**
* @generated from field: cosmos.ics23.v1.CompressedNonExistenceProof nonexist = 2;
*/
value: CompressedNonExistenceProof;
case: "nonexist";
} | { case: undefined; value?: undefined } = { case: undefined };
constructor(data?: PartialMessage<CompressedBatchEntry>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmos.ics23.v1.CompressedBatchEntry";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "exist", kind: "message", T: CompressedExistenceProof, oneof: "proof" },
{ no: 2, name: "nonexist", kind: "message", T: CompressedNonExistenceProof, oneof: "proof" },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CompressedBatchEntry {
return new CompressedBatchEntry().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CompressedBatchEntry {
return new CompressedBatchEntry().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CompressedBatchEntry {
return new CompressedBatchEntry().fromJsonString(jsonString, options);
}
static equals(a: CompressedBatchEntry | PlainMessage<CompressedBatchEntry> | undefined, b: CompressedBatchEntry | PlainMessage<CompressedBatchEntry> | undefined): boolean {
return proto3.util.equals(CompressedBatchEntry, a, b);
}
}
/**
* @generated from message cosmos.ics23.v1.CompressedExistenceProof
*/
export class CompressedExistenceProof extends Message<CompressedExistenceProof> {
/**
* @generated from field: bytes key = 1;
*/
key = new Uint8Array(0);
/**
* @generated from field: bytes value = 2;
*/
value = new Uint8Array(0);
/**
* @generated from field: cosmos.ics23.v1.LeafOp leaf = 3;
*/
leaf?: LeafOp;
/**
* these are indexes into the lookup_inners table in CompressedBatchProof
*
* @generated from field: repeated int32 path = 4;
*/
path: number[] = [];
constructor(data?: PartialMessage<CompressedExistenceProof>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmos.ics23.v1.CompressedExistenceProof";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "key", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "value", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 3, name: "leaf", kind: "message", T: LeafOp },
{ no: 4, name: "path", kind: "scalar", T: 5 /* ScalarType.INT32 */, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CompressedExistenceProof {
return new CompressedExistenceProof().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CompressedExistenceProof {
return new CompressedExistenceProof().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CompressedExistenceProof {
return new CompressedExistenceProof().fromJsonString(jsonString, options);
}
static equals(a: CompressedExistenceProof | PlainMessage<CompressedExistenceProof> | undefined, b: CompressedExistenceProof | PlainMessage<CompressedExistenceProof> | undefined): boolean {
return proto3.util.equals(CompressedExistenceProof, a, b);
}
}
/**
* @generated from message cosmos.ics23.v1.CompressedNonExistenceProof
*/
export class CompressedNonExistenceProof extends Message<CompressedNonExistenceProof> {
/**
* TODO: remove this as unnecessary??? we prove a range
*
* @generated from field: bytes key = 1;
*/
key = new Uint8Array(0);
/**
* @generated from field: cosmos.ics23.v1.CompressedExistenceProof left = 2;
*/
left?: CompressedExistenceProof;
/**
* @generated from field: cosmos.ics23.v1.CompressedExistenceProof right = 3;
*/
right?: CompressedExistenceProof;
constructor(data?: PartialMessage<CompressedNonExistenceProof>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmos.ics23.v1.CompressedNonExistenceProof";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "key", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "left", kind: "message", T: CompressedExistenceProof },
{ no: 3, name: "right", kind: "message", T: CompressedExistenceProof },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CompressedNonExistenceProof {
return new CompressedNonExistenceProof().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CompressedNonExistenceProof {
return new CompressedNonExistenceProof().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CompressedNonExistenceProof {
return new CompressedNonExistenceProof().fromJsonString(jsonString, options);
}
static equals(a: CompressedNonExistenceProof | PlainMessage<CompressedNonExistenceProof> | undefined, b: CompressedNonExistenceProof | PlainMessage<CompressedNonExistenceProof> | undefined): boolean {
return proto3.util.equals(CompressedNonExistenceProof, a, b);
}
}

505
libs/es-client/src/protobufs/cosmwasm/wasm/v1/authz_pb.ts Normal file
View File

@ -0,0 +1,505 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file cosmwasm/wasm/v1/authz.proto (package cosmwasm.wasm.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Any, Message, proto3, protoInt64 } from "@bufbuild/protobuf";
import { AccessConfig } from "./types_pb.js";
import { Coin } from "../../../cosmos/base/v1beta1/coin_pb.js";
/**
* StoreCodeAuthorization defines authorization for wasm code upload.
* Since: wasmd 0.42
*
* @generated from message cosmwasm.wasm.v1.StoreCodeAuthorization
*/
export class StoreCodeAuthorization extends Message<StoreCodeAuthorization> {
/**
* Grants for code upload
*
* @generated from field: repeated cosmwasm.wasm.v1.CodeGrant grants = 1;
*/
grants: CodeGrant[] = [];
constructor(data?: PartialMessage<StoreCodeAuthorization>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.StoreCodeAuthorization";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "grants", kind: "message", T: CodeGrant, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StoreCodeAuthorization {
return new StoreCodeAuthorization().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StoreCodeAuthorization {
return new StoreCodeAuthorization().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StoreCodeAuthorization {
return new StoreCodeAuthorization().fromJsonString(jsonString, options);
}
static equals(a: StoreCodeAuthorization | PlainMessage<StoreCodeAuthorization> | undefined, b: StoreCodeAuthorization | PlainMessage<StoreCodeAuthorization> | undefined): boolean {
return proto3.util.equals(StoreCodeAuthorization, a, b);
}
}
/**
* ContractExecutionAuthorization defines authorization for wasm execute.
* Since: wasmd 0.30
*
* @generated from message cosmwasm.wasm.v1.ContractExecutionAuthorization
*/
export class ContractExecutionAuthorization extends Message<ContractExecutionAuthorization> {
/**
* Grants for contract executions
*
* @generated from field: repeated cosmwasm.wasm.v1.ContractGrant grants = 1;
*/
grants: ContractGrant[] = [];
constructor(data?: PartialMessage<ContractExecutionAuthorization>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.ContractExecutionAuthorization";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "grants", kind: "message", T: ContractGrant, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ContractExecutionAuthorization {
return new ContractExecutionAuthorization().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ContractExecutionAuthorization {
return new ContractExecutionAuthorization().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ContractExecutionAuthorization {
return new ContractExecutionAuthorization().fromJsonString(jsonString, options);
}
static equals(a: ContractExecutionAuthorization | PlainMessage<ContractExecutionAuthorization> | undefined, b: ContractExecutionAuthorization | PlainMessage<ContractExecutionAuthorization> | undefined): boolean {
return proto3.util.equals(ContractExecutionAuthorization, a, b);
}
}
/**
* ContractMigrationAuthorization defines authorization for wasm contract
* migration. Since: wasmd 0.30
*
* @generated from message cosmwasm.wasm.v1.ContractMigrationAuthorization
*/
export class ContractMigrationAuthorization extends Message<ContractMigrationAuthorization> {
/**
* Grants for contract migrations
*
* @generated from field: repeated cosmwasm.wasm.v1.ContractGrant grants = 1;
*/
grants: ContractGrant[] = [];
constructor(data?: PartialMessage<ContractMigrationAuthorization>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.ContractMigrationAuthorization";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "grants", kind: "message", T: ContractGrant, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ContractMigrationAuthorization {
return new ContractMigrationAuthorization().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ContractMigrationAuthorization {
return new ContractMigrationAuthorization().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ContractMigrationAuthorization {
return new ContractMigrationAuthorization().fromJsonString(jsonString, options);
}
static equals(a: ContractMigrationAuthorization | PlainMessage<ContractMigrationAuthorization> | undefined, b: ContractMigrationAuthorization | PlainMessage<ContractMigrationAuthorization> | undefined): boolean {
return proto3.util.equals(ContractMigrationAuthorization, a, b);
}
}
/**
* CodeGrant a granted permission for a single code
*
* @generated from message cosmwasm.wasm.v1.CodeGrant
*/
export class CodeGrant extends Message<CodeGrant> {
/**
* CodeHash is the unique identifier created by wasmvm
* Wildcard "*" is used to specify any kind of grant.
*
* @generated from field: bytes code_hash = 1;
*/
codeHash = new Uint8Array(0);
/**
* InstantiatePermission is the superset access control to apply
* on contract creation.
* Optional
*
* @generated from field: cosmwasm.wasm.v1.AccessConfig instantiate_permission = 2;
*/
instantiatePermission?: AccessConfig;
constructor(data?: PartialMessage<CodeGrant>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.CodeGrant";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "code_hash", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "instantiate_permission", kind: "message", T: AccessConfig },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CodeGrant {
return new CodeGrant().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CodeGrant {
return new CodeGrant().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CodeGrant {
return new CodeGrant().fromJsonString(jsonString, options);
}
static equals(a: CodeGrant | PlainMessage<CodeGrant> | undefined, b: CodeGrant | PlainMessage<CodeGrant> | undefined): boolean {
return proto3.util.equals(CodeGrant, a, b);
}
}
/**
* ContractGrant a granted permission for a single contract
* Since: wasmd 0.30
*
* @generated from message cosmwasm.wasm.v1.ContractGrant
*/
export class ContractGrant extends Message<ContractGrant> {
/**
* Contract is the bech32 address of the smart contract
*
* @generated from field: string contract = 1;
*/
contract = "";
/**
* Limit defines execution limits that are enforced and updated when the grant
* is applied. When the limit lapsed the grant is removed.
*
* @generated from field: google.protobuf.Any limit = 2;
*/
limit?: Any;
/**
* Filter define more fine-grained control on the message payload passed
* to the contract in the operation. When no filter applies on execution, the
* operation is prohibited.
*
* @generated from field: google.protobuf.Any filter = 3;
*/
filter?: Any;
constructor(data?: PartialMessage<ContractGrant>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.ContractGrant";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "contract", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "limit", kind: "message", T: Any },
{ no: 3, name: "filter", kind: "message", T: Any },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ContractGrant {
return new ContractGrant().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ContractGrant {
return new ContractGrant().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ContractGrant {
return new ContractGrant().fromJsonString(jsonString, options);
}
static equals(a: ContractGrant | PlainMessage<ContractGrant> | undefined, b: ContractGrant | PlainMessage<ContractGrant> | undefined): boolean {
return proto3.util.equals(ContractGrant, a, b);
}
}
/**
* MaxCallsLimit limited number of calls to the contract. No funds transferable.
* Since: wasmd 0.30
*
* @generated from message cosmwasm.wasm.v1.MaxCallsLimit
*/
export class MaxCallsLimit extends Message<MaxCallsLimit> {
/**
* Remaining number that is decremented on each execution
*
* @generated from field: uint64 remaining = 1;
*/
remaining = protoInt64.zero;
constructor(data?: PartialMessage<MaxCallsLimit>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.MaxCallsLimit";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "remaining", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MaxCallsLimit {
return new MaxCallsLimit().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MaxCallsLimit {
return new MaxCallsLimit().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MaxCallsLimit {
return new MaxCallsLimit().fromJsonString(jsonString, options);
}
static equals(a: MaxCallsLimit | PlainMessage<MaxCallsLimit> | undefined, b: MaxCallsLimit | PlainMessage<MaxCallsLimit> | undefined): boolean {
return proto3.util.equals(MaxCallsLimit, a, b);
}
}
/**
* MaxFundsLimit defines the maximal amounts that can be sent to the contract.
* Since: wasmd 0.30
*
* @generated from message cosmwasm.wasm.v1.MaxFundsLimit
*/
export class MaxFundsLimit extends Message<MaxFundsLimit> {
/**
* Amounts is the maximal amount of tokens transferable to the contract.
*
* @generated from field: repeated cosmos.base.v1beta1.Coin amounts = 1;
*/
amounts: Coin[] = [];
constructor(data?: PartialMessage<MaxFundsLimit>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.MaxFundsLimit";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "amounts", kind: "message", T: Coin, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MaxFundsLimit {
return new MaxFundsLimit().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MaxFundsLimit {
return new MaxFundsLimit().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MaxFundsLimit {
return new MaxFundsLimit().fromJsonString(jsonString, options);
}
static equals(a: MaxFundsLimit | PlainMessage<MaxFundsLimit> | undefined, b: MaxFundsLimit | PlainMessage<MaxFundsLimit> | undefined): boolean {
return proto3.util.equals(MaxFundsLimit, a, b);
}
}
/**
* CombinedLimit defines the maximal amounts that can be sent to a contract and
* the maximal number of calls executable. Both need to remain >0 to be valid.
* Since: wasmd 0.30
*
* @generated from message cosmwasm.wasm.v1.CombinedLimit
*/
export class CombinedLimit extends Message<CombinedLimit> {
/**
* Remaining number that is decremented on each execution
*
* @generated from field: uint64 calls_remaining = 1;
*/
callsRemaining = protoInt64.zero;
/**
* Amounts is the maximal amount of tokens transferable to the contract.
*
* @generated from field: repeated cosmos.base.v1beta1.Coin amounts = 2;
*/
amounts: Coin[] = [];
constructor(data?: PartialMessage<CombinedLimit>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.CombinedLimit";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "calls_remaining", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 2, name: "amounts", kind: "message", T: Coin, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CombinedLimit {
return new CombinedLimit().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CombinedLimit {
return new CombinedLimit().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CombinedLimit {
return new CombinedLimit().fromJsonString(jsonString, options);
}
static equals(a: CombinedLimit | PlainMessage<CombinedLimit> | undefined, b: CombinedLimit | PlainMessage<CombinedLimit> | undefined): boolean {
return proto3.util.equals(CombinedLimit, a, b);
}
}
/**
* AllowAllMessagesFilter is a wildcard to allow any type of contract payload
* message.
* Since: wasmd 0.30
*
* @generated from message cosmwasm.wasm.v1.AllowAllMessagesFilter
*/
export class AllowAllMessagesFilter extends Message<AllowAllMessagesFilter> {
constructor(data?: PartialMessage<AllowAllMessagesFilter>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.AllowAllMessagesFilter";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AllowAllMessagesFilter {
return new AllowAllMessagesFilter().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AllowAllMessagesFilter {
return new AllowAllMessagesFilter().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AllowAllMessagesFilter {
return new AllowAllMessagesFilter().fromJsonString(jsonString, options);
}
static equals(a: AllowAllMessagesFilter | PlainMessage<AllowAllMessagesFilter> | undefined, b: AllowAllMessagesFilter | PlainMessage<AllowAllMessagesFilter> | undefined): boolean {
return proto3.util.equals(AllowAllMessagesFilter, a, b);
}
}
/**
* AcceptedMessageKeysFilter accept only the specific contract message keys in
* the json object to be executed.
* Since: wasmd 0.30
*
* @generated from message cosmwasm.wasm.v1.AcceptedMessageKeysFilter
*/
export class AcceptedMessageKeysFilter extends Message<AcceptedMessageKeysFilter> {
/**
* Messages is the list of unique keys
*
* @generated from field: repeated string keys = 1;
*/
keys: string[] = [];
constructor(data?: PartialMessage<AcceptedMessageKeysFilter>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.AcceptedMessageKeysFilter";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "keys", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AcceptedMessageKeysFilter {
return new AcceptedMessageKeysFilter().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AcceptedMessageKeysFilter {
return new AcceptedMessageKeysFilter().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AcceptedMessageKeysFilter {
return new AcceptedMessageKeysFilter().fromJsonString(jsonString, options);
}
static equals(a: AcceptedMessageKeysFilter | PlainMessage<AcceptedMessageKeysFilter> | undefined, b: AcceptedMessageKeysFilter | PlainMessage<AcceptedMessageKeysFilter> | undefined): boolean {
return proto3.util.equals(AcceptedMessageKeysFilter, a, b);
}
}
/**
* AcceptedMessagesFilter accept only the specific raw contract messages to be
* executed.
* Since: wasmd 0.30
*
* @generated from message cosmwasm.wasm.v1.AcceptedMessagesFilter
*/
export class AcceptedMessagesFilter extends Message<AcceptedMessagesFilter> {
/**
* Messages is the list of raw contract messages
*
* @generated from field: repeated bytes messages = 1;
*/
messages: Uint8Array[] = [];
constructor(data?: PartialMessage<AcceptedMessagesFilter>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.AcceptedMessagesFilter";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "messages", kind: "scalar", T: 12 /* ScalarType.BYTES */, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AcceptedMessagesFilter {
return new AcceptedMessagesFilter().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AcceptedMessagesFilter {
return new AcceptedMessagesFilter().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AcceptedMessagesFilter {
return new AcceptedMessagesFilter().fromJsonString(jsonString, options);
}
static equals(a: AcceptedMessagesFilter | PlainMessage<AcceptedMessagesFilter> | undefined, b: AcceptedMessagesFilter | PlainMessage<AcceptedMessagesFilter> | undefined): boolean {
return proto3.util.equals(AcceptedMessagesFilter, a, b);
}
}

227
libs/es-client/src/protobufs/cosmwasm/wasm/v1/genesis_pb.ts Normal file
View File

@ -0,0 +1,227 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file cosmwasm/wasm/v1/genesis.proto (package cosmwasm.wasm.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, protoInt64 } from "@bufbuild/protobuf";
import { CodeInfo, ContractCodeHistoryEntry, ContractInfo, Model, Params } from "./types_pb.js";
/**
* GenesisState - genesis state of x/wasm
*
* @generated from message cosmwasm.wasm.v1.GenesisState
*/
export class GenesisState extends Message<GenesisState> {
/**
* @generated from field: cosmwasm.wasm.v1.Params params = 1;
*/
params?: Params;
/**
* @generated from field: repeated cosmwasm.wasm.v1.Code codes = 2;
*/
codes: Code[] = [];
/**
* @generated from field: repeated cosmwasm.wasm.v1.Contract contracts = 3;
*/
contracts: Contract[] = [];
/**
* @generated from field: repeated cosmwasm.wasm.v1.Sequence sequences = 4;
*/
sequences: Sequence[] = [];
constructor(data?: PartialMessage<GenesisState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.GenesisState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "params", kind: "message", T: Params },
{ no: 2, name: "codes", kind: "message", T: Code, repeated: true },
{ no: 3, name: "contracts", kind: "message", T: Contract, repeated: true },
{ no: 4, name: "sequences", kind: "message", T: Sequence, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GenesisState {
return new GenesisState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJsonString(jsonString, options);
}
static equals(a: GenesisState | PlainMessage<GenesisState> | undefined, b: GenesisState | PlainMessage<GenesisState> | undefined): boolean {
return proto3.util.equals(GenesisState, a, b);
}
}
/**
* Code struct encompasses CodeInfo and CodeBytes
*
* @generated from message cosmwasm.wasm.v1.Code
*/
export class Code extends Message<Code> {
/**
* @generated from field: uint64 code_id = 1;
*/
codeId = protoInt64.zero;
/**
* @generated from field: cosmwasm.wasm.v1.CodeInfo code_info = 2;
*/
codeInfo?: CodeInfo;
/**
* @generated from field: bytes code_bytes = 3;
*/
codeBytes = new Uint8Array(0);
/**
* Pinned to wasmvm cache
*
* @generated from field: bool pinned = 4;
*/
pinned = false;
constructor(data?: PartialMessage<Code>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.Code";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "code_id", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 2, name: "code_info", kind: "message", T: CodeInfo },
{ no: 3, name: "code_bytes", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 4, name: "pinned", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Code {
return new Code().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Code {
return new Code().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Code {
return new Code().fromJsonString(jsonString, options);
}
static equals(a: Code | PlainMessage<Code> | undefined, b: Code | PlainMessage<Code> | undefined): boolean {
return proto3.util.equals(Code, a, b);
}
}
/**
* Contract struct encompasses ContractAddress, ContractInfo, and ContractState
*
* @generated from message cosmwasm.wasm.v1.Contract
*/
export class Contract extends Message<Contract> {
/**
* @generated from field: string contract_address = 1;
*/
contractAddress = "";
/**
* @generated from field: cosmwasm.wasm.v1.ContractInfo contract_info = 2;
*/
contractInfo?: ContractInfo;
/**
* @generated from field: repeated cosmwasm.wasm.v1.Model contract_state = 3;
*/
contractState: Model[] = [];
/**
* @generated from field: repeated cosmwasm.wasm.v1.ContractCodeHistoryEntry contract_code_history = 4;
*/
contractCodeHistory: ContractCodeHistoryEntry[] = [];
constructor(data?: PartialMessage<Contract>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.Contract";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "contract_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "contract_info", kind: "message", T: ContractInfo },
{ no: 3, name: "contract_state", kind: "message", T: Model, repeated: true },
{ no: 4, name: "contract_code_history", kind: "message", T: ContractCodeHistoryEntry, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Contract {
return new Contract().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Contract {
return new Contract().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Contract {
return new Contract().fromJsonString(jsonString, options);
}
static equals(a: Contract | PlainMessage<Contract> | undefined, b: Contract | PlainMessage<Contract> | undefined): boolean {
return proto3.util.equals(Contract, a, b);
}
}
/**
* Sequence key and value of an id generation counter
*
* @generated from message cosmwasm.wasm.v1.Sequence
*/
export class Sequence extends Message<Sequence> {
/**
* @generated from field: bytes id_key = 1;
*/
idKey = new Uint8Array(0);
/**
* @generated from field: uint64 value = 2;
*/
value = protoInt64.zero;
constructor(data?: PartialMessage<Sequence>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.Sequence";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "id_key", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "value", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Sequence {
return new Sequence().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Sequence {
return new Sequence().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Sequence {
return new Sequence().fromJsonString(jsonString, options);
}
static equals(a: Sequence | PlainMessage<Sequence> | undefined, b: Sequence | PlainMessage<Sequence> | undefined): boolean {
return proto3.util.equals(Sequence, a, b);
}
}

189
libs/es-client/src/protobufs/cosmwasm/wasm/v1/ibc_pb.ts Normal file
View File

@ -0,0 +1,189 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file cosmwasm/wasm/v1/ibc.proto (package cosmwasm.wasm.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, protoInt64 } from "@bufbuild/protobuf";
/**
* MsgIBCSend
*
* @generated from message cosmwasm.wasm.v1.MsgIBCSend
*/
export class MsgIBCSend extends Message<MsgIBCSend> {
/**
* the channel by which the packet will be sent
*
* @generated from field: string channel = 2;
*/
channel = "";
/**
* Timeout height relative to the current block height.
* The timeout is disabled when set to 0.
*
* @generated from field: uint64 timeout_height = 4;
*/
timeoutHeight = protoInt64.zero;
/**
* Timeout timestamp (in nanoseconds) relative to the current block timestamp.
* The timeout is disabled when set to 0.
*
* @generated from field: uint64 timeout_timestamp = 5;
*/
timeoutTimestamp = protoInt64.zero;
/**
* Data is the payload to transfer. We must not make assumption what format or
* content is in here.
*
* @generated from field: bytes data = 6;
*/
data = new Uint8Array(0);
constructor(data?: PartialMessage<MsgIBCSend>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.MsgIBCSend";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 2, name: "channel", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "timeout_height", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 5, name: "timeout_timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 6, name: "data", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgIBCSend {
return new MsgIBCSend().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgIBCSend {
return new MsgIBCSend().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgIBCSend {
return new MsgIBCSend().fromJsonString(jsonString, options);
}
static equals(a: MsgIBCSend | PlainMessage<MsgIBCSend> | undefined, b: MsgIBCSend | PlainMessage<MsgIBCSend> | undefined): boolean {
return proto3.util.equals(MsgIBCSend, a, b);
}
}
/**
* MsgIBCSendResponse
*
* @generated from message cosmwasm.wasm.v1.MsgIBCSendResponse
*/
export class MsgIBCSendResponse extends Message<MsgIBCSendResponse> {
/**
* Sequence number of the IBC packet sent
*
* @generated from field: uint64 sequence = 1;
*/
sequence = protoInt64.zero;
constructor(data?: PartialMessage<MsgIBCSendResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.MsgIBCSendResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgIBCSendResponse {
return new MsgIBCSendResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgIBCSendResponse {
return new MsgIBCSendResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgIBCSendResponse {
return new MsgIBCSendResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgIBCSendResponse | PlainMessage<MsgIBCSendResponse> | undefined, b: MsgIBCSendResponse | PlainMessage<MsgIBCSendResponse> | undefined): boolean {
return proto3.util.equals(MsgIBCSendResponse, a, b);
}
}
/**
* MsgIBCWriteAcknowledgementResponse
*
* @generated from message cosmwasm.wasm.v1.MsgIBCWriteAcknowledgementResponse
*/
export class MsgIBCWriteAcknowledgementResponse extends Message<MsgIBCWriteAcknowledgementResponse> {
constructor(data?: PartialMessage<MsgIBCWriteAcknowledgementResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.MsgIBCWriteAcknowledgementResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgIBCWriteAcknowledgementResponse {
return new MsgIBCWriteAcknowledgementResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgIBCWriteAcknowledgementResponse {
return new MsgIBCWriteAcknowledgementResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgIBCWriteAcknowledgementResponse {
return new MsgIBCWriteAcknowledgementResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgIBCWriteAcknowledgementResponse | PlainMessage<MsgIBCWriteAcknowledgementResponse> | undefined, b: MsgIBCWriteAcknowledgementResponse | PlainMessage<MsgIBCWriteAcknowledgementResponse> | undefined): boolean {
return proto3.util.equals(MsgIBCWriteAcknowledgementResponse, a, b);
}
}
/**
* MsgIBCCloseChannel port and channel need to be owned by the contract
*
* @generated from message cosmwasm.wasm.v1.MsgIBCCloseChannel
*/
export class MsgIBCCloseChannel extends Message<MsgIBCCloseChannel> {
/**
* @generated from field: string channel = 2;
*/
channel = "";
constructor(data?: PartialMessage<MsgIBCCloseChannel>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.MsgIBCCloseChannel";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 2, name: "channel", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgIBCCloseChannel {
return new MsgIBCCloseChannel().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgIBCCloseChannel {
return new MsgIBCCloseChannel().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgIBCCloseChannel {
return new MsgIBCCloseChannel().fromJsonString(jsonString, options);
}
static equals(a: MsgIBCCloseChannel | PlainMessage<MsgIBCCloseChannel> | undefined, b: MsgIBCCloseChannel | PlainMessage<MsgIBCCloseChannel> | undefined): boolean {
return proto3.util.equals(MsgIBCCloseChannel, a, b);
}
}

1080
libs/es-client/src/protobufs/cosmwasm/wasm/v1/proposal_legacy_pb.ts Normal file
View File

File diff suppressed because it is too large Load Diff

178
libs/es-client/src/protobufs/cosmwasm/wasm/v1/query_cosmes.ts Normal file
View File

@ -0,0 +1,178 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file cosmwasm/wasm/v1/query.proto (package cosmwasm.wasm.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { QueryAllContractStateRequest, QueryAllContractStateResponse, QueryBuildAddressRequest, QueryBuildAddressResponse, QueryCodeInfoRequest, QueryCodeInfoResponse, QueryCodeRequest, QueryCodeResponse, QueryCodesRequest, QueryCodesResponse, QueryContractHistoryRequest, QueryContractHistoryResponse, QueryContractInfoRequest, QueryContractInfoResponse, QueryContractsByCodeRequest, QueryContractsByCodeResponse, QueryContractsByCreatorRequest, QueryContractsByCreatorResponse, QueryParamsRequest, QueryParamsResponse, QueryPinnedCodesRequest, QueryPinnedCodesResponse, QueryRawContractStateRequest, QueryRawContractStateResponse, QuerySmartContractStateRequest, QuerySmartContractStateResponse, QueryWasmLimitsConfigRequest, QueryWasmLimitsConfigResponse } from "./query_pb.js";
const TYPE_NAME = "cosmwasm.wasm.v1.Query";
/**
* ContractInfo gets the contract meta data
*
* @generated from rpc cosmwasm.wasm.v1.Query.ContractInfo
*/
export const QueryContractInfoService = {
typeName: TYPE_NAME,
method: "ContractInfo",
Request: QueryContractInfoRequest,
Response: QueryContractInfoResponse,
} as const;
/**
* ContractHistory gets the contract code history
*
* @generated from rpc cosmwasm.wasm.v1.Query.ContractHistory
*/
export const QueryContractHistoryService = {
typeName: TYPE_NAME,
method: "ContractHistory",
Request: QueryContractHistoryRequest,
Response: QueryContractHistoryResponse,
} as const;
/**
* ContractsByCode lists all smart contracts for a code id
*
* @generated from rpc cosmwasm.wasm.v1.Query.ContractsByCode
*/
export const QueryContractsByCodeService = {
typeName: TYPE_NAME,
method: "ContractsByCode",
Request: QueryContractsByCodeRequest,
Response: QueryContractsByCodeResponse,
} as const;
/**
* AllContractState gets all raw store data for a single contract
*
* @generated from rpc cosmwasm.wasm.v1.Query.AllContractState
*/
export const QueryAllContractStateService = {
typeName: TYPE_NAME,
method: "AllContractState",
Request: QueryAllContractStateRequest,
Response: QueryAllContractStateResponse,
} as const;
/**
* RawContractState gets single key from the raw store data of a contract
*
* @generated from rpc cosmwasm.wasm.v1.Query.RawContractState
*/
export const QueryRawContractStateService = {
typeName: TYPE_NAME,
method: "RawContractState",
Request: QueryRawContractStateRequest,
Response: QueryRawContractStateResponse,
} as const;
/**
* SmartContractState get smart query result from the contract
*
* @generated from rpc cosmwasm.wasm.v1.Query.SmartContractState
*/
export const QuerySmartContractStateService = {
typeName: TYPE_NAME,
method: "SmartContractState",
Request: QuerySmartContractStateRequest,
Response: QuerySmartContractStateResponse,
} as const;
/**
* Code gets the binary code and metadata for a single wasm code
*
* @generated from rpc cosmwasm.wasm.v1.Query.Code
*/
export const QueryCodeService = {
typeName: TYPE_NAME,
method: "Code",
Request: QueryCodeRequest,
Response: QueryCodeResponse,
} as const;
/**
* Codes gets the metadata for all stored wasm codes
*
* @generated from rpc cosmwasm.wasm.v1.Query.Codes
*/
export const QueryCodesService = {
typeName: TYPE_NAME,
method: "Codes",
Request: QueryCodesRequest,
Response: QueryCodesResponse,
} as const;
/**
* CodeInfo gets the metadata for a single wasm code
*
* @generated from rpc cosmwasm.wasm.v1.Query.CodeInfo
*/
export const QueryCodeInfoService = {
typeName: TYPE_NAME,
method: "CodeInfo",
Request: QueryCodeInfoRequest,
Response: QueryCodeInfoResponse,
} as const;
/**
* PinnedCodes gets the pinned code ids
*
* @generated from rpc cosmwasm.wasm.v1.Query.PinnedCodes
*/
export const QueryPinnedCodesService = {
typeName: TYPE_NAME,
method: "PinnedCodes",
Request: QueryPinnedCodesRequest,
Response: QueryPinnedCodesResponse,
} as const;
/**
* Params gets the module params
*
* @generated from rpc cosmwasm.wasm.v1.Query.Params
*/
export const QueryParamsService = {
typeName: TYPE_NAME,
method: "Params",
Request: QueryParamsRequest,
Response: QueryParamsResponse,
} as const;
/**
* ContractsByCreator gets the contracts by creator
*
* @generated from rpc cosmwasm.wasm.v1.Query.ContractsByCreator
*/
export const QueryContractsByCreatorService = {
typeName: TYPE_NAME,
method: "ContractsByCreator",
Request: QueryContractsByCreatorRequest,
Response: QueryContractsByCreatorResponse,
} as const;
/**
* WasmLimitsConfig gets the configured limits for static validation of Wasm
* files, encoded in JSON.
*
* @generated from rpc cosmwasm.wasm.v1.Query.WasmLimitsConfig
*/
export const QueryWasmLimitsConfigService = {
typeName: TYPE_NAME,
method: "WasmLimitsConfig",
Request: QueryWasmLimitsConfigRequest,
Response: QueryWasmLimitsConfigResponse,
} as const;
/**
* BuildAddress builds a contract address
*
* @generated from rpc cosmwasm.wasm.v1.Query.BuildAddress
*/
export const QueryBuildAddressService = {
typeName: TYPE_NAME,
method: "BuildAddress",
Request: QueryBuildAddressRequest,
Response: QueryBuildAddressResponse,
} as const;

1357
libs/es-client/src/protobufs/cosmwasm/wasm/v1/query_pb.ts Normal file
View File

File diff suppressed because it is too large Load Diff

239
libs/es-client/src/protobufs/cosmwasm/wasm/v1/tx_cosmes.ts Normal file
View File

@ -0,0 +1,239 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file cosmwasm/wasm/v1/tx.proto (package cosmwasm.wasm.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { MsgAddCodeUploadParamsAddresses, MsgAddCodeUploadParamsAddressesResponse, MsgClearAdmin, MsgClearAdminResponse, MsgExecuteContract, MsgExecuteContractResponse, MsgInstantiateContract, MsgInstantiateContract2, MsgInstantiateContract2Response, MsgInstantiateContractResponse, MsgMigrateContract, MsgMigrateContractResponse, MsgPinCodes, MsgPinCodesResponse, MsgRemoveCodeUploadParamsAddresses, MsgRemoveCodeUploadParamsAddressesResponse, MsgStoreAndInstantiateContract, MsgStoreAndInstantiateContractResponse, MsgStoreAndMigrateContract, MsgStoreAndMigrateContractResponse, MsgStoreCode, MsgStoreCodeResponse, MsgSudoContract, MsgSudoContractResponse, MsgUnpinCodes, MsgUnpinCodesResponse, MsgUpdateAdmin, MsgUpdateAdminResponse, MsgUpdateContractLabel, MsgUpdateContractLabelResponse, MsgUpdateInstantiateConfig, MsgUpdateInstantiateConfigResponse, MsgUpdateParams, MsgUpdateParamsResponse } from "./tx_pb.js";
const TYPE_NAME = "cosmwasm.wasm.v1.Msg";
/**
* StoreCode to submit Wasm code to the system
*
* @generated from rpc cosmwasm.wasm.v1.Msg.StoreCode
*/
export const MsgStoreCodeService = {
typeName: TYPE_NAME,
method: "StoreCode",
Request: MsgStoreCode,
Response: MsgStoreCodeResponse,
} as const;
/**
* InstantiateContract creates a new smart contract instance for the given
* code id.
*
* @generated from rpc cosmwasm.wasm.v1.Msg.InstantiateContract
*/
export const MsgInstantiateContractService = {
typeName: TYPE_NAME,
method: "InstantiateContract",
Request: MsgInstantiateContract,
Response: MsgInstantiateContractResponse,
} as const;
/**
* InstantiateContract2 creates a new smart contract instance for the given
* code id with a predictable address
*
* @generated from rpc cosmwasm.wasm.v1.Msg.InstantiateContract2
*/
export const MsgInstantiateContract2Service = {
typeName: TYPE_NAME,
method: "InstantiateContract2",
Request: MsgInstantiateContract2,
Response: MsgInstantiateContract2Response,
} as const;
/**
* Execute submits the given message data to a smart contract
*
* @generated from rpc cosmwasm.wasm.v1.Msg.ExecuteContract
*/
export const MsgExecuteContractService = {
typeName: TYPE_NAME,
method: "ExecuteContract",
Request: MsgExecuteContract,
Response: MsgExecuteContractResponse,
} as const;
/**
* Migrate runs a code upgrade/ downgrade for a smart contract
*
* @generated from rpc cosmwasm.wasm.v1.Msg.MigrateContract
*/
export const MsgMigrateContractService = {
typeName: TYPE_NAME,
method: "MigrateContract",
Request: MsgMigrateContract,
Response: MsgMigrateContractResponse,
} as const;
/**
* UpdateAdmin sets a new admin for a smart contract
*
* @generated from rpc cosmwasm.wasm.v1.Msg.UpdateAdmin
*/
export const MsgUpdateAdminService = {
typeName: TYPE_NAME,
method: "UpdateAdmin",
Request: MsgUpdateAdmin,
Response: MsgUpdateAdminResponse,
} as const;
/**
* ClearAdmin removes any admin stored for a smart contract
*
* @generated from rpc cosmwasm.wasm.v1.Msg.ClearAdmin
*/
export const MsgClearAdminService = {
typeName: TYPE_NAME,
method: "ClearAdmin",
Request: MsgClearAdmin,
Response: MsgClearAdminResponse,
} as const;
/**
* UpdateInstantiateConfig updates instantiate config for a smart contract
*
* @generated from rpc cosmwasm.wasm.v1.Msg.UpdateInstantiateConfig
*/
export const MsgUpdateInstantiateConfigService = {
typeName: TYPE_NAME,
method: "UpdateInstantiateConfig",
Request: MsgUpdateInstantiateConfig,
Response: MsgUpdateInstantiateConfigResponse,
} as const;
/**
* UpdateParams defines a governance operation for updating the x/wasm
* module parameters. The authority is defined in the keeper.
*
* Since: 0.40
*
* @generated from rpc cosmwasm.wasm.v1.Msg.UpdateParams
*/
export const MsgUpdateParamsService = {
typeName: TYPE_NAME,
method: "UpdateParams",
Request: MsgUpdateParams,
Response: MsgUpdateParamsResponse,
} as const;
/**
* SudoContract defines a governance operation for calling sudo
* on a contract. The authority is defined in the keeper.
*
* Since: 0.40
*
* @generated from rpc cosmwasm.wasm.v1.Msg.SudoContract
*/
export const MsgSudoContractService = {
typeName: TYPE_NAME,
method: "SudoContract",
Request: MsgSudoContract,
Response: MsgSudoContractResponse,
} as const;
/**
* PinCodes defines a governance operation for pinning a set of
* code ids in the wasmvm cache. The authority is defined in the keeper.
*
* Since: 0.40
*
* @generated from rpc cosmwasm.wasm.v1.Msg.PinCodes
*/
export const MsgPinCodesService = {
typeName: TYPE_NAME,
method: "PinCodes",
Request: MsgPinCodes,
Response: MsgPinCodesResponse,
} as const;
/**
* UnpinCodes defines a governance operation for unpinning a set of
* code ids in the wasmvm cache. The authority is defined in the keeper.
*
* Since: 0.40
*
* @generated from rpc cosmwasm.wasm.v1.Msg.UnpinCodes
*/
export const MsgUnpinCodesService = {
typeName: TYPE_NAME,
method: "UnpinCodes",
Request: MsgUnpinCodes,
Response: MsgUnpinCodesResponse,
} as const;
/**
* StoreAndInstantiateContract defines a governance operation for storing
* and instantiating the contract. The authority is defined in the keeper.
*
* Since: 0.40
*
* @generated from rpc cosmwasm.wasm.v1.Msg.StoreAndInstantiateContract
*/
export const MsgStoreAndInstantiateContractService = {
typeName: TYPE_NAME,
method: "StoreAndInstantiateContract",
Request: MsgStoreAndInstantiateContract,
Response: MsgStoreAndInstantiateContractResponse,
} as const;
/**
* RemoveCodeUploadParamsAddresses defines a governance operation for
* removing addresses from code upload params.
* The authority is defined in the keeper.
*
* @generated from rpc cosmwasm.wasm.v1.Msg.RemoveCodeUploadParamsAddresses
*/
export const MsgRemoveCodeUploadParamsAddressesService = {
typeName: TYPE_NAME,
method: "RemoveCodeUploadParamsAddresses",
Request: MsgRemoveCodeUploadParamsAddresses,
Response: MsgRemoveCodeUploadParamsAddressesResponse,
} as const;
/**
* AddCodeUploadParamsAddresses defines a governance operation for
* adding addresses to code upload params.
* The authority is defined in the keeper.
*
* @generated from rpc cosmwasm.wasm.v1.Msg.AddCodeUploadParamsAddresses
*/
export const MsgAddCodeUploadParamsAddressesService = {
typeName: TYPE_NAME,
method: "AddCodeUploadParamsAddresses",
Request: MsgAddCodeUploadParamsAddresses,
Response: MsgAddCodeUploadParamsAddressesResponse,
} as const;
/**
* StoreAndMigrateContract defines a governance operation for storing
* and migrating the contract. The authority is defined in the keeper.
*
* Since: 0.42
*
* @generated from rpc cosmwasm.wasm.v1.Msg.StoreAndMigrateContract
*/
export const MsgStoreAndMigrateContractService = {
typeName: TYPE_NAME,
method: "StoreAndMigrateContract",
Request: MsgStoreAndMigrateContract,
Response: MsgStoreAndMigrateContractResponse,
} as const;
/**
* UpdateContractLabel sets a new label for a smart contract
*
* Since: 0.43
*
* @generated from rpc cosmwasm.wasm.v1.Msg.UpdateContractLabel
*/
export const MsgUpdateContractLabelService = {
typeName: TYPE_NAME,
method: "UpdateContractLabel",
Request: MsgUpdateContractLabel,
Response: MsgUpdateContractLabelResponse,
} as const;

1807
libs/es-client/src/protobufs/cosmwasm/wasm/v1/tx_pb.ts Normal file
View File

File diff suppressed because it is too large Load Diff

527
libs/es-client/src/protobufs/cosmwasm/wasm/v1/types_pb.ts Normal file
View File

@ -0,0 +1,527 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file cosmwasm/wasm/v1/types.proto (package cosmwasm.wasm.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Any, Message, proto3, protoInt64 } from "@bufbuild/protobuf";
/**
* AccessType permission types
*
* @generated from enum cosmwasm.wasm.v1.AccessType
*/
export enum AccessType {
/**
* AccessTypeUnspecified placeholder for empty value
*
* @generated from enum value: ACCESS_TYPE_UNSPECIFIED = 0;
*/
UNSPECIFIED = 0,
/**
* AccessTypeNobody forbidden
*
* @generated from enum value: ACCESS_TYPE_NOBODY = 1;
*/
NOBODY = 1,
/**
* AccessTypeEverybody unrestricted
*
* @generated from enum value: ACCESS_TYPE_EVERYBODY = 3;
*/
EVERYBODY = 3,
/**
* AccessTypeAnyOfAddresses allow any of the addresses
*
* @generated from enum value: ACCESS_TYPE_ANY_OF_ADDRESSES = 4;
*/
ANY_OF_ADDRESSES = 4,
}
// Retrieve enum metadata with: proto3.getEnumType(AccessType)
proto3.util.setEnumType(AccessType, "cosmwasm.wasm.v1.AccessType", [
{ no: 0, name: "ACCESS_TYPE_UNSPECIFIED" },
{ no: 1, name: "ACCESS_TYPE_NOBODY" },
{ no: 3, name: "ACCESS_TYPE_EVERYBODY" },
{ no: 4, name: "ACCESS_TYPE_ANY_OF_ADDRESSES" },
]);
/**
* ContractCodeHistoryOperationType actions that caused a code change
*
* @generated from enum cosmwasm.wasm.v1.ContractCodeHistoryOperationType
*/
export enum ContractCodeHistoryOperationType {
/**
* ContractCodeHistoryOperationTypeUnspecified placeholder for empty value
*
* @generated from enum value: CONTRACT_CODE_HISTORY_OPERATION_TYPE_UNSPECIFIED = 0;
*/
UNSPECIFIED = 0,
/**
* ContractCodeHistoryOperationTypeInit on chain contract instantiation
*
* @generated from enum value: CONTRACT_CODE_HISTORY_OPERATION_TYPE_INIT = 1;
*/
INIT = 1,
/**
* ContractCodeHistoryOperationTypeMigrate code migration
*
* @generated from enum value: CONTRACT_CODE_HISTORY_OPERATION_TYPE_MIGRATE = 2;
*/
MIGRATE = 2,
/**
* ContractCodeHistoryOperationTypeGenesis based on genesis data
*
* @generated from enum value: CONTRACT_CODE_HISTORY_OPERATION_TYPE_GENESIS = 3;
*/
GENESIS = 3,
}
// Retrieve enum metadata with: proto3.getEnumType(ContractCodeHistoryOperationType)
proto3.util.setEnumType(ContractCodeHistoryOperationType, "cosmwasm.wasm.v1.ContractCodeHistoryOperationType", [
{ no: 0, name: "CONTRACT_CODE_HISTORY_OPERATION_TYPE_UNSPECIFIED" },
{ no: 1, name: "CONTRACT_CODE_HISTORY_OPERATION_TYPE_INIT" },
{ no: 2, name: "CONTRACT_CODE_HISTORY_OPERATION_TYPE_MIGRATE" },
{ no: 3, name: "CONTRACT_CODE_HISTORY_OPERATION_TYPE_GENESIS" },
]);
/**
* AccessTypeParam
*
* @generated from message cosmwasm.wasm.v1.AccessTypeParam
*/
export class AccessTypeParam extends Message<AccessTypeParam> {
/**
* @generated from field: cosmwasm.wasm.v1.AccessType value = 1;
*/
value = AccessType.UNSPECIFIED;
constructor(data?: PartialMessage<AccessTypeParam>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.AccessTypeParam";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "value", kind: "enum", T: proto3.getEnumType(AccessType) },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AccessTypeParam {
return new AccessTypeParam().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AccessTypeParam {
return new AccessTypeParam().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AccessTypeParam {
return new AccessTypeParam().fromJsonString(jsonString, options);
}
static equals(a: AccessTypeParam | PlainMessage<AccessTypeParam> | undefined, b: AccessTypeParam | PlainMessage<AccessTypeParam> | undefined): boolean {
return proto3.util.equals(AccessTypeParam, a, b);
}
}
/**
* AccessConfig access control type.
*
* @generated from message cosmwasm.wasm.v1.AccessConfig
*/
export class AccessConfig extends Message<AccessConfig> {
/**
* @generated from field: cosmwasm.wasm.v1.AccessType permission = 1;
*/
permission = AccessType.UNSPECIFIED;
/**
* @generated from field: repeated string addresses = 3;
*/
addresses: string[] = [];
constructor(data?: PartialMessage<AccessConfig>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.AccessConfig";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "permission", kind: "enum", T: proto3.getEnumType(AccessType) },
{ no: 3, name: "addresses", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AccessConfig {
return new AccessConfig().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AccessConfig {
return new AccessConfig().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AccessConfig {
return new AccessConfig().fromJsonString(jsonString, options);
}
static equals(a: AccessConfig | PlainMessage<AccessConfig> | undefined, b: AccessConfig | PlainMessage<AccessConfig> | undefined): boolean {
return proto3.util.equals(AccessConfig, a, b);
}
}
/**
* Params defines the set of wasm parameters.
*
* @generated from message cosmwasm.wasm.v1.Params
*/
export class Params extends Message<Params> {
/**
* @generated from field: cosmwasm.wasm.v1.AccessConfig code_upload_access = 1;
*/
codeUploadAccess?: AccessConfig;
/**
* @generated from field: cosmwasm.wasm.v1.AccessType instantiate_default_permission = 2;
*/
instantiateDefaultPermission = AccessType.UNSPECIFIED;
constructor(data?: PartialMessage<Params>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.Params";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "code_upload_access", kind: "message", T: AccessConfig },
{ no: 2, name: "instantiate_default_permission", kind: "enum", T: proto3.getEnumType(AccessType) },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Params {
return new Params().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Params {
return new Params().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Params {
return new Params().fromJsonString(jsonString, options);
}
static equals(a: Params | PlainMessage<Params> | undefined, b: Params | PlainMessage<Params> | undefined): boolean {
return proto3.util.equals(Params, a, b);
}
}
/**
* CodeInfo is data for the uploaded contract WASM code
*
* @generated from message cosmwasm.wasm.v1.CodeInfo
*/
export class CodeInfo extends Message<CodeInfo> {
/**
* CodeHash is the unique identifier created by wasmvm
*
* @generated from field: bytes code_hash = 1;
*/
codeHash = new Uint8Array(0);
/**
* Creator address who initially stored the code
*
* @generated from field: string creator = 2;
*/
creator = "";
/**
* InstantiateConfig access control to apply on contract creation, optional
*
* @generated from field: cosmwasm.wasm.v1.AccessConfig instantiate_config = 5;
*/
instantiateConfig?: AccessConfig;
constructor(data?: PartialMessage<CodeInfo>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.CodeInfo";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "code_hash", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "creator", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 5, name: "instantiate_config", kind: "message", T: AccessConfig },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CodeInfo {
return new CodeInfo().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CodeInfo {
return new CodeInfo().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CodeInfo {
return new CodeInfo().fromJsonString(jsonString, options);
}
static equals(a: CodeInfo | PlainMessage<CodeInfo> | undefined, b: CodeInfo | PlainMessage<CodeInfo> | undefined): boolean {
return proto3.util.equals(CodeInfo, a, b);
}
}
/**
* ContractInfo stores a WASM contract instance
*
* @generated from message cosmwasm.wasm.v1.ContractInfo
*/
export class ContractInfo extends Message<ContractInfo> {
/**
* CodeID is the reference to the stored Wasm code
*
* @generated from field: uint64 code_id = 1;
*/
codeId = protoInt64.zero;
/**
* Creator address who initially instantiated the contract
*
* @generated from field: string creator = 2;
*/
creator = "";
/**
* Admin is an optional address that can execute migrations
*
* @generated from field: string admin = 3;
*/
admin = "";
/**
* Label is optional metadata to be stored with a contract instance.
*
* @generated from field: string label = 4;
*/
label = "";
/**
* Created Tx position when the contract was instantiated.
*
* @generated from field: cosmwasm.wasm.v1.AbsoluteTxPosition created = 5;
*/
created?: AbsoluteTxPosition;
/**
* @generated from field: string ibc_port_id = 6;
*/
ibcPortId = "";
/**
* Extension is an extension point to store custom metadata within the
* persistence model.
*
* @generated from field: google.protobuf.Any extension = 7;
*/
extension?: Any;
constructor(data?: PartialMessage<ContractInfo>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.ContractInfo";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "code_id", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 2, name: "creator", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "admin", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "label", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 5, name: "created", kind: "message", T: AbsoluteTxPosition },
{ no: 6, name: "ibc_port_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 7, name: "extension", kind: "message", T: Any },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ContractInfo {
return new ContractInfo().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ContractInfo {
return new ContractInfo().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ContractInfo {
return new ContractInfo().fromJsonString(jsonString, options);
}
static equals(a: ContractInfo | PlainMessage<ContractInfo> | undefined, b: ContractInfo | PlainMessage<ContractInfo> | undefined): boolean {
return proto3.util.equals(ContractInfo, a, b);
}
}
/**
* ContractCodeHistoryEntry metadata to a contract.
*
* @generated from message cosmwasm.wasm.v1.ContractCodeHistoryEntry
*/
export class ContractCodeHistoryEntry extends Message<ContractCodeHistoryEntry> {
/**
* @generated from field: cosmwasm.wasm.v1.ContractCodeHistoryOperationType operation = 1;
*/
operation = ContractCodeHistoryOperationType.UNSPECIFIED;
/**
* CodeID is the reference to the stored WASM code
*
* @generated from field: uint64 code_id = 2;
*/
codeId = protoInt64.zero;
/**
* Updated Tx position when the operation was executed.
*
* @generated from field: cosmwasm.wasm.v1.AbsoluteTxPosition updated = 3;
*/
updated?: AbsoluteTxPosition;
/**
* @generated from field: bytes msg = 4;
*/
msg = new Uint8Array(0);
constructor(data?: PartialMessage<ContractCodeHistoryEntry>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.ContractCodeHistoryEntry";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "operation", kind: "enum", T: proto3.getEnumType(ContractCodeHistoryOperationType) },
{ no: 2, name: "code_id", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 3, name: "updated", kind: "message", T: AbsoluteTxPosition },
{ no: 4, name: "msg", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ContractCodeHistoryEntry {
return new ContractCodeHistoryEntry().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ContractCodeHistoryEntry {
return new ContractCodeHistoryEntry().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ContractCodeHistoryEntry {
return new ContractCodeHistoryEntry().fromJsonString(jsonString, options);
}
static equals(a: ContractCodeHistoryEntry | PlainMessage<ContractCodeHistoryEntry> | undefined, b: ContractCodeHistoryEntry | PlainMessage<ContractCodeHistoryEntry> | undefined): boolean {
return proto3.util.equals(ContractCodeHistoryEntry, a, b);
}
}
/**
* AbsoluteTxPosition is a unique transaction position that allows for global
* ordering of transactions.
*
* @generated from message cosmwasm.wasm.v1.AbsoluteTxPosition
*/
export class AbsoluteTxPosition extends Message<AbsoluteTxPosition> {
/**
* BlockHeight is the block the contract was created at
*
* @generated from field: uint64 block_height = 1;
*/
blockHeight = protoInt64.zero;
/**
* TxIndex is a monotonic counter within the block (actual transaction index,
* or gas consumed)
*
* @generated from field: uint64 tx_index = 2;
*/
txIndex = protoInt64.zero;
constructor(data?: PartialMessage<AbsoluteTxPosition>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.AbsoluteTxPosition";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "block_height", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 2, name: "tx_index", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AbsoluteTxPosition {
return new AbsoluteTxPosition().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AbsoluteTxPosition {
return new AbsoluteTxPosition().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AbsoluteTxPosition {
return new AbsoluteTxPosition().fromJsonString(jsonString, options);
}
static equals(a: AbsoluteTxPosition | PlainMessage<AbsoluteTxPosition> | undefined, b: AbsoluteTxPosition | PlainMessage<AbsoluteTxPosition> | undefined): boolean {
return proto3.util.equals(AbsoluteTxPosition, a, b);
}
}
/**
* Model is a struct that holds a KV pair
*
* @generated from message cosmwasm.wasm.v1.Model
*/
export class Model extends Message<Model> {
/**
* hex-encode key to read it better (this is often ascii)
*
* @generated from field: bytes key = 1;
*/
key = new Uint8Array(0);
/**
* base64-encode raw value
*
* @generated from field: bytes value = 2;
*/
value = new Uint8Array(0);
constructor(data?: PartialMessage<Model>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "cosmwasm.wasm.v1.Model";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "key", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "value", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Model {
return new Model().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Model {
return new Model().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Model {
return new Model().fromJsonString(jsonString, options);
}
static equals(a: Model | PlainMessage<Model> | undefined, b: Model | PlainMessage<Model> | undefined): boolean {
return proto3.util.equals(Model, a, b);
}
}

42
libs/es-client/src/protobufs/did/module/v1/module_pb.ts Normal file
View File

@ -0,0 +1,42 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file did/module/v1/module.proto (package did.module.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
/**
* Module is the app config object of the module.
* Learn more: https://docs.cosmos.network/main/building-modules/depinject
*
* @generated from message did.module.v1.Module
*/
export class Module extends Message<Module> {
constructor(data?: PartialMessage<Module>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.module.v1.Module";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Module {
return new Module().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Module {
return new Module().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Module {
return new Module().fromJsonString(jsonString, options);
}
static equals(a: Module | PlainMessage<Module> | undefined, b: Module | PlainMessage<Module> | undefined): boolean {
return proto3.util.equals(Module, a, b);
}
}

312
libs/es-client/src/protobufs/did/v1/genesis_pb.ts Normal file
View File

@ -0,0 +1,312 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file did/v1/genesis.proto (package did.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
/**
* GenesisState defines the module genesis state
*
* @generated from message did.v1.GenesisState
*/
export class GenesisState extends Message<GenesisState> {
/**
* Params defines all the parameters of the module.
*
* @generated from field: did.v1.Params params = 1;
*/
params?: Params;
constructor(data?: PartialMessage<GenesisState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.GenesisState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "params", kind: "message", T: Params },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GenesisState {
return new GenesisState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJsonString(jsonString, options);
}
static equals(a: GenesisState | PlainMessage<GenesisState> | undefined, b: GenesisState | PlainMessage<GenesisState> | undefined): boolean {
return proto3.util.equals(GenesisState, a, b);
}
}
/**
* Params defines the set of module parameters.
*
* @generated from message did.v1.Params
*/
export class Params extends Message<Params> {
/**
* @generated from field: repeated did.v1.Attenuation attenuations = 1;
*/
attenuations: Attenuation[] = [];
constructor(data?: PartialMessage<Params>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.Params";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "attenuations", kind: "message", T: Attenuation, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Params {
return new Params().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Params {
return new Params().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Params {
return new Params().fromJsonString(jsonString, options);
}
static equals(a: Params | PlainMessage<Params> | undefined, b: Params | PlainMessage<Params> | undefined): boolean {
return proto3.util.equals(Params, a, b);
}
}
/**
* Attenuation defines the attenuation of a resource
*
* @generated from message did.v1.Attenuation
*/
export class Attenuation extends Message<Attenuation> {
/**
* @generated from field: did.v1.Resource resource = 1;
*/
resource?: Resource;
/**
* @generated from field: repeated did.v1.Capability capabilities = 2;
*/
capabilities: Capability[] = [];
constructor(data?: PartialMessage<Attenuation>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.Attenuation";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "resource", kind: "message", T: Resource },
{ no: 2, name: "capabilities", kind: "message", T: Capability, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Attenuation {
return new Attenuation().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Attenuation {
return new Attenuation().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Attenuation {
return new Attenuation().fromJsonString(jsonString, options);
}
static equals(a: Attenuation | PlainMessage<Attenuation> | undefined, b: Attenuation | PlainMessage<Attenuation> | undefined): boolean {
return proto3.util.equals(Attenuation, a, b);
}
}
/**
* Capability reprensents the available capabilities of a decentralized web node
*
* @generated from message did.v1.Capability
*/
export class Capability extends Message<Capability> {
/**
* @generated from field: string name = 1;
*/
name = "";
/**
* @generated from field: string parent = 2;
*/
parent = "";
/**
* @generated from field: string description = 3;
*/
description = "";
/**
* @generated from field: repeated string resources = 4;
*/
resources: string[] = [];
constructor(data?: PartialMessage<Capability>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.Capability";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "parent", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "description", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "resources", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Capability {
return new Capability().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Capability {
return new Capability().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Capability {
return new Capability().fromJsonString(jsonString, options);
}
static equals(a: Capability | PlainMessage<Capability> | undefined, b: Capability | PlainMessage<Capability> | undefined): boolean {
return proto3.util.equals(Capability, a, b);
}
}
/**
* Resource reprensents the available resources of a decentralized web node
*
* @generated from message did.v1.Resource
*/
export class Resource extends Message<Resource> {
/**
* @generated from field: string kind = 1;
*/
kind = "";
/**
* @generated from field: string template = 2;
*/
template = "";
constructor(data?: PartialMessage<Resource>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.Resource";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "kind", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "template", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Resource {
return new Resource().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Resource {
return new Resource().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Resource {
return new Resource().fromJsonString(jsonString, options);
}
static equals(a: Resource | PlainMessage<Resource> | undefined, b: Resource | PlainMessage<Resource> | undefined): boolean {
return proto3.util.equals(Resource, a, b);
}
}
/**
* Document defines a DID document
*
* @generated from message did.v1.Document
*/
export class Document extends Message<Document> {
/**
* @generated from field: string id = 1;
*/
id = "";
/**
* The DID of the controller
*
* @generated from field: string controller = 2;
*/
controller = "";
/**
* @generated from field: repeated string authentication = 3;
*/
authentication: string[] = [];
/**
* @generated from field: repeated string assertion_method = 4;
*/
assertionMethod: string[] = [];
/**
* @generated from field: repeated string capability_delegation = 5;
*/
capabilityDelegation: string[] = [];
/**
* @generated from field: repeated string capability_invocation = 6;
*/
capabilityInvocation: string[] = [];
/**
* @generated from field: repeated string service = 7;
*/
service: string[] = [];
constructor(data?: PartialMessage<Document>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.Document";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "controller", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "authentication", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
{ no: 4, name: "assertion_method", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
{ no: 5, name: "capability_delegation", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
{ no: 6, name: "capability_invocation", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
{ no: 7, name: "service", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Document {
return new Document().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Document {
return new Document().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Document {
return new Document().fromJsonString(jsonString, options);
}
static equals(a: Document | PlainMessage<Document> | undefined, b: Document | PlainMessage<Document> | undefined): boolean {
return proto3.util.equals(Document, a, b);
}
}

45
libs/es-client/src/protobufs/did/v1/query_cosmes.ts Normal file
View File

@ -0,0 +1,45 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file did/v1/query.proto (package did.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { QueryParamsResponse, QueryRequest, QueryResolveResponse, QueryVerifyRequest, QueryVerifyResponse } from "./query_pb.js";
const TYPE_NAME = "did.v1.Query";
/**
* Params queries all parameters of the module.
*
* @generated from rpc did.v1.Query.Params
*/
export const QueryParamsService = {
typeName: TYPE_NAME,
method: "Params",
Request: QueryRequest,
Response: QueryParamsResponse,
} as const;
/**
* Resolve queries the DID document by its id.
*
* @generated from rpc did.v1.Query.Resolve
*/
export const QueryResolveService = {
typeName: TYPE_NAME,
method: "Resolve",
Request: QueryRequest,
Response: QueryResolveResponse,
} as const;
/**
* Verify verifies a message with the DID document
*
* @generated from rpc did.v1.Query.Verify
*/
export const QueryVerifyService = {
typeName: TYPE_NAME,
method: "Verify",
Request: QueryVerifyRequest,
Response: QueryVerifyResponse,
} as const;

362
libs/es-client/src/protobufs/did/v1/query_pb.ts Normal file
View File

@ -0,0 +1,362 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file did/v1/query.proto (package did.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { Document, Params } from "./genesis_pb.js";
/**
* Queryequest is the request type for the Query/Params RPC method.
*
* @generated from message did.v1.QueryRequest
*/
export class QueryRequest extends Message<QueryRequest> {
/**
* @generated from field: string did = 1;
*/
did = "";
/**
* @generated from field: string origin = 2;
*/
origin = "";
/**
* @generated from field: string key = 3;
*/
key = "";
/**
* @generated from field: string asset = 4;
*/
asset = "";
constructor(data?: PartialMessage<QueryRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.QueryRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "did", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "origin", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "key", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "asset", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryRequest {
return new QueryRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryRequest {
return new QueryRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryRequest {
return new QueryRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryRequest | PlainMessage<QueryRequest> | undefined, b: QueryRequest | PlainMessage<QueryRequest> | undefined): boolean {
return proto3.util.equals(QueryRequest, a, b);
}
}
/**
* QueryParamsResponse is the response type for the Query/Params RPC method.
*
* @generated from message did.v1.QueryParamsResponse
*/
export class QueryParamsResponse extends Message<QueryParamsResponse> {
/**
* params defines the parameters of the module.
*
* @generated from field: did.v1.Params params = 1;
*/
params?: Params;
constructor(data?: PartialMessage<QueryParamsResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.QueryParamsResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "params", kind: "message", T: Params },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryParamsResponse {
return new QueryParamsResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryParamsResponse {
return new QueryParamsResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryParamsResponse {
return new QueryParamsResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryParamsResponse | PlainMessage<QueryParamsResponse> | undefined, b: QueryParamsResponse | PlainMessage<QueryParamsResponse> | undefined): boolean {
return proto3.util.equals(QueryParamsResponse, a, b);
}
}
/**
* QueryResolveResponse is the response type for the Query/Resolve RPC method.
*
* @generated from message did.v1.QueryResolveResponse
*/
export class QueryResolveResponse extends Message<QueryResolveResponse> {
/**
* document is the DID document
*
* @generated from field: did.v1.Document document = 1;
*/
document?: Document;
constructor(data?: PartialMessage<QueryResolveResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.QueryResolveResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "document", kind: "message", T: Document },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryResolveResponse {
return new QueryResolveResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryResolveResponse {
return new QueryResolveResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryResolveResponse {
return new QueryResolveResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryResolveResponse | PlainMessage<QueryResolveResponse> | undefined, b: QueryResolveResponse | PlainMessage<QueryResolveResponse> | undefined): boolean {
return proto3.util.equals(QueryResolveResponse, a, b);
}
}
/**
* QuerySignRequest is the request type for the Query/Sign RPC method.
*
* @generated from message did.v1.QuerySignRequest
*/
export class QuerySignRequest extends Message<QuerySignRequest> {
/**
* @generated from field: string did = 1;
*/
did = "";
/**
* @generated from field: string origin = 2;
*/
origin = "";
/**
* @generated from field: string key = 3;
*/
key = "";
/**
* @generated from field: string asset = 4;
*/
asset = "";
/**
* @generated from field: string message = 5;
*/
message = "";
constructor(data?: PartialMessage<QuerySignRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.QuerySignRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "did", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "origin", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "key", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "asset", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 5, name: "message", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QuerySignRequest {
return new QuerySignRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QuerySignRequest {
return new QuerySignRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QuerySignRequest {
return new QuerySignRequest().fromJsonString(jsonString, options);
}
static equals(a: QuerySignRequest | PlainMessage<QuerySignRequest> | undefined, b: QuerySignRequest | PlainMessage<QuerySignRequest> | undefined): boolean {
return proto3.util.equals(QuerySignRequest, a, b);
}
}
/**
* QuerySignResponse is the response type for the Query/Sign RPC method.
*
* @generated from message did.v1.QuerySignResponse
*/
export class QuerySignResponse extends Message<QuerySignResponse> {
/**
* signature is the signature of the message
*
* @generated from field: string signature = 1;
*/
signature = "";
constructor(data?: PartialMessage<QuerySignResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.QuerySignResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "signature", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QuerySignResponse {
return new QuerySignResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QuerySignResponse {
return new QuerySignResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QuerySignResponse {
return new QuerySignResponse().fromJsonString(jsonString, options);
}
static equals(a: QuerySignResponse | PlainMessage<QuerySignResponse> | undefined, b: QuerySignResponse | PlainMessage<QuerySignResponse> | undefined): boolean {
return proto3.util.equals(QuerySignResponse, a, b);
}
}
/**
* QueryVerifyRequest is the request type for the Query/Verify RPC method.
*
* @generated from message did.v1.QueryVerifyRequest
*/
export class QueryVerifyRequest extends Message<QueryVerifyRequest> {
/**
* @generated from field: string did = 1;
*/
did = "";
/**
* @generated from field: string origin = 2;
*/
origin = "";
/**
* @generated from field: string key = 3;
*/
key = "";
/**
* @generated from field: string asset = 4;
*/
asset = "";
/**
* @generated from field: string message = 5;
*/
message = "";
/**
* @generated from field: string signature = 6;
*/
signature = "";
constructor(data?: PartialMessage<QueryVerifyRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.QueryVerifyRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "did", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "origin", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "key", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "asset", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 5, name: "message", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 6, name: "signature", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryVerifyRequest {
return new QueryVerifyRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryVerifyRequest {
return new QueryVerifyRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryVerifyRequest {
return new QueryVerifyRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryVerifyRequest | PlainMessage<QueryVerifyRequest> | undefined, b: QueryVerifyRequest | PlainMessage<QueryVerifyRequest> | undefined): boolean {
return proto3.util.equals(QueryVerifyRequest, a, b);
}
}
/**
* QueryVerifyResponse is the response type for the Query/Verify RPC method.
*
* @generated from message did.v1.QueryVerifyResponse
*/
export class QueryVerifyResponse extends Message<QueryVerifyResponse> {
/**
* valid is the validity of the signature
*
* @generated from field: bool valid = 1;
*/
valid = false;
constructor(data?: PartialMessage<QueryVerifyResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.QueryVerifyResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "valid", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryVerifyResponse {
return new QueryVerifyResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryVerifyResponse {
return new QueryVerifyResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryVerifyResponse {
return new QueryVerifyResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryVerifyResponse | PlainMessage<QueryVerifyResponse> | undefined, b: QueryVerifyResponse | PlainMessage<QueryVerifyResponse> | undefined): boolean {
return proto3.util.equals(QueryVerifyResponse, a, b);
}
}

305
libs/es-client/src/protobufs/did/v1/state_pb.ts Normal file
View File

@ -0,0 +1,305 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file did/v1/state.proto (package did.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, protoInt64 } from "@bufbuild/protobuf";
/**
* @generated from message did.v1.Account
*/
export class Account extends Message<Account> {
/**
* The unique identifier of the assertion
*
* @generated from field: string did = 1;
*/
did = "";
/**
* The authentication of the DID
*
* @generated from field: string controller = 2;
*/
controller = "";
/**
* Origin of the authentication
*
* @generated from field: string subject = 3;
*/
subject = "";
/**
* string is the verification method
*
* @generated from field: string public_key_hex = 4;
*/
publicKeyHex = "";
/**
* AssertionType is the assertion type
*
* @generated from field: string assertion_type = 5;
*/
assertionType = "";
/**
* Metadata of the authentication
*
* @generated from field: map<string, bytes> accumulator = 6;
*/
accumulator: { [key: string]: Uint8Array } = {};
/**
* CreationBlock is the block number of the creation of the authentication
*
* @generated from field: int64 creation_block = 7;
*/
creationBlock = protoInt64.zero;
constructor(data?: PartialMessage<Account>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.Account";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "did", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "controller", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "subject", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "public_key_hex", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 5, name: "assertion_type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 6, name: "accumulator", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 12 /* ScalarType.BYTES */} },
{ no: 7, name: "creation_block", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Account {
return new Account().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Account {
return new Account().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Account {
return new Account().fromJsonString(jsonString, options);
}
static equals(a: Account | PlainMessage<Account> | undefined, b: Account | PlainMessage<Account> | undefined): boolean {
return proto3.util.equals(Account, a, b);
}
}
/**
* PublicKey represents a public key
*
* @generated from message did.v1.PublicKey
*/
export class PublicKey extends Message<PublicKey> {
/**
* The unique identifier of the controller
*
* @generated from field: uint64 number = 1;
*/
number = protoInt64.zero;
/**
* The unique identifier of the controller
*
* @generated from field: string did = 2;
*/
did = "";
/**
* The DID of the controller
*
* @generated from field: string sonr_address = 3;
*/
sonrAddress = "";
/**
* The DID of the controller
*
* @generated from field: string eth_address = 4;
*/
ethAddress = "";
/**
* The DID of the controller
*
* @generated from field: string btc_address = 5;
*/
btcAddress = "";
/**
* string is the verification method
*
* @generated from field: string public_key_hex = 6;
*/
publicKeyHex = "";
/**
* Pointer to the Keyshares
*
* @generated from field: string ks_val = 7;
*/
ksVal = "";
/**
* The block number of when a user claimed the controller
*
* @generated from field: int64 claimed_block = 8;
*/
claimedBlock = protoInt64.zero;
/**
* CreationBlock is the block number of the creation of the controller
*
* @generated from field: int64 creation_block = 9;
*/
creationBlock = protoInt64.zero;
constructor(data?: PartialMessage<PublicKey>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.PublicKey";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "number", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 2, name: "did", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "sonr_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "eth_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 5, name: "btc_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 6, name: "public_key_hex", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 7, name: "ks_val", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 8, name: "claimed_block", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
{ no: 9, name: "creation_block", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PublicKey {
return new PublicKey().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PublicKey {
return new PublicKey().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PublicKey {
return new PublicKey().fromJsonString(jsonString, options);
}
static equals(a: PublicKey | PlainMessage<PublicKey> | undefined, b: PublicKey | PlainMessage<PublicKey> | undefined): boolean {
return proto3.util.equals(PublicKey, a, b);
}
}
/**
* Verification represents a verification method
*
* @generated from message did.v1.Verification
*/
export class Verification extends Message<Verification> {
/**
* The unique identifier of the verification
*
* @generated from field: string did = 1;
*/
did = "";
/**
* The controller of the verification
*
* @generated from field: string controller = 2;
*/
controller = "";
/**
* The DIDNamespace of the verification
*
* @generated from field: string did_method = 3;
*/
didMethod = "";
/**
* The value of the linked identifier
*
* @generated from field: string issuer = 4;
*/
issuer = "";
/**
* The subject of the verification
*
* @generated from field: string subject = 5;
*/
subject = "";
/**
* The public key of the verification
*
* @generated from field: string public_key_hex = 6;
*/
publicKeyHex = "";
/**
* The verification method type
*
* @generated from field: string verification_type = 7;
*/
verificationType = "";
/**
* Metadata of the verification
*
* @generated from field: map<string, string> metadata = 8;
*/
metadata: { [key: string]: string } = {};
/**
* CreationBlock is the block number of the creation of the controller
*
* @generated from field: int64 creation_block = 9;
*/
creationBlock = protoInt64.zero;
constructor(data?: PartialMessage<Verification>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.Verification";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "did", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "controller", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "did_method", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "issuer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 5, name: "subject", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 6, name: "public_key_hex", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 7, name: "verification_type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 8, name: "metadata", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} },
{ no: 9, name: "creation_block", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Verification {
return new Verification().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Verification {
return new Verification().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Verification {
return new Verification().fromJsonString(jsonString, options);
}
static equals(a: Verification | PlainMessage<Verification> | undefined, b: Verification | PlainMessage<Verification> | undefined): boolean {
return proto3.util.equals(Verification, a, b);
}
}

82
libs/es-client/src/protobufs/did/v1/tx_cosmes.ts Normal file
View File

@ -0,0 +1,82 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file did/v1/tx.proto (package did.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { MsgExecuteTx, MsgExecuteTxResponse, MsgLinkAssertion, MsgLinkAssertionResponse, MsgLinkAuthentication, MsgLinkAuthenticationResponse, MsgUnlinkAssertion, MsgUnlinkAssertionResponse, MsgUnlinkAuthentication, MsgUnlinkAuthenticationResponse, MsgUpdateParams, MsgUpdateParamsResponse } from "./tx_pb.js";
const TYPE_NAME = "did.v1.Msg";
/**
* ExecuteTx executes a transaction on the Sonr Blockchain. It leverages
* Macaroon for verification.
*
* @generated from rpc did.v1.Msg.ExecuteTx
*/
export const MsgExecuteTxService = {
typeName: TYPE_NAME,
method: "ExecuteTx",
Request: MsgExecuteTx,
Response: MsgExecuteTxResponse,
} as const;
/**
* LinkAssertion links an assertion to a controller.
*
* @generated from rpc did.v1.Msg.LinkAssertion
*/
export const MsgLinkAssertionService = {
typeName: TYPE_NAME,
method: "LinkAssertion",
Request: MsgLinkAssertion,
Response: MsgLinkAssertionResponse,
} as const;
/**
* LinkAuthentication links an authentication to a controller.
*
* @generated from rpc did.v1.Msg.LinkAuthentication
*/
export const MsgLinkAuthenticationService = {
typeName: TYPE_NAME,
method: "LinkAuthentication",
Request: MsgLinkAuthentication,
Response: MsgLinkAuthenticationResponse,
} as const;
/**
* UnlinkAssertion unlinks an assertion from a controller.
*
* @generated from rpc did.v1.Msg.UnlinkAssertion
*/
export const MsgUnlinkAssertionService = {
typeName: TYPE_NAME,
method: "UnlinkAssertion",
Request: MsgUnlinkAssertion,
Response: MsgUnlinkAssertionResponse,
} as const;
/**
* UnlinkAuthentication unlinks an authentication from a controller.
*
* @generated from rpc did.v1.Msg.UnlinkAuthentication
*/
export const MsgUnlinkAuthenticationService = {
typeName: TYPE_NAME,
method: "UnlinkAuthentication",
Request: MsgUnlinkAuthentication,
Response: MsgUnlinkAuthenticationResponse,
} as const;
/**
* UpdateParams defines a governance operation for updating the parameters.
*
* @generated from rpc did.v1.Msg.UpdateParams
*/
export const MsgUpdateParamsService = {
typeName: TYPE_NAME,
method: "UpdateParams",
Request: MsgUpdateParams,
Response: MsgUpdateParamsResponse,
} as const;

662
libs/es-client/src/protobufs/did/v1/tx_pb.ts Normal file
View File

@ -0,0 +1,662 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file did/v1/tx.proto (package did.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { Params } from "./genesis_pb.js";
/**
* MsgLinkAuthentication is the message type for the LinkAuthentication RPC.
*
* @generated from message did.v1.MsgLinkAuthentication
*/
export class MsgLinkAuthentication extends Message<MsgLinkAuthentication> {
/**
* Controller is the address of the controller to authenticate.
*
* @generated from field: string controller = 1;
*/
controller = "";
/**
* Subject is the subject of the authentication.
*
* @generated from field: string subject = 2;
*/
subject = "";
/**
* Assertion is the assertion of the authentication.
*
* @generated from field: string assertion = 3;
*/
assertion = "";
/**
* Authentication is the authentication of the authentication.
*
* @generated from field: bytes credential_id = 4;
*/
credentialId = new Uint8Array(0);
/**
* token is the macron token to authenticate the operation.
*
* @generated from field: string macaroon_token = 5;
*/
macaroonToken = "";
constructor(data?: PartialMessage<MsgLinkAuthentication>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.MsgLinkAuthentication";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "controller", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "subject", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "assertion", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "credential_id", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 5, name: "macaroon_token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgLinkAuthentication {
return new MsgLinkAuthentication().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgLinkAuthentication {
return new MsgLinkAuthentication().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgLinkAuthentication {
return new MsgLinkAuthentication().fromJsonString(jsonString, options);
}
static equals(a: MsgLinkAuthentication | PlainMessage<MsgLinkAuthentication> | undefined, b: MsgLinkAuthentication | PlainMessage<MsgLinkAuthentication> | undefined): boolean {
return proto3.util.equals(MsgLinkAuthentication, a, b);
}
}
/**
* MsgLinkAuthenticationResponse is the response type for the
* LinkAuthentication RPC.
*
* @generated from message did.v1.MsgLinkAuthenticationResponse
*/
export class MsgLinkAuthenticationResponse extends Message<MsgLinkAuthenticationResponse> {
/**
* Success returns true if the specified cid is valid and not already
* encrypted.
*
* @generated from field: bool success = 1;
*/
success = false;
/**
* Controller is the address of the initialized controller.
*
* @generated from field: string did = 2;
*/
did = "";
constructor(data?: PartialMessage<MsgLinkAuthenticationResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.MsgLinkAuthenticationResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "success", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
{ no: 2, name: "did", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgLinkAuthenticationResponse {
return new MsgLinkAuthenticationResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgLinkAuthenticationResponse {
return new MsgLinkAuthenticationResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgLinkAuthenticationResponse {
return new MsgLinkAuthenticationResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgLinkAuthenticationResponse | PlainMessage<MsgLinkAuthenticationResponse> | undefined, b: MsgLinkAuthenticationResponse | PlainMessage<MsgLinkAuthenticationResponse> | undefined): boolean {
return proto3.util.equals(MsgLinkAuthenticationResponse, a, b);
}
}
/**
* MsgLinkAssertion is the message type for the LinkAssertion RPC.
*
* @generated from message did.v1.MsgLinkAssertion
*/
export class MsgLinkAssertion extends Message<MsgLinkAssertion> {
/**
* Controller is the address of the controller to authenticate.
*
* @generated from field: string controller = 1;
*/
controller = "";
/**
* Subject is the subject of the authentication.
*
* @generated from field: string subject = 2;
*/
subject = "";
/**
* Assertion is the assertion of the authentication.
*
* @generated from field: string assertion = 3;
*/
assertion = "";
/**
* token is the macron token to authenticate the operation.
*
* @generated from field: string macaroon_token = 4;
*/
macaroonToken = "";
constructor(data?: PartialMessage<MsgLinkAssertion>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.MsgLinkAssertion";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "controller", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "subject", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "assertion", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "macaroon_token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgLinkAssertion {
return new MsgLinkAssertion().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgLinkAssertion {
return new MsgLinkAssertion().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgLinkAssertion {
return new MsgLinkAssertion().fromJsonString(jsonString, options);
}
static equals(a: MsgLinkAssertion | PlainMessage<MsgLinkAssertion> | undefined, b: MsgLinkAssertion | PlainMessage<MsgLinkAssertion> | undefined): boolean {
return proto3.util.equals(MsgLinkAssertion, a, b);
}
}
/**
* MsgLinkAssertionResponse is the response type for the
* LinkAssertion RPC.
*
* @generated from message did.v1.MsgLinkAssertionResponse
*/
export class MsgLinkAssertionResponse extends Message<MsgLinkAssertionResponse> {
/**
* Success returns true if the specified cid is valid and not already
* encrypted.
*
* @generated from field: bool success = 1;
*/
success = false;
/**
* Controller is the address of the initialized controller.
*
* @generated from field: string did = 2;
*/
did = "";
constructor(data?: PartialMessage<MsgLinkAssertionResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.MsgLinkAssertionResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "success", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
{ no: 2, name: "did", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgLinkAssertionResponse {
return new MsgLinkAssertionResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgLinkAssertionResponse {
return new MsgLinkAssertionResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgLinkAssertionResponse {
return new MsgLinkAssertionResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgLinkAssertionResponse | PlainMessage<MsgLinkAssertionResponse> | undefined, b: MsgLinkAssertionResponse | PlainMessage<MsgLinkAssertionResponse> | undefined): boolean {
return proto3.util.equals(MsgLinkAssertionResponse, a, b);
}
}
/**
* MsgExecuteTx is the message type for the ExecuteTx RPC.
*
* @generated from message did.v1.MsgExecuteTx
*/
export class MsgExecuteTx extends Message<MsgExecuteTx> {
/**
* Controller is the address of the controller to authenticate.
*
* @generated from field: string controller = 1;
*/
controller = "";
/**
* Messages is the list of messages to execute.
*
* @generated from field: map<string, bytes> messages = 2;
*/
messages: { [key: string]: Uint8Array } = {};
/**
* MacaroonToken is the macaroon token to authenticate the operation.
*
* @generated from field: string macaroon_token = 3;
*/
macaroonToken = "";
constructor(data?: PartialMessage<MsgExecuteTx>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.MsgExecuteTx";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "controller", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "messages", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 12 /* ScalarType.BYTES */} },
{ no: 3, name: "macaroon_token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgExecuteTx {
return new MsgExecuteTx().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgExecuteTx {
return new MsgExecuteTx().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgExecuteTx {
return new MsgExecuteTx().fromJsonString(jsonString, options);
}
static equals(a: MsgExecuteTx | PlainMessage<MsgExecuteTx> | undefined, b: MsgExecuteTx | PlainMessage<MsgExecuteTx> | undefined): boolean {
return proto3.util.equals(MsgExecuteTx, a, b);
}
}
/**
* MsgExecuteTxResponse is the response type for the ExecuteTx RPC.
*
* @generated from message did.v1.MsgExecuteTxResponse
*/
export class MsgExecuteTxResponse extends Message<MsgExecuteTxResponse> {
/**
* @generated from field: bool success = 1;
*/
success = false;
/**
* @generated from field: string tx_hash = 2;
*/
txHash = "";
constructor(data?: PartialMessage<MsgExecuteTxResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.MsgExecuteTxResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "success", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
{ no: 2, name: "tx_hash", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgExecuteTxResponse {
return new MsgExecuteTxResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgExecuteTxResponse {
return new MsgExecuteTxResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgExecuteTxResponse {
return new MsgExecuteTxResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgExecuteTxResponse | PlainMessage<MsgExecuteTxResponse> | undefined, b: MsgExecuteTxResponse | PlainMessage<MsgExecuteTxResponse> | undefined): boolean {
return proto3.util.equals(MsgExecuteTxResponse, a, b);
}
}
/**
* MsgUnlinkAssertion is the message type for the UnlinkAssertion RPC.
*
* @generated from message did.v1.MsgUnlinkAssertion
*/
export class MsgUnlinkAssertion extends Message<MsgUnlinkAssertion> {
/**
* Controller is the address of the controller to authenticate.
*
* @generated from field: string controller = 1;
*/
controller = "";
/**
* Assertion is the assertion of the authentication.
*
* @generated from field: string assertion_did = 2;
*/
assertionDid = "";
/**
* token is the macron token to authenticate the operation.
*
* @generated from field: string macaroon_token = 3;
*/
macaroonToken = "";
constructor(data?: PartialMessage<MsgUnlinkAssertion>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.MsgUnlinkAssertion";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "controller", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "assertion_did", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "macaroon_token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgUnlinkAssertion {
return new MsgUnlinkAssertion().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgUnlinkAssertion {
return new MsgUnlinkAssertion().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgUnlinkAssertion {
return new MsgUnlinkAssertion().fromJsonString(jsonString, options);
}
static equals(a: MsgUnlinkAssertion | PlainMessage<MsgUnlinkAssertion> | undefined, b: MsgUnlinkAssertion | PlainMessage<MsgUnlinkAssertion> | undefined): boolean {
return proto3.util.equals(MsgUnlinkAssertion, a, b);
}
}
/**
* MsgUnlinkAssertionResponse is the response type for the
* UnlinkAssertion RPC.
*
* @generated from message did.v1.MsgUnlinkAssertionResponse
*/
export class MsgUnlinkAssertionResponse extends Message<MsgUnlinkAssertionResponse> {
/**
* Success returns true if the specified cid is valid and not already
* encrypted.
*
* @generated from field: bool success = 1;
*/
success = false;
/**
* Controller is the address of the initialized controller.
*
* @generated from field: string did = 2;
*/
did = "";
constructor(data?: PartialMessage<MsgUnlinkAssertionResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.MsgUnlinkAssertionResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "success", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
{ no: 2, name: "did", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgUnlinkAssertionResponse {
return new MsgUnlinkAssertionResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgUnlinkAssertionResponse {
return new MsgUnlinkAssertionResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgUnlinkAssertionResponse {
return new MsgUnlinkAssertionResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgUnlinkAssertionResponse | PlainMessage<MsgUnlinkAssertionResponse> | undefined, b: MsgUnlinkAssertionResponse | PlainMessage<MsgUnlinkAssertionResponse> | undefined): boolean {
return proto3.util.equals(MsgUnlinkAssertionResponse, a, b);
}
}
/**
* MsgUnlinkAuthentication is the message type for the UnlinkAuthentication RPC.
*
* @generated from message did.v1.MsgUnlinkAuthentication
*/
export class MsgUnlinkAuthentication extends Message<MsgUnlinkAuthentication> {
/**
* Controller is the address of the controller to authenticate.
*
* @generated from field: string controller = 1;
*/
controller = "";
/**
* Subject is the subject of the authentication.
*
* @generated from field: string authentication_did = 2;
*/
authenticationDid = "";
/**
* token is the macron token to authenticate the operation.
*
* @generated from field: string macaroon_token = 3;
*/
macaroonToken = "";
constructor(data?: PartialMessage<MsgUnlinkAuthentication>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.MsgUnlinkAuthentication";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "controller", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "authentication_did", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "macaroon_token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgUnlinkAuthentication {
return new MsgUnlinkAuthentication().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgUnlinkAuthentication {
return new MsgUnlinkAuthentication().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgUnlinkAuthentication {
return new MsgUnlinkAuthentication().fromJsonString(jsonString, options);
}
static equals(a: MsgUnlinkAuthentication | PlainMessage<MsgUnlinkAuthentication> | undefined, b: MsgUnlinkAuthentication | PlainMessage<MsgUnlinkAuthentication> | undefined): boolean {
return proto3.util.equals(MsgUnlinkAuthentication, a, b);
}
}
/**
* MsgUnlinkAuthenticationResponse is the response type for the
* UnlinkAuthentication RPC.
*
* @generated from message did.v1.MsgUnlinkAuthenticationResponse
*/
export class MsgUnlinkAuthenticationResponse extends Message<MsgUnlinkAuthenticationResponse> {
/**
* Success returns true if the specified cid is valid and not already
* encrypted.
*
* @generated from field: bool success = 1;
*/
success = false;
/**
* Controller is the address of the initialized controller.
*
* @generated from field: string did = 2;
*/
did = "";
constructor(data?: PartialMessage<MsgUnlinkAuthenticationResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.MsgUnlinkAuthenticationResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "success", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
{ no: 2, name: "did", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgUnlinkAuthenticationResponse {
return new MsgUnlinkAuthenticationResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgUnlinkAuthenticationResponse {
return new MsgUnlinkAuthenticationResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgUnlinkAuthenticationResponse {
return new MsgUnlinkAuthenticationResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgUnlinkAuthenticationResponse | PlainMessage<MsgUnlinkAuthenticationResponse> | undefined, b: MsgUnlinkAuthenticationResponse | PlainMessage<MsgUnlinkAuthenticationResponse> | undefined): boolean {
return proto3.util.equals(MsgUnlinkAuthenticationResponse, a, b);
}
}
/**
* MsgUpdateParams is the Msg/UpdateParams request type.
*
* Since: cosmos-sdk 0.47
*
* @generated from message did.v1.MsgUpdateParams
*/
export class MsgUpdateParams extends Message<MsgUpdateParams> {
/**
* authority is the address of the governance account.
*
* @generated from field: string authority = 1;
*/
authority = "";
/**
* params defines the parameters to update.
*
* @generated from field: did.v1.Params params = 2;
*/
params?: Params;
/**
* token is the macron token to authenticate the operation.
*
* @generated from field: string token = 3;
*/
token = "";
constructor(data?: PartialMessage<MsgUpdateParams>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.MsgUpdateParams";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "authority", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "params", kind: "message", T: Params },
{ no: 3, name: "token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgUpdateParams {
return new MsgUpdateParams().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgUpdateParams {
return new MsgUpdateParams().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgUpdateParams {
return new MsgUpdateParams().fromJsonString(jsonString, options);
}
static equals(a: MsgUpdateParams | PlainMessage<MsgUpdateParams> | undefined, b: MsgUpdateParams | PlainMessage<MsgUpdateParams> | undefined): boolean {
return proto3.util.equals(MsgUpdateParams, a, b);
}
}
/**
* MsgUpdateParamsResponse defines the response structure for executing a
* MsgUpdateParams message.
*
* Since: cosmos-sdk 0.47
*
* @generated from message did.v1.MsgUpdateParamsResponse
*/
export class MsgUpdateParamsResponse extends Message<MsgUpdateParamsResponse> {
constructor(data?: PartialMessage<MsgUpdateParamsResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "did.v1.MsgUpdateParamsResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgUpdateParamsResponse {
return new MsgUpdateParamsResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgUpdateParamsResponse {
return new MsgUpdateParamsResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgUpdateParamsResponse {
return new MsgUpdateParamsResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgUpdateParamsResponse | PlainMessage<MsgUpdateParamsResponse> | undefined, b: MsgUpdateParamsResponse | PlainMessage<MsgUpdateParamsResponse> | undefined): boolean {
return proto3.util.equals(MsgUpdateParamsResponse, a, b);
}
}

42
libs/es-client/src/protobufs/dwn/module/v1/module_pb.ts Normal file
View File

@ -0,0 +1,42 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file dwn/module/v1/module.proto (package dwn.module.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
/**
* Module is the app config object of the module.
* Learn more: https://docs.cosmos.network/main/building-modules/depinject
*
* @generated from message dwn.module.v1.Module
*/
export class Module extends Message<Module> {
constructor(data?: PartialMessage<Module>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "dwn.module.v1.Module";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Module {
return new Module().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Module {
return new Module().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Module {
return new Module().fromJsonString(jsonString, options);
}
static equals(a: Module | PlainMessage<Module> | undefined, b: Module | PlainMessage<Module> | undefined): boolean {
return proto3.util.equals(Module, a, b);
}
}

243
libs/es-client/src/protobufs/dwn/v1/genesis_pb.ts Normal file
View File

@ -0,0 +1,243 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file dwn/v1/genesis.proto (package dwn.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
/**
* GenesisState defines the module genesis state
*
* @generated from message dwn.v1.GenesisState
*/
export class GenesisState extends Message<GenesisState> {
/**
* Params defines all the parameters of the module.
*
* @generated from field: dwn.v1.Params params = 1;
*/
params?: Params;
constructor(data?: PartialMessage<GenesisState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "dwn.v1.GenesisState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "params", kind: "message", T: Params },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GenesisState {
return new GenesisState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJsonString(jsonString, options);
}
static equals(a: GenesisState | PlainMessage<GenesisState> | undefined, b: GenesisState | PlainMessage<GenesisState> | undefined): boolean {
return proto3.util.equals(GenesisState, a, b);
}
}
/**
* Params defines the set of module parameters.
*
* @generated from message dwn.v1.Params
*/
export class Params extends Message<Params> {
/**
* Attenuation defines the available attenuations
*
* @generated from field: repeated dwn.v1.Attenuation attenuations = 1;
*/
attenuations: Attenuation[] = [];
/**
* @generated from field: repeated string allowed_operators = 2;
*/
allowedOperators: string[] = [];
constructor(data?: PartialMessage<Params>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "dwn.v1.Params";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "attenuations", kind: "message", T: Attenuation, repeated: true },
{ no: 2, name: "allowed_operators", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Params {
return new Params().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Params {
return new Params().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Params {
return new Params().fromJsonString(jsonString, options);
}
static equals(a: Params | PlainMessage<Params> | undefined, b: Params | PlainMessage<Params> | undefined): boolean {
return proto3.util.equals(Params, a, b);
}
}
/**
* Attenuation defines the attenuation of a resource
*
* @generated from message dwn.v1.Attenuation
*/
export class Attenuation extends Message<Attenuation> {
/**
* @generated from field: dwn.v1.Resource resource = 1;
*/
resource?: Resource;
/**
* @generated from field: repeated dwn.v1.Capability capabilities = 2;
*/
capabilities: Capability[] = [];
constructor(data?: PartialMessage<Attenuation>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "dwn.v1.Attenuation";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "resource", kind: "message", T: Resource },
{ no: 2, name: "capabilities", kind: "message", T: Capability, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Attenuation {
return new Attenuation().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Attenuation {
return new Attenuation().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Attenuation {
return new Attenuation().fromJsonString(jsonString, options);
}
static equals(a: Attenuation | PlainMessage<Attenuation> | undefined, b: Attenuation | PlainMessage<Attenuation> | undefined): boolean {
return proto3.util.equals(Attenuation, a, b);
}
}
/**
* Capability reprensents the available capabilities of a decentralized web node
*
* @generated from message dwn.v1.Capability
*/
export class Capability extends Message<Capability> {
/**
* @generated from field: string name = 1;
*/
name = "";
/**
* @generated from field: string parent = 2;
*/
parent = "";
/**
* @generated from field: string description = 3;
*/
description = "";
/**
* @generated from field: repeated string resources = 4;
*/
resources: string[] = [];
constructor(data?: PartialMessage<Capability>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "dwn.v1.Capability";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "parent", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "description", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "resources", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Capability {
return new Capability().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Capability {
return new Capability().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Capability {
return new Capability().fromJsonString(jsonString, options);
}
static equals(a: Capability | PlainMessage<Capability> | undefined, b: Capability | PlainMessage<Capability> | undefined): boolean {
return proto3.util.equals(Capability, a, b);
}
}
/**
* Resource reprensents the available resources of a decentralized web node
*
* @generated from message dwn.v1.Resource
*/
export class Resource extends Message<Resource> {
/**
* @generated from field: string kind = 1;
*/
kind = "";
/**
* @generated from field: string template = 2;
*/
template = "";
constructor(data?: PartialMessage<Resource>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "dwn.v1.Resource";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "kind", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "template", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Resource {
return new Resource().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Resource {
return new Resource().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Resource {
return new Resource().fromJsonString(jsonString, options);
}
static equals(a: Resource | PlainMessage<Resource> | undefined, b: Resource | PlainMessage<Resource> | undefined): boolean {
return proto3.util.equals(Resource, a, b);
}
}

21
libs/es-client/src/protobufs/dwn/v1/query_cosmes.ts Normal file
View File

@ -0,0 +1,21 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file dwn/v1/query.proto (package dwn.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { QueryParamsRequest, QueryParamsResponse } from "./query_pb.js";
const TYPE_NAME = "dwn.v1.Query";
/**
* Params queries all parameters of the module.
*
* @generated from rpc dwn.v1.Query.Params
*/
export const QueryParamsService = {
typeName: TYPE_NAME,
method: "Params",
Request: QueryParamsRequest,
Response: QueryParamsResponse,
} as const;

83
libs/es-client/src/protobufs/dwn/v1/query_pb.ts Normal file
View File

@ -0,0 +1,83 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file dwn/v1/query.proto (package dwn.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { Params } from "./genesis_pb.js";
/**
* QueryParamsRequest is the request type for the Query/Params RPC method.
*
* @generated from message dwn.v1.QueryParamsRequest
*/
export class QueryParamsRequest extends Message<QueryParamsRequest> {
constructor(data?: PartialMessage<QueryParamsRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "dwn.v1.QueryParamsRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryParamsRequest {
return new QueryParamsRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryParamsRequest {
return new QueryParamsRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryParamsRequest {
return new QueryParamsRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryParamsRequest | PlainMessage<QueryParamsRequest> | undefined, b: QueryParamsRequest | PlainMessage<QueryParamsRequest> | undefined): boolean {
return proto3.util.equals(QueryParamsRequest, a, b);
}
}
/**
* QueryParamsResponse is the response type for the Query/Params RPC method.
*
* @generated from message dwn.v1.QueryParamsResponse
*/
export class QueryParamsResponse extends Message<QueryParamsResponse> {
/**
* params defines the parameters of the module.
*
* @generated from field: dwn.v1.Params params = 1;
*/
params?: Params;
constructor(data?: PartialMessage<QueryParamsResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "dwn.v1.QueryParamsResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "params", kind: "message", T: Params },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryParamsResponse {
return new QueryParamsResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryParamsResponse {
return new QueryParamsResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryParamsResponse {
return new QueryParamsResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryParamsResponse | PlainMessage<QueryParamsResponse> | undefined, b: QueryParamsResponse | PlainMessage<QueryParamsResponse> | undefined): boolean {
return proto3.util.equals(QueryParamsResponse, a, b);
}
}

130
libs/es-client/src/protobufs/dwn/v1/state_pb.ts Normal file
View File

@ -0,0 +1,130 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file dwn/v1/state.proto (package dwn.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, protoInt64 } from "@bufbuild/protobuf";
/**
* @generated from message dwn.v1.Credential
*/
export class Credential extends Message<Credential> {
/**
* The credential ID as a byte array
*
* @generated from field: bytes id = 1;
*/
id = new Uint8Array(0);
/**
* The credential type (e.g. "public-key")
*
* @generated from field: string kind = 2;
*/
kind = "";
/**
* Optional transport hints (usb, nfc, ble, internal)
*
* @generated from field: repeated string transports = 3;
*/
transports: string[] = [];
/**
* The credential's public key
*
* @generated from field: bytes public_key = 4;
*/
publicKey = new Uint8Array(0);
/**
* The attestation type used (e.g. "none", "indirect", etc)
*
* @generated from field: string attestation_type = 5;
*/
attestationType = "";
/**
* Timestamp of when the credential was created
*
* @generated from field: uint64 created_at = 6;
*/
createdAt = protoInt64.zero;
constructor(data?: PartialMessage<Credential>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "dwn.v1.Credential";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "id", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "kind", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "transports", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
{ no: 4, name: "public_key", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 5, name: "attestation_type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 6, name: "created_at", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Credential {
return new Credential().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Credential {
return new Credential().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Credential {
return new Credential().fromJsonString(jsonString, options);
}
static equals(a: Credential | PlainMessage<Credential> | undefined, b: Credential | PlainMessage<Credential> | undefined): boolean {
return proto3.util.equals(Credential, a, b);
}
}
/**
* @generated from message dwn.v1.Profile
*/
export class Profile extends Message<Profile> {
/**
* @generated from field: bytes account = 1;
*/
account = new Uint8Array(0);
/**
* @generated from field: uint64 amount = 2;
*/
amount = protoInt64.zero;
constructor(data?: PartialMessage<Profile>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "dwn.v1.Profile";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "account", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "amount", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Profile {
return new Profile().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Profile {
return new Profile().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Profile {
return new Profile().fromJsonString(jsonString, options);
}
static equals(a: Profile | PlainMessage<Profile> | undefined, b: Profile | PlainMessage<Profile> | undefined): boolean {
return proto3.util.equals(Profile, a, b);
}
}

35
libs/es-client/src/protobufs/dwn/v1/tx_cosmes.ts Normal file
View File

@ -0,0 +1,35 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file dwn/v1/tx.proto (package dwn.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { MsgInitialize, MsgInitializeResponse, MsgUpdateParams, MsgUpdateParamsResponse } from "./tx_pb.js";
const TYPE_NAME = "dwn.v1.Msg";
/**
* UpdateParams defines a governance operation for updating the parameters.
*
* Since: cosmos-sdk 0.47
*
* @generated from rpc dwn.v1.Msg.UpdateParams
*/
export const MsgUpdateParamsService = {
typeName: TYPE_NAME,
method: "UpdateParams",
Request: MsgUpdateParams,
Response: MsgUpdateParamsResponse,
} as const;
/**
* Spawn spawns a new Vault
*
* @generated from rpc dwn.v1.Msg.Initialize
*/
export const MsgInitializeService = {
typeName: TYPE_NAME,
method: "Initialize",
Request: MsgInitialize,
Response: MsgInitializeResponse,
} as const;

188
libs/es-client/src/protobufs/dwn/v1/tx_pb.ts Normal file
View File

@ -0,0 +1,188 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file dwn/v1/tx.proto (package dwn.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { Params } from "./genesis_pb.js";
/**
* MsgUpdateParams is the Msg/UpdateParams request type.
*
* Since: cosmos-sdk 0.47
*
* @generated from message dwn.v1.MsgUpdateParams
*/
export class MsgUpdateParams extends Message<MsgUpdateParams> {
/**
* authority is the address of the governance account.
*
* @generated from field: string authority = 1;
*/
authority = "";
/**
* params defines the parameters to update.
*
* NOTE: All parameters must be supplied.
*
* @generated from field: dwn.v1.Params params = 2;
*/
params?: Params;
constructor(data?: PartialMessage<MsgUpdateParams>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "dwn.v1.MsgUpdateParams";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "authority", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "params", kind: "message", T: Params },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgUpdateParams {
return new MsgUpdateParams().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgUpdateParams {
return new MsgUpdateParams().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgUpdateParams {
return new MsgUpdateParams().fromJsonString(jsonString, options);
}
static equals(a: MsgUpdateParams | PlainMessage<MsgUpdateParams> | undefined, b: MsgUpdateParams | PlainMessage<MsgUpdateParams> | undefined): boolean {
return proto3.util.equals(MsgUpdateParams, a, b);
}
}
/**
* MsgUpdateParamsResponse defines the response structure for executing a
* MsgUpdateParams message.
*
* Since: cosmos-sdk 0.47
*
* @generated from message dwn.v1.MsgUpdateParamsResponse
*/
export class MsgUpdateParamsResponse extends Message<MsgUpdateParamsResponse> {
constructor(data?: PartialMessage<MsgUpdateParamsResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "dwn.v1.MsgUpdateParamsResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgUpdateParamsResponse {
return new MsgUpdateParamsResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgUpdateParamsResponse {
return new MsgUpdateParamsResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgUpdateParamsResponse {
return new MsgUpdateParamsResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgUpdateParamsResponse | PlainMessage<MsgUpdateParamsResponse> | undefined, b: MsgUpdateParamsResponse | PlainMessage<MsgUpdateParamsResponse> | undefined): boolean {
return proto3.util.equals(MsgUpdateParamsResponse, a, b);
}
}
/**
* MsgSpawn spawns a New Vault with Unclaimed State. This is a one-time
* operation that must be performed interacting with the Vault.
*
* Since: cosmos-sdk 0.47
*
* @generated from message dwn.v1.MsgInitialize
*/
export class MsgInitialize extends Message<MsgInitialize> {
/**
* authority is the address of the governance account.
*
* @generated from field: string authority = 1;
*/
authority = "";
/**
* params defines the parameters to update.
*
* NOTE: All parameters must be supplied.
*
* @generated from field: dwn.v1.Params params = 2;
*/
params?: Params;
constructor(data?: PartialMessage<MsgInitialize>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "dwn.v1.MsgInitialize";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "authority", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "params", kind: "message", T: Params },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgInitialize {
return new MsgInitialize().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgInitialize {
return new MsgInitialize().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgInitialize {
return new MsgInitialize().fromJsonString(jsonString, options);
}
static equals(a: MsgInitialize | PlainMessage<MsgInitialize> | undefined, b: MsgInitialize | PlainMessage<MsgInitialize> | undefined): boolean {
return proto3.util.equals(MsgInitialize, a, b);
}
}
/**
* MsgSpawnResponse defines the response structure for executing a
* MsgSpawn message.
*
* Since: cosmos-sdk 0.47
*
* @generated from message dwn.v1.MsgInitializeResponse
*/
export class MsgInitializeResponse extends Message<MsgInitializeResponse> {
constructor(data?: PartialMessage<MsgInitializeResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "dwn.v1.MsgInitializeResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgInitializeResponse {
return new MsgInitializeResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgInitializeResponse {
return new MsgInitializeResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgInitializeResponse {
return new MsgInitializeResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgInitializeResponse | PlainMessage<MsgInitializeResponse> | undefined, b: MsgInitializeResponse | PlainMessage<MsgInitializeResponse> | undefined): boolean {
return proto3.util.equals(MsgInitializeResponse, a, b);
}
}

65
libs/es-client/src/protobufs/ibc/applications/fee/v1/ack_pb.ts Normal file
View File

@ -0,0 +1,65 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/fee/v1/ack.proto (package ibc.applications.fee.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
/**
* IncentivizedAcknowledgement is the acknowledgement format to be used by applications wrapped in the fee middleware
*
* @generated from message ibc.applications.fee.v1.IncentivizedAcknowledgement
*/
export class IncentivizedAcknowledgement extends Message<IncentivizedAcknowledgement> {
/**
* the underlying app acknowledgement bytes
*
* @generated from field: bytes app_acknowledgement = 1;
*/
appAcknowledgement = new Uint8Array(0);
/**
* the relayer address which submits the recv packet message
*
* @generated from field: string forward_relayer_address = 2;
*/
forwardRelayerAddress = "";
/**
* success flag of the base application callback
*
* @generated from field: bool underlying_app_success = 3;
*/
underlyingAppSuccess = false;
constructor(data?: PartialMessage<IncentivizedAcknowledgement>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.IncentivizedAcknowledgement";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "app_acknowledgement", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "forward_relayer_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "underlying_app_success", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): IncentivizedAcknowledgement {
return new IncentivizedAcknowledgement().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): IncentivizedAcknowledgement {
return new IncentivizedAcknowledgement().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): IncentivizedAcknowledgement {
return new IncentivizedAcknowledgement().fromJsonString(jsonString, options);
}
static equals(a: IncentivizedAcknowledgement | PlainMessage<IncentivizedAcknowledgement> | undefined, b: IncentivizedAcknowledgement | PlainMessage<IncentivizedAcknowledgement> | undefined): boolean {
return proto3.util.equals(IncentivizedAcknowledgement, a, b);
}
}

214
libs/es-client/src/protobufs/ibc/applications/fee/v1/fee_pb.ts Normal file
View File

@ -0,0 +1,214 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/fee/v1/fee.proto (package ibc.applications.fee.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { Coin } from "../../../../cosmos/base/v1beta1/coin_pb.js";
import { PacketId } from "../../../core/channel/v1/channel_pb.js";
/**
* Fee defines the ICS29 receive, acknowledgement and timeout fees
*
* @generated from message ibc.applications.fee.v1.Fee
*/
export class Fee extends Message<Fee> {
/**
* the packet receive fee
*
* @generated from field: repeated cosmos.base.v1beta1.Coin recv_fee = 1;
*/
recvFee: Coin[] = [];
/**
* the packet acknowledgement fee
*
* @generated from field: repeated cosmos.base.v1beta1.Coin ack_fee = 2;
*/
ackFee: Coin[] = [];
/**
* the packet timeout fee
*
* @generated from field: repeated cosmos.base.v1beta1.Coin timeout_fee = 3;
*/
timeoutFee: Coin[] = [];
constructor(data?: PartialMessage<Fee>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.Fee";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "recv_fee", kind: "message", T: Coin, repeated: true },
{ no: 2, name: "ack_fee", kind: "message", T: Coin, repeated: true },
{ no: 3, name: "timeout_fee", kind: "message", T: Coin, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Fee {
return new Fee().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Fee {
return new Fee().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Fee {
return new Fee().fromJsonString(jsonString, options);
}
static equals(a: Fee | PlainMessage<Fee> | undefined, b: Fee | PlainMessage<Fee> | undefined): boolean {
return proto3.util.equals(Fee, a, b);
}
}
/**
* PacketFee contains ICS29 relayer fees, refund address and optional list of permitted relayers
*
* @generated from message ibc.applications.fee.v1.PacketFee
*/
export class PacketFee extends Message<PacketFee> {
/**
* fee encapsulates the recv, ack and timeout fees associated with an IBC packet
*
* @generated from field: ibc.applications.fee.v1.Fee fee = 1;
*/
fee?: Fee;
/**
* the refund address for unspent fees
*
* @generated from field: string refund_address = 2;
*/
refundAddress = "";
/**
* optional list of relayers permitted to receive fees
*
* @generated from field: repeated string relayers = 3;
*/
relayers: string[] = [];
constructor(data?: PartialMessage<PacketFee>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.PacketFee";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "fee", kind: "message", T: Fee },
{ no: 2, name: "refund_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "relayers", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PacketFee {
return new PacketFee().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PacketFee {
return new PacketFee().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PacketFee {
return new PacketFee().fromJsonString(jsonString, options);
}
static equals(a: PacketFee | PlainMessage<PacketFee> | undefined, b: PacketFee | PlainMessage<PacketFee> | undefined): boolean {
return proto3.util.equals(PacketFee, a, b);
}
}
/**
* PacketFees contains a list of type PacketFee
*
* @generated from message ibc.applications.fee.v1.PacketFees
*/
export class PacketFees extends Message<PacketFees> {
/**
* list of packet fees
*
* @generated from field: repeated ibc.applications.fee.v1.PacketFee packet_fees = 1;
*/
packetFees: PacketFee[] = [];
constructor(data?: PartialMessage<PacketFees>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.PacketFees";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "packet_fees", kind: "message", T: PacketFee, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PacketFees {
return new PacketFees().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PacketFees {
return new PacketFees().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PacketFees {
return new PacketFees().fromJsonString(jsonString, options);
}
static equals(a: PacketFees | PlainMessage<PacketFees> | undefined, b: PacketFees | PlainMessage<PacketFees> | undefined): boolean {
return proto3.util.equals(PacketFees, a, b);
}
}
/**
* IdentifiedPacketFees contains a list of type PacketFee and associated PacketId
*
* @generated from message ibc.applications.fee.v1.IdentifiedPacketFees
*/
export class IdentifiedPacketFees extends Message<IdentifiedPacketFees> {
/**
* unique packet identifier comprised of the channel ID, port ID and sequence
*
* @generated from field: ibc.core.channel.v1.PacketId packet_id = 1;
*/
packetId?: PacketId;
/**
* list of packet fees
*
* @generated from field: repeated ibc.applications.fee.v1.PacketFee packet_fees = 2;
*/
packetFees: PacketFee[] = [];
constructor(data?: PartialMessage<IdentifiedPacketFees>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.IdentifiedPacketFees";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "packet_id", kind: "message", T: PacketId },
{ no: 2, name: "packet_fees", kind: "message", T: PacketFee, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): IdentifiedPacketFees {
return new IdentifiedPacketFees().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): IdentifiedPacketFees {
return new IdentifiedPacketFees().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): IdentifiedPacketFees {
return new IdentifiedPacketFees().fromJsonString(jsonString, options);
}
static equals(a: IdentifiedPacketFees | PlainMessage<IdentifiedPacketFees> | undefined, b: IdentifiedPacketFees | PlainMessage<IdentifiedPacketFees> | undefined): boolean {
return proto3.util.equals(IdentifiedPacketFees, a, b);
}
}

296
libs/es-client/src/protobufs/ibc/applications/fee/v1/genesis_pb.ts Normal file
View File

@ -0,0 +1,296 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/fee/v1/genesis.proto (package ibc.applications.fee.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { IdentifiedPacketFees } from "./fee_pb.js";
import { PacketId } from "../../../core/channel/v1/channel_pb.js";
/**
* GenesisState defines the ICS29 fee middleware genesis state
*
* @generated from message ibc.applications.fee.v1.GenesisState
*/
export class GenesisState extends Message<GenesisState> {
/**
* list of identified packet fees
*
* @generated from field: repeated ibc.applications.fee.v1.IdentifiedPacketFees identified_fees = 1;
*/
identifiedFees: IdentifiedPacketFees[] = [];
/**
* list of fee enabled channels
*
* @generated from field: repeated ibc.applications.fee.v1.FeeEnabledChannel fee_enabled_channels = 2;
*/
feeEnabledChannels: FeeEnabledChannel[] = [];
/**
* list of registered payees
*
* @generated from field: repeated ibc.applications.fee.v1.RegisteredPayee registered_payees = 3;
*/
registeredPayees: RegisteredPayee[] = [];
/**
* list of registered counterparty payees
*
* @generated from field: repeated ibc.applications.fee.v1.RegisteredCounterpartyPayee registered_counterparty_payees = 4;
*/
registeredCounterpartyPayees: RegisteredCounterpartyPayee[] = [];
/**
* list of forward relayer addresses
*
* @generated from field: repeated ibc.applications.fee.v1.ForwardRelayerAddress forward_relayers = 5;
*/
forwardRelayers: ForwardRelayerAddress[] = [];
constructor(data?: PartialMessage<GenesisState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.GenesisState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "identified_fees", kind: "message", T: IdentifiedPacketFees, repeated: true },
{ no: 2, name: "fee_enabled_channels", kind: "message", T: FeeEnabledChannel, repeated: true },
{ no: 3, name: "registered_payees", kind: "message", T: RegisteredPayee, repeated: true },
{ no: 4, name: "registered_counterparty_payees", kind: "message", T: RegisteredCounterpartyPayee, repeated: true },
{ no: 5, name: "forward_relayers", kind: "message", T: ForwardRelayerAddress, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GenesisState {
return new GenesisState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJsonString(jsonString, options);
}
static equals(a: GenesisState | PlainMessage<GenesisState> | undefined, b: GenesisState | PlainMessage<GenesisState> | undefined): boolean {
return proto3.util.equals(GenesisState, a, b);
}
}
/**
* FeeEnabledChannel contains the PortID & ChannelID for a fee enabled channel
*
* @generated from message ibc.applications.fee.v1.FeeEnabledChannel
*/
export class FeeEnabledChannel extends Message<FeeEnabledChannel> {
/**
* unique port identifier
*
* @generated from field: string port_id = 1;
*/
portId = "";
/**
* unique channel identifier
*
* @generated from field: string channel_id = 2;
*/
channelId = "";
constructor(data?: PartialMessage<FeeEnabledChannel>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.FeeEnabledChannel";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "port_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "channel_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FeeEnabledChannel {
return new FeeEnabledChannel().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FeeEnabledChannel {
return new FeeEnabledChannel().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FeeEnabledChannel {
return new FeeEnabledChannel().fromJsonString(jsonString, options);
}
static equals(a: FeeEnabledChannel | PlainMessage<FeeEnabledChannel> | undefined, b: FeeEnabledChannel | PlainMessage<FeeEnabledChannel> | undefined): boolean {
return proto3.util.equals(FeeEnabledChannel, a, b);
}
}
/**
* RegisteredPayee contains the relayer address and payee address for a specific channel
*
* @generated from message ibc.applications.fee.v1.RegisteredPayee
*/
export class RegisteredPayee extends Message<RegisteredPayee> {
/**
* unique channel identifier
*
* @generated from field: string channel_id = 1;
*/
channelId = "";
/**
* the relayer address
*
* @generated from field: string relayer = 2;
*/
relayer = "";
/**
* the payee address
*
* @generated from field: string payee = 3;
*/
payee = "";
constructor(data?: PartialMessage<RegisteredPayee>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.RegisteredPayee";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "channel_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "relayer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "payee", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RegisteredPayee {
return new RegisteredPayee().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RegisteredPayee {
return new RegisteredPayee().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RegisteredPayee {
return new RegisteredPayee().fromJsonString(jsonString, options);
}
static equals(a: RegisteredPayee | PlainMessage<RegisteredPayee> | undefined, b: RegisteredPayee | PlainMessage<RegisteredPayee> | undefined): boolean {
return proto3.util.equals(RegisteredPayee, a, b);
}
}
/**
* RegisteredCounterpartyPayee contains the relayer address and counterparty payee address for a specific channel (used
* for recv fee distribution)
*
* @generated from message ibc.applications.fee.v1.RegisteredCounterpartyPayee
*/
export class RegisteredCounterpartyPayee extends Message<RegisteredCounterpartyPayee> {
/**
* unique channel identifier
*
* @generated from field: string channel_id = 1;
*/
channelId = "";
/**
* the relayer address
*
* @generated from field: string relayer = 2;
*/
relayer = "";
/**
* the counterparty payee address
*
* @generated from field: string counterparty_payee = 3;
*/
counterpartyPayee = "";
constructor(data?: PartialMessage<RegisteredCounterpartyPayee>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.RegisteredCounterpartyPayee";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "channel_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "relayer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "counterparty_payee", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RegisteredCounterpartyPayee {
return new RegisteredCounterpartyPayee().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RegisteredCounterpartyPayee {
return new RegisteredCounterpartyPayee().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RegisteredCounterpartyPayee {
return new RegisteredCounterpartyPayee().fromJsonString(jsonString, options);
}
static equals(a: RegisteredCounterpartyPayee | PlainMessage<RegisteredCounterpartyPayee> | undefined, b: RegisteredCounterpartyPayee | PlainMessage<RegisteredCounterpartyPayee> | undefined): boolean {
return proto3.util.equals(RegisteredCounterpartyPayee, a, b);
}
}
/**
* ForwardRelayerAddress contains the forward relayer address and PacketId used for async acknowledgements
*
* @generated from message ibc.applications.fee.v1.ForwardRelayerAddress
*/
export class ForwardRelayerAddress extends Message<ForwardRelayerAddress> {
/**
* the forward relayer address
*
* @generated from field: string address = 1;
*/
address = "";
/**
* unique packet identifier comprised of the channel ID, port ID and sequence
*
* @generated from field: ibc.core.channel.v1.PacketId packet_id = 2;
*/
packetId?: PacketId;
constructor(data?: PartialMessage<ForwardRelayerAddress>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.ForwardRelayerAddress";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "packet_id", kind: "message", T: PacketId },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ForwardRelayerAddress {
return new ForwardRelayerAddress().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ForwardRelayerAddress {
return new ForwardRelayerAddress().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ForwardRelayerAddress {
return new ForwardRelayerAddress().fromJsonString(jsonString, options);
}
static equals(a: ForwardRelayerAddress | PlainMessage<ForwardRelayerAddress> | undefined, b: ForwardRelayerAddress | PlainMessage<ForwardRelayerAddress> | undefined): boolean {
return proto3.util.equals(ForwardRelayerAddress, a, b);
}
}

58
libs/es-client/src/protobufs/ibc/applications/fee/v1/metadata_pb.ts Normal file
View File

@ -0,0 +1,58 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/fee/v1/metadata.proto (package ibc.applications.fee.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
/**
* Metadata defines the ICS29 channel specific metadata encoded into the channel version bytestring
* See ICS004: https://github.com/cosmos/ibc/tree/master/spec/core/ics-004-channel-and-packet-semantics#Versioning
*
* @generated from message ibc.applications.fee.v1.Metadata
*/
export class Metadata extends Message<Metadata> {
/**
* fee_version defines the ICS29 fee version
*
* @generated from field: string fee_version = 1;
*/
feeVersion = "";
/**
* app_version defines the underlying application version, which may or may not be a JSON encoded bytestring
*
* @generated from field: string app_version = 2;
*/
appVersion = "";
constructor(data?: PartialMessage<Metadata>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.Metadata";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "fee_version", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "app_version", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Metadata {
return new Metadata().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Metadata {
return new Metadata().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Metadata {
return new Metadata().fromJsonString(jsonString, options);
}
static equals(a: Metadata | PlainMessage<Metadata> | undefined, b: Metadata | PlainMessage<Metadata> | undefined): boolean {
return proto3.util.equals(Metadata, a, b);
}
}

129
libs/es-client/src/protobufs/ibc/applications/fee/v1/query_cosmes.ts Normal file
View File

@ -0,0 +1,129 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file ibc/applications/fee/v1/query.proto (package ibc.applications.fee.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { QueryCounterpartyPayeeRequest, QueryCounterpartyPayeeResponse, QueryFeeEnabledChannelRequest, QueryFeeEnabledChannelResponse, QueryFeeEnabledChannelsRequest, QueryFeeEnabledChannelsResponse, QueryIncentivizedPacketRequest, QueryIncentivizedPacketResponse, QueryIncentivizedPacketsForChannelRequest, QueryIncentivizedPacketsForChannelResponse, QueryIncentivizedPacketsRequest, QueryIncentivizedPacketsResponse, QueryPayeeRequest, QueryPayeeResponse, QueryTotalAckFeesRequest, QueryTotalAckFeesResponse, QueryTotalRecvFeesRequest, QueryTotalRecvFeesResponse, QueryTotalTimeoutFeesRequest, QueryTotalTimeoutFeesResponse } from "./query_pb.js";
const TYPE_NAME = "ibc.applications.fee.v1.Query";
/**
* IncentivizedPackets returns all incentivized packets and their associated fees
*
* @generated from rpc ibc.applications.fee.v1.Query.IncentivizedPackets
*/
export const QueryIncentivizedPacketsService = {
typeName: TYPE_NAME,
method: "IncentivizedPackets",
Request: QueryIncentivizedPacketsRequest,
Response: QueryIncentivizedPacketsResponse,
} as const;
/**
* IncentivizedPacket returns all packet fees for a packet given its identifier
*
* @generated from rpc ibc.applications.fee.v1.Query.IncentivizedPacket
*/
export const QueryIncentivizedPacketService = {
typeName: TYPE_NAME,
method: "IncentivizedPacket",
Request: QueryIncentivizedPacketRequest,
Response: QueryIncentivizedPacketResponse,
} as const;
/**
* IncentivizedPacketsForChannel retrieves all incentivized packets for a specific channel
*
* @generated from rpc ibc.applications.fee.v1.Query.IncentivizedPacketsForChannel
*/
export const QueryIncentivizedPacketsForChannelService = {
typeName: TYPE_NAME,
method: "IncentivizedPacketsForChannel",
Request: QueryIncentivizedPacketsForChannelRequest,
Response: QueryIncentivizedPacketsForChannelResponse,
} as const;
/**
* TotalRecvFees returns the total receive fees for a packet given its identifier
*
* @generated from rpc ibc.applications.fee.v1.Query.TotalRecvFees
*/
export const QueryTotalRecvFeesService = {
typeName: TYPE_NAME,
method: "TotalRecvFees",
Request: QueryTotalRecvFeesRequest,
Response: QueryTotalRecvFeesResponse,
} as const;
/**
* TotalAckFees returns the total acknowledgement fees for a packet given its identifier
*
* @generated from rpc ibc.applications.fee.v1.Query.TotalAckFees
*/
export const QueryTotalAckFeesService = {
typeName: TYPE_NAME,
method: "TotalAckFees",
Request: QueryTotalAckFeesRequest,
Response: QueryTotalAckFeesResponse,
} as const;
/**
* TotalTimeoutFees returns the total timeout fees for a packet given its identifier
*
* @generated from rpc ibc.applications.fee.v1.Query.TotalTimeoutFees
*/
export const QueryTotalTimeoutFeesService = {
typeName: TYPE_NAME,
method: "TotalTimeoutFees",
Request: QueryTotalTimeoutFeesRequest,
Response: QueryTotalTimeoutFeesResponse,
} as const;
/**
* Payee returns the registered payee address for a specific channel given the relayer address
*
* @generated from rpc ibc.applications.fee.v1.Query.Payee
*/
export const QueryPayeeService = {
typeName: TYPE_NAME,
method: "Payee",
Request: QueryPayeeRequest,
Response: QueryPayeeResponse,
} as const;
/**
* CounterpartyPayee returns the registered counterparty payee for forward relaying
*
* @generated from rpc ibc.applications.fee.v1.Query.CounterpartyPayee
*/
export const QueryCounterpartyPayeeService = {
typeName: TYPE_NAME,
method: "CounterpartyPayee",
Request: QueryCounterpartyPayeeRequest,
Response: QueryCounterpartyPayeeResponse,
} as const;
/**
* FeeEnabledChannels returns a list of all fee enabled channels
*
* @generated from rpc ibc.applications.fee.v1.Query.FeeEnabledChannels
*/
export const QueryFeeEnabledChannelsService = {
typeName: TYPE_NAME,
method: "FeeEnabledChannels",
Request: QueryFeeEnabledChannelsRequest,
Response: QueryFeeEnabledChannelsResponse,
} as const;
/**
* FeeEnabledChannel returns true if the provided port and channel identifiers belong to a fee enabled channel
*
* @generated from rpc ibc.applications.fee.v1.Query.FeeEnabledChannel
*/
export const QueryFeeEnabledChannelService = {
typeName: TYPE_NAME,
method: "FeeEnabledChannel",
Request: QueryFeeEnabledChannelRequest,
Response: QueryFeeEnabledChannelResponse,
} as const;

927
libs/es-client/src/protobufs/ibc/applications/fee/v1/query_pb.ts Normal file
View File

@ -0,0 +1,927 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/fee/v1/query.proto (package ibc.applications.fee.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, protoInt64 } from "@bufbuild/protobuf";
import { PageRequest, PageResponse } from "../../../../cosmos/base/query/v1beta1/pagination_pb.js";
import { IdentifiedPacketFees } from "./fee_pb.js";
import { PacketId } from "../../../core/channel/v1/channel_pb.js";
import { Coin } from "../../../../cosmos/base/v1beta1/coin_pb.js";
import { FeeEnabledChannel } from "./genesis_pb.js";
/**
* QueryIncentivizedPacketsRequest defines the request type for the IncentivizedPackets rpc
*
* @generated from message ibc.applications.fee.v1.QueryIncentivizedPacketsRequest
*/
export class QueryIncentivizedPacketsRequest extends Message<QueryIncentivizedPacketsRequest> {
/**
* pagination defines an optional pagination for the request.
*
* @generated from field: cosmos.base.query.v1beta1.PageRequest pagination = 1;
*/
pagination?: PageRequest;
/**
* block height at which to query
*
* @generated from field: uint64 query_height = 2;
*/
queryHeight = protoInt64.zero;
constructor(data?: PartialMessage<QueryIncentivizedPacketsRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.QueryIncentivizedPacketsRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "pagination", kind: "message", T: PageRequest },
{ no: 2, name: "query_height", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryIncentivizedPacketsRequest {
return new QueryIncentivizedPacketsRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryIncentivizedPacketsRequest {
return new QueryIncentivizedPacketsRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryIncentivizedPacketsRequest {
return new QueryIncentivizedPacketsRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryIncentivizedPacketsRequest | PlainMessage<QueryIncentivizedPacketsRequest> | undefined, b: QueryIncentivizedPacketsRequest | PlainMessage<QueryIncentivizedPacketsRequest> | undefined): boolean {
return proto3.util.equals(QueryIncentivizedPacketsRequest, a, b);
}
}
/**
* QueryIncentivizedPacketsResponse defines the response type for the IncentivizedPackets rpc
*
* @generated from message ibc.applications.fee.v1.QueryIncentivizedPacketsResponse
*/
export class QueryIncentivizedPacketsResponse extends Message<QueryIncentivizedPacketsResponse> {
/**
* list of identified fees for incentivized packets
*
* @generated from field: repeated ibc.applications.fee.v1.IdentifiedPacketFees incentivized_packets = 1;
*/
incentivizedPackets: IdentifiedPacketFees[] = [];
/**
* pagination defines the pagination in the response.
*
* @generated from field: cosmos.base.query.v1beta1.PageResponse pagination = 2;
*/
pagination?: PageResponse;
constructor(data?: PartialMessage<QueryIncentivizedPacketsResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.QueryIncentivizedPacketsResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "incentivized_packets", kind: "message", T: IdentifiedPacketFees, repeated: true },
{ no: 2, name: "pagination", kind: "message", T: PageResponse },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryIncentivizedPacketsResponse {
return new QueryIncentivizedPacketsResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryIncentivizedPacketsResponse {
return new QueryIncentivizedPacketsResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryIncentivizedPacketsResponse {
return new QueryIncentivizedPacketsResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryIncentivizedPacketsResponse | PlainMessage<QueryIncentivizedPacketsResponse> | undefined, b: QueryIncentivizedPacketsResponse | PlainMessage<QueryIncentivizedPacketsResponse> | undefined): boolean {
return proto3.util.equals(QueryIncentivizedPacketsResponse, a, b);
}
}
/**
* QueryIncentivizedPacketRequest defines the request type for the IncentivizedPacket rpc
*
* @generated from message ibc.applications.fee.v1.QueryIncentivizedPacketRequest
*/
export class QueryIncentivizedPacketRequest extends Message<QueryIncentivizedPacketRequest> {
/**
* unique packet identifier comprised of channel ID, port ID and sequence
*
* @generated from field: ibc.core.channel.v1.PacketId packet_id = 1;
*/
packetId?: PacketId;
/**
* block height at which to query
*
* @generated from field: uint64 query_height = 2;
*/
queryHeight = protoInt64.zero;
constructor(data?: PartialMessage<QueryIncentivizedPacketRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.QueryIncentivizedPacketRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "packet_id", kind: "message", T: PacketId },
{ no: 2, name: "query_height", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryIncentivizedPacketRequest {
return new QueryIncentivizedPacketRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryIncentivizedPacketRequest {
return new QueryIncentivizedPacketRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryIncentivizedPacketRequest {
return new QueryIncentivizedPacketRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryIncentivizedPacketRequest | PlainMessage<QueryIncentivizedPacketRequest> | undefined, b: QueryIncentivizedPacketRequest | PlainMessage<QueryIncentivizedPacketRequest> | undefined): boolean {
return proto3.util.equals(QueryIncentivizedPacketRequest, a, b);
}
}
/**
* QueryIncentivizedPacketResponse defines the response type for the IncentivizedPacket rpc
*
* @generated from message ibc.applications.fee.v1.QueryIncentivizedPacketResponse
*/
export class QueryIncentivizedPacketResponse extends Message<QueryIncentivizedPacketResponse> {
/**
* the identified fees for the incentivized packet
*
* @generated from field: ibc.applications.fee.v1.IdentifiedPacketFees incentivized_packet = 1;
*/
incentivizedPacket?: IdentifiedPacketFees;
constructor(data?: PartialMessage<QueryIncentivizedPacketResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.QueryIncentivizedPacketResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "incentivized_packet", kind: "message", T: IdentifiedPacketFees },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryIncentivizedPacketResponse {
return new QueryIncentivizedPacketResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryIncentivizedPacketResponse {
return new QueryIncentivizedPacketResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryIncentivizedPacketResponse {
return new QueryIncentivizedPacketResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryIncentivizedPacketResponse | PlainMessage<QueryIncentivizedPacketResponse> | undefined, b: QueryIncentivizedPacketResponse | PlainMessage<QueryIncentivizedPacketResponse> | undefined): boolean {
return proto3.util.equals(QueryIncentivizedPacketResponse, a, b);
}
}
/**
* QueryIncentivizedPacketsForChannelRequest defines the request type for querying for all incentivized packets
* for a specific channel
*
* @generated from message ibc.applications.fee.v1.QueryIncentivizedPacketsForChannelRequest
*/
export class QueryIncentivizedPacketsForChannelRequest extends Message<QueryIncentivizedPacketsForChannelRequest> {
/**
* pagination defines an optional pagination for the request.
*
* @generated from field: cosmos.base.query.v1beta1.PageRequest pagination = 1;
*/
pagination?: PageRequest;
/**
* @generated from field: string port_id = 2;
*/
portId = "";
/**
* @generated from field: string channel_id = 3;
*/
channelId = "";
/**
* Height to query at
*
* @generated from field: uint64 query_height = 4;
*/
queryHeight = protoInt64.zero;
constructor(data?: PartialMessage<QueryIncentivizedPacketsForChannelRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.QueryIncentivizedPacketsForChannelRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "pagination", kind: "message", T: PageRequest },
{ no: 2, name: "port_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "channel_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "query_height", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryIncentivizedPacketsForChannelRequest {
return new QueryIncentivizedPacketsForChannelRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryIncentivizedPacketsForChannelRequest {
return new QueryIncentivizedPacketsForChannelRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryIncentivizedPacketsForChannelRequest {
return new QueryIncentivizedPacketsForChannelRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryIncentivizedPacketsForChannelRequest | PlainMessage<QueryIncentivizedPacketsForChannelRequest> | undefined, b: QueryIncentivizedPacketsForChannelRequest | PlainMessage<QueryIncentivizedPacketsForChannelRequest> | undefined): boolean {
return proto3.util.equals(QueryIncentivizedPacketsForChannelRequest, a, b);
}
}
/**
* QueryIncentivizedPacketsForChannelResponse defines the response type for querying for all incentivized packets
* for a specific channel
*
* @generated from message ibc.applications.fee.v1.QueryIncentivizedPacketsForChannelResponse
*/
export class QueryIncentivizedPacketsForChannelResponse extends Message<QueryIncentivizedPacketsForChannelResponse> {
/**
* Map of all incentivized_packets
*
* @generated from field: repeated ibc.applications.fee.v1.IdentifiedPacketFees incentivized_packets = 1;
*/
incentivizedPackets: IdentifiedPacketFees[] = [];
/**
* pagination defines the pagination in the response.
*
* @generated from field: cosmos.base.query.v1beta1.PageResponse pagination = 2;
*/
pagination?: PageResponse;
constructor(data?: PartialMessage<QueryIncentivizedPacketsForChannelResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.QueryIncentivizedPacketsForChannelResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "incentivized_packets", kind: "message", T: IdentifiedPacketFees, repeated: true },
{ no: 2, name: "pagination", kind: "message", T: PageResponse },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryIncentivizedPacketsForChannelResponse {
return new QueryIncentivizedPacketsForChannelResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryIncentivizedPacketsForChannelResponse {
return new QueryIncentivizedPacketsForChannelResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryIncentivizedPacketsForChannelResponse {
return new QueryIncentivizedPacketsForChannelResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryIncentivizedPacketsForChannelResponse | PlainMessage<QueryIncentivizedPacketsForChannelResponse> | undefined, b: QueryIncentivizedPacketsForChannelResponse | PlainMessage<QueryIncentivizedPacketsForChannelResponse> | undefined): boolean {
return proto3.util.equals(QueryIncentivizedPacketsForChannelResponse, a, b);
}
}
/**
* QueryTotalRecvFeesRequest defines the request type for the TotalRecvFees rpc
*
* @generated from message ibc.applications.fee.v1.QueryTotalRecvFeesRequest
*/
export class QueryTotalRecvFeesRequest extends Message<QueryTotalRecvFeesRequest> {
/**
* the packet identifier for the associated fees
*
* @generated from field: ibc.core.channel.v1.PacketId packet_id = 1;
*/
packetId?: PacketId;
constructor(data?: PartialMessage<QueryTotalRecvFeesRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.QueryTotalRecvFeesRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "packet_id", kind: "message", T: PacketId },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryTotalRecvFeesRequest {
return new QueryTotalRecvFeesRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryTotalRecvFeesRequest {
return new QueryTotalRecvFeesRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryTotalRecvFeesRequest {
return new QueryTotalRecvFeesRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryTotalRecvFeesRequest | PlainMessage<QueryTotalRecvFeesRequest> | undefined, b: QueryTotalRecvFeesRequest | PlainMessage<QueryTotalRecvFeesRequest> | undefined): boolean {
return proto3.util.equals(QueryTotalRecvFeesRequest, a, b);
}
}
/**
* QueryTotalRecvFeesResponse defines the response type for the TotalRecvFees rpc
*
* @generated from message ibc.applications.fee.v1.QueryTotalRecvFeesResponse
*/
export class QueryTotalRecvFeesResponse extends Message<QueryTotalRecvFeesResponse> {
/**
* the total packet receive fees
*
* @generated from field: repeated cosmos.base.v1beta1.Coin recv_fees = 1;
*/
recvFees: Coin[] = [];
constructor(data?: PartialMessage<QueryTotalRecvFeesResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.QueryTotalRecvFeesResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "recv_fees", kind: "message", T: Coin, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryTotalRecvFeesResponse {
return new QueryTotalRecvFeesResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryTotalRecvFeesResponse {
return new QueryTotalRecvFeesResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryTotalRecvFeesResponse {
return new QueryTotalRecvFeesResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryTotalRecvFeesResponse | PlainMessage<QueryTotalRecvFeesResponse> | undefined, b: QueryTotalRecvFeesResponse | PlainMessage<QueryTotalRecvFeesResponse> | undefined): boolean {
return proto3.util.equals(QueryTotalRecvFeesResponse, a, b);
}
}
/**
* QueryTotalAckFeesRequest defines the request type for the TotalAckFees rpc
*
* @generated from message ibc.applications.fee.v1.QueryTotalAckFeesRequest
*/
export class QueryTotalAckFeesRequest extends Message<QueryTotalAckFeesRequest> {
/**
* the packet identifier for the associated fees
*
* @generated from field: ibc.core.channel.v1.PacketId packet_id = 1;
*/
packetId?: PacketId;
constructor(data?: PartialMessage<QueryTotalAckFeesRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.QueryTotalAckFeesRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "packet_id", kind: "message", T: PacketId },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryTotalAckFeesRequest {
return new QueryTotalAckFeesRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryTotalAckFeesRequest {
return new QueryTotalAckFeesRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryTotalAckFeesRequest {
return new QueryTotalAckFeesRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryTotalAckFeesRequest | PlainMessage<QueryTotalAckFeesRequest> | undefined, b: QueryTotalAckFeesRequest | PlainMessage<QueryTotalAckFeesRequest> | undefined): boolean {
return proto3.util.equals(QueryTotalAckFeesRequest, a, b);
}
}
/**
* QueryTotalAckFeesResponse defines the response type for the TotalAckFees rpc
*
* @generated from message ibc.applications.fee.v1.QueryTotalAckFeesResponse
*/
export class QueryTotalAckFeesResponse extends Message<QueryTotalAckFeesResponse> {
/**
* the total packet acknowledgement fees
*
* @generated from field: repeated cosmos.base.v1beta1.Coin ack_fees = 1;
*/
ackFees: Coin[] = [];
constructor(data?: PartialMessage<QueryTotalAckFeesResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.QueryTotalAckFeesResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "ack_fees", kind: "message", T: Coin, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryTotalAckFeesResponse {
return new QueryTotalAckFeesResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryTotalAckFeesResponse {
return new QueryTotalAckFeesResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryTotalAckFeesResponse {
return new QueryTotalAckFeesResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryTotalAckFeesResponse | PlainMessage<QueryTotalAckFeesResponse> | undefined, b: QueryTotalAckFeesResponse | PlainMessage<QueryTotalAckFeesResponse> | undefined): boolean {
return proto3.util.equals(QueryTotalAckFeesResponse, a, b);
}
}
/**
* QueryTotalTimeoutFeesRequest defines the request type for the TotalTimeoutFees rpc
*
* @generated from message ibc.applications.fee.v1.QueryTotalTimeoutFeesRequest
*/
export class QueryTotalTimeoutFeesRequest extends Message<QueryTotalTimeoutFeesRequest> {
/**
* the packet identifier for the associated fees
*
* @generated from field: ibc.core.channel.v1.PacketId packet_id = 1;
*/
packetId?: PacketId;
constructor(data?: PartialMessage<QueryTotalTimeoutFeesRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.QueryTotalTimeoutFeesRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "packet_id", kind: "message", T: PacketId },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryTotalTimeoutFeesRequest {
return new QueryTotalTimeoutFeesRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryTotalTimeoutFeesRequest {
return new QueryTotalTimeoutFeesRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryTotalTimeoutFeesRequest {
return new QueryTotalTimeoutFeesRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryTotalTimeoutFeesRequest | PlainMessage<QueryTotalTimeoutFeesRequest> | undefined, b: QueryTotalTimeoutFeesRequest | PlainMessage<QueryTotalTimeoutFeesRequest> | undefined): boolean {
return proto3.util.equals(QueryTotalTimeoutFeesRequest, a, b);
}
}
/**
* QueryTotalTimeoutFeesResponse defines the response type for the TotalTimeoutFees rpc
*
* @generated from message ibc.applications.fee.v1.QueryTotalTimeoutFeesResponse
*/
export class QueryTotalTimeoutFeesResponse extends Message<QueryTotalTimeoutFeesResponse> {
/**
* the total packet timeout fees
*
* @generated from field: repeated cosmos.base.v1beta1.Coin timeout_fees = 1;
*/
timeoutFees: Coin[] = [];
constructor(data?: PartialMessage<QueryTotalTimeoutFeesResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.QueryTotalTimeoutFeesResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "timeout_fees", kind: "message", T: Coin, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryTotalTimeoutFeesResponse {
return new QueryTotalTimeoutFeesResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryTotalTimeoutFeesResponse {
return new QueryTotalTimeoutFeesResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryTotalTimeoutFeesResponse {
return new QueryTotalTimeoutFeesResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryTotalTimeoutFeesResponse | PlainMessage<QueryTotalTimeoutFeesResponse> | undefined, b: QueryTotalTimeoutFeesResponse | PlainMessage<QueryTotalTimeoutFeesResponse> | undefined): boolean {
return proto3.util.equals(QueryTotalTimeoutFeesResponse, a, b);
}
}
/**
* QueryPayeeRequest defines the request type for the Payee rpc
*
* @generated from message ibc.applications.fee.v1.QueryPayeeRequest
*/
export class QueryPayeeRequest extends Message<QueryPayeeRequest> {
/**
* unique channel identifier
*
* @generated from field: string channel_id = 1;
*/
channelId = "";
/**
* the relayer address to which the distribution address is registered
*
* @generated from field: string relayer = 2;
*/
relayer = "";
constructor(data?: PartialMessage<QueryPayeeRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.QueryPayeeRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "channel_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "relayer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryPayeeRequest {
return new QueryPayeeRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryPayeeRequest {
return new QueryPayeeRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryPayeeRequest {
return new QueryPayeeRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryPayeeRequest | PlainMessage<QueryPayeeRequest> | undefined, b: QueryPayeeRequest | PlainMessage<QueryPayeeRequest> | undefined): boolean {
return proto3.util.equals(QueryPayeeRequest, a, b);
}
}
/**
* QueryPayeeResponse defines the response type for the Payee rpc
*
* @generated from message ibc.applications.fee.v1.QueryPayeeResponse
*/
export class QueryPayeeResponse extends Message<QueryPayeeResponse> {
/**
* the payee address to which packet fees are paid out
*
* @generated from field: string payee_address = 1;
*/
payeeAddress = "";
constructor(data?: PartialMessage<QueryPayeeResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.QueryPayeeResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "payee_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryPayeeResponse {
return new QueryPayeeResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryPayeeResponse {
return new QueryPayeeResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryPayeeResponse {
return new QueryPayeeResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryPayeeResponse | PlainMessage<QueryPayeeResponse> | undefined, b: QueryPayeeResponse | PlainMessage<QueryPayeeResponse> | undefined): boolean {
return proto3.util.equals(QueryPayeeResponse, a, b);
}
}
/**
* QueryCounterpartyPayeeRequest defines the request type for the CounterpartyPayee rpc
*
* @generated from message ibc.applications.fee.v1.QueryCounterpartyPayeeRequest
*/
export class QueryCounterpartyPayeeRequest extends Message<QueryCounterpartyPayeeRequest> {
/**
* unique channel identifier
*
* @generated from field: string channel_id = 1;
*/
channelId = "";
/**
* the relayer address to which the counterparty is registered
*
* @generated from field: string relayer = 2;
*/
relayer = "";
constructor(data?: PartialMessage<QueryCounterpartyPayeeRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.QueryCounterpartyPayeeRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "channel_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "relayer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryCounterpartyPayeeRequest {
return new QueryCounterpartyPayeeRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryCounterpartyPayeeRequest {
return new QueryCounterpartyPayeeRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryCounterpartyPayeeRequest {
return new QueryCounterpartyPayeeRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryCounterpartyPayeeRequest | PlainMessage<QueryCounterpartyPayeeRequest> | undefined, b: QueryCounterpartyPayeeRequest | PlainMessage<QueryCounterpartyPayeeRequest> | undefined): boolean {
return proto3.util.equals(QueryCounterpartyPayeeRequest, a, b);
}
}
/**
* QueryCounterpartyPayeeResponse defines the response type for the CounterpartyPayee rpc
*
* @generated from message ibc.applications.fee.v1.QueryCounterpartyPayeeResponse
*/
export class QueryCounterpartyPayeeResponse extends Message<QueryCounterpartyPayeeResponse> {
/**
* the counterparty payee address used to compensate forward relaying
*
* @generated from field: string counterparty_payee = 1;
*/
counterpartyPayee = "";
constructor(data?: PartialMessage<QueryCounterpartyPayeeResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.QueryCounterpartyPayeeResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "counterparty_payee", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryCounterpartyPayeeResponse {
return new QueryCounterpartyPayeeResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryCounterpartyPayeeResponse {
return new QueryCounterpartyPayeeResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryCounterpartyPayeeResponse {
return new QueryCounterpartyPayeeResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryCounterpartyPayeeResponse | PlainMessage<QueryCounterpartyPayeeResponse> | undefined, b: QueryCounterpartyPayeeResponse | PlainMessage<QueryCounterpartyPayeeResponse> | undefined): boolean {
return proto3.util.equals(QueryCounterpartyPayeeResponse, a, b);
}
}
/**
* QueryFeeEnabledChannelsRequest defines the request type for the FeeEnabledChannels rpc
*
* @generated from message ibc.applications.fee.v1.QueryFeeEnabledChannelsRequest
*/
export class QueryFeeEnabledChannelsRequest extends Message<QueryFeeEnabledChannelsRequest> {
/**
* pagination defines an optional pagination for the request.
*
* @generated from field: cosmos.base.query.v1beta1.PageRequest pagination = 1;
*/
pagination?: PageRequest;
/**
* block height at which to query
*
* @generated from field: uint64 query_height = 2;
*/
queryHeight = protoInt64.zero;
constructor(data?: PartialMessage<QueryFeeEnabledChannelsRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.QueryFeeEnabledChannelsRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "pagination", kind: "message", T: PageRequest },
{ no: 2, name: "query_height", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryFeeEnabledChannelsRequest {
return new QueryFeeEnabledChannelsRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryFeeEnabledChannelsRequest {
return new QueryFeeEnabledChannelsRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryFeeEnabledChannelsRequest {
return new QueryFeeEnabledChannelsRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryFeeEnabledChannelsRequest | PlainMessage<QueryFeeEnabledChannelsRequest> | undefined, b: QueryFeeEnabledChannelsRequest | PlainMessage<QueryFeeEnabledChannelsRequest> | undefined): boolean {
return proto3.util.equals(QueryFeeEnabledChannelsRequest, a, b);
}
}
/**
* QueryFeeEnabledChannelsResponse defines the response type for the FeeEnabledChannels rpc
*
* @generated from message ibc.applications.fee.v1.QueryFeeEnabledChannelsResponse
*/
export class QueryFeeEnabledChannelsResponse extends Message<QueryFeeEnabledChannelsResponse> {
/**
* list of fee enabled channels
*
* @generated from field: repeated ibc.applications.fee.v1.FeeEnabledChannel fee_enabled_channels = 1;
*/
feeEnabledChannels: FeeEnabledChannel[] = [];
/**
* pagination defines the pagination in the response.
*
* @generated from field: cosmos.base.query.v1beta1.PageResponse pagination = 2;
*/
pagination?: PageResponse;
constructor(data?: PartialMessage<QueryFeeEnabledChannelsResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.QueryFeeEnabledChannelsResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "fee_enabled_channels", kind: "message", T: FeeEnabledChannel, repeated: true },
{ no: 2, name: "pagination", kind: "message", T: PageResponse },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryFeeEnabledChannelsResponse {
return new QueryFeeEnabledChannelsResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryFeeEnabledChannelsResponse {
return new QueryFeeEnabledChannelsResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryFeeEnabledChannelsResponse {
return new QueryFeeEnabledChannelsResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryFeeEnabledChannelsResponse | PlainMessage<QueryFeeEnabledChannelsResponse> | undefined, b: QueryFeeEnabledChannelsResponse | PlainMessage<QueryFeeEnabledChannelsResponse> | undefined): boolean {
return proto3.util.equals(QueryFeeEnabledChannelsResponse, a, b);
}
}
/**
* QueryFeeEnabledChannelRequest defines the request type for the FeeEnabledChannel rpc
*
* @generated from message ibc.applications.fee.v1.QueryFeeEnabledChannelRequest
*/
export class QueryFeeEnabledChannelRequest extends Message<QueryFeeEnabledChannelRequest> {
/**
* unique port identifier
*
* @generated from field: string port_id = 1;
*/
portId = "";
/**
* unique channel identifier
*
* @generated from field: string channel_id = 2;
*/
channelId = "";
constructor(data?: PartialMessage<QueryFeeEnabledChannelRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.QueryFeeEnabledChannelRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "port_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "channel_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryFeeEnabledChannelRequest {
return new QueryFeeEnabledChannelRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryFeeEnabledChannelRequest {
return new QueryFeeEnabledChannelRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryFeeEnabledChannelRequest {
return new QueryFeeEnabledChannelRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryFeeEnabledChannelRequest | PlainMessage<QueryFeeEnabledChannelRequest> | undefined, b: QueryFeeEnabledChannelRequest | PlainMessage<QueryFeeEnabledChannelRequest> | undefined): boolean {
return proto3.util.equals(QueryFeeEnabledChannelRequest, a, b);
}
}
/**
* QueryFeeEnabledChannelResponse defines the response type for the FeeEnabledChannel rpc
*
* @generated from message ibc.applications.fee.v1.QueryFeeEnabledChannelResponse
*/
export class QueryFeeEnabledChannelResponse extends Message<QueryFeeEnabledChannelResponse> {
/**
* boolean flag representing the fee enabled channel status
*
* @generated from field: bool fee_enabled = 1;
*/
feeEnabled = false;
constructor(data?: PartialMessage<QueryFeeEnabledChannelResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.QueryFeeEnabledChannelResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "fee_enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryFeeEnabledChannelResponse {
return new QueryFeeEnabledChannelResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryFeeEnabledChannelResponse {
return new QueryFeeEnabledChannelResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryFeeEnabledChannelResponse {
return new QueryFeeEnabledChannelResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryFeeEnabledChannelResponse | PlainMessage<QueryFeeEnabledChannelResponse> | undefined, b: QueryFeeEnabledChannelResponse | PlainMessage<QueryFeeEnabledChannelResponse> | undefined): boolean {
return proto3.util.equals(QueryFeeEnabledChannelResponse, a, b);
}
}

71
libs/es-client/src/protobufs/ibc/applications/fee/v1/tx_cosmes.ts Normal file
View File

@ -0,0 +1,71 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file ibc/applications/fee/v1/tx.proto (package ibc.applications.fee.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { MsgPayPacketFee, MsgPayPacketFeeAsync, MsgPayPacketFeeAsyncResponse, MsgPayPacketFeeResponse, MsgRegisterCounterpartyPayee, MsgRegisterCounterpartyPayeeResponse, MsgRegisterPayee, MsgRegisterPayeeResponse } from "./tx_pb.js";
const TYPE_NAME = "ibc.applications.fee.v1.Msg";
/**
* RegisterPayee defines a rpc handler method for MsgRegisterPayee
* RegisterPayee is called by the relayer on each channelEnd and allows them to set an optional
* payee to which reverse and timeout relayer packet fees will be paid out. The payee should be registered on
* the source chain from which packets originate as this is where fee distribution takes place. This function may be
* called more than once by a relayer, in which case, the latest payee is always used.
*
* @generated from rpc ibc.applications.fee.v1.Msg.RegisterPayee
*/
export const MsgRegisterPayeeService = {
typeName: TYPE_NAME,
method: "RegisterPayee",
Request: MsgRegisterPayee,
Response: MsgRegisterPayeeResponse,
} as const;
/**
* RegisterCounterpartyPayee defines a rpc handler method for MsgRegisterCounterpartyPayee
* RegisterCounterpartyPayee is called by the relayer on each channelEnd and allows them to specify the counterparty
* payee address before relaying. This ensures they will be properly compensated for forward relaying since
* the destination chain must include the registered counterparty payee address in the acknowledgement. This function
* may be called more than once by a relayer, in which case, the latest counterparty payee address is always used.
*
* @generated from rpc ibc.applications.fee.v1.Msg.RegisterCounterpartyPayee
*/
export const MsgRegisterCounterpartyPayeeService = {
typeName: TYPE_NAME,
method: "RegisterCounterpartyPayee",
Request: MsgRegisterCounterpartyPayee,
Response: MsgRegisterCounterpartyPayeeResponse,
} as const;
/**
* PayPacketFee defines a rpc handler method for MsgPayPacketFee
* PayPacketFee is an open callback that may be called by any module/user that wishes to escrow funds in order to
* incentivize the relaying of the packet at the next sequence
* NOTE: This method is intended to be used within a multi msg transaction, where the subsequent msg that follows
* initiates the lifecycle of the incentivized packet
*
* @generated from rpc ibc.applications.fee.v1.Msg.PayPacketFee
*/
export const MsgPayPacketFeeService = {
typeName: TYPE_NAME,
method: "PayPacketFee",
Request: MsgPayPacketFee,
Response: MsgPayPacketFeeResponse,
} as const;
/**
* PayPacketFeeAsync defines a rpc handler method for MsgPayPacketFeeAsync
* PayPacketFeeAsync is an open callback that may be called by any module/user that wishes to escrow funds in order to
* incentivize the relaying of a known packet (i.e. at a particular sequence)
*
* @generated from rpc ibc.applications.fee.v1.Msg.PayPacketFeeAsync
*/
export const MsgPayPacketFeeAsyncService = {
typeName: TYPE_NAME,
method: "PayPacketFeeAsync",
Request: MsgPayPacketFeeAsync,
Response: MsgPayPacketFeeAsyncResponse,
} as const;

397
libs/es-client/src/protobufs/ibc/applications/fee/v1/tx_pb.ts Normal file
View File

@ -0,0 +1,397 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/fee/v1/tx.proto (package ibc.applications.fee.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { Fee, PacketFee } from "./fee_pb.js";
import { PacketId } from "../../../core/channel/v1/channel_pb.js";
/**
* MsgRegisterPayee defines the request type for the RegisterPayee rpc
*
* @generated from message ibc.applications.fee.v1.MsgRegisterPayee
*/
export class MsgRegisterPayee extends Message<MsgRegisterPayee> {
/**
* unique port identifier
*
* @generated from field: string port_id = 1;
*/
portId = "";
/**
* unique channel identifier
*
* @generated from field: string channel_id = 2;
*/
channelId = "";
/**
* the relayer address
*
* @generated from field: string relayer = 3;
*/
relayer = "";
/**
* the payee address
*
* @generated from field: string payee = 4;
*/
payee = "";
constructor(data?: PartialMessage<MsgRegisterPayee>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.MsgRegisterPayee";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "port_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "channel_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "relayer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "payee", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgRegisterPayee {
return new MsgRegisterPayee().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgRegisterPayee {
return new MsgRegisterPayee().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgRegisterPayee {
return new MsgRegisterPayee().fromJsonString(jsonString, options);
}
static equals(a: MsgRegisterPayee | PlainMessage<MsgRegisterPayee> | undefined, b: MsgRegisterPayee | PlainMessage<MsgRegisterPayee> | undefined): boolean {
return proto3.util.equals(MsgRegisterPayee, a, b);
}
}
/**
* MsgRegisterPayeeResponse defines the response type for the RegisterPayee rpc
*
* @generated from message ibc.applications.fee.v1.MsgRegisterPayeeResponse
*/
export class MsgRegisterPayeeResponse extends Message<MsgRegisterPayeeResponse> {
constructor(data?: PartialMessage<MsgRegisterPayeeResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.MsgRegisterPayeeResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgRegisterPayeeResponse {
return new MsgRegisterPayeeResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgRegisterPayeeResponse {
return new MsgRegisterPayeeResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgRegisterPayeeResponse {
return new MsgRegisterPayeeResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgRegisterPayeeResponse | PlainMessage<MsgRegisterPayeeResponse> | undefined, b: MsgRegisterPayeeResponse | PlainMessage<MsgRegisterPayeeResponse> | undefined): boolean {
return proto3.util.equals(MsgRegisterPayeeResponse, a, b);
}
}
/**
* MsgRegisterCounterpartyPayee defines the request type for the RegisterCounterpartyPayee rpc
*
* @generated from message ibc.applications.fee.v1.MsgRegisterCounterpartyPayee
*/
export class MsgRegisterCounterpartyPayee extends Message<MsgRegisterCounterpartyPayee> {
/**
* unique port identifier
*
* @generated from field: string port_id = 1;
*/
portId = "";
/**
* unique channel identifier
*
* @generated from field: string channel_id = 2;
*/
channelId = "";
/**
* the relayer address
*
* @generated from field: string relayer = 3;
*/
relayer = "";
/**
* the counterparty payee address
*
* @generated from field: string counterparty_payee = 4;
*/
counterpartyPayee = "";
constructor(data?: PartialMessage<MsgRegisterCounterpartyPayee>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.MsgRegisterCounterpartyPayee";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "port_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "channel_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "relayer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "counterparty_payee", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgRegisterCounterpartyPayee {
return new MsgRegisterCounterpartyPayee().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgRegisterCounterpartyPayee {
return new MsgRegisterCounterpartyPayee().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgRegisterCounterpartyPayee {
return new MsgRegisterCounterpartyPayee().fromJsonString(jsonString, options);
}
static equals(a: MsgRegisterCounterpartyPayee | PlainMessage<MsgRegisterCounterpartyPayee> | undefined, b: MsgRegisterCounterpartyPayee | PlainMessage<MsgRegisterCounterpartyPayee> | undefined): boolean {
return proto3.util.equals(MsgRegisterCounterpartyPayee, a, b);
}
}
/**
* MsgRegisterCounterpartyPayeeResponse defines the response type for the RegisterCounterpartyPayee rpc
*
* @generated from message ibc.applications.fee.v1.MsgRegisterCounterpartyPayeeResponse
*/
export class MsgRegisterCounterpartyPayeeResponse extends Message<MsgRegisterCounterpartyPayeeResponse> {
constructor(data?: PartialMessage<MsgRegisterCounterpartyPayeeResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.MsgRegisterCounterpartyPayeeResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgRegisterCounterpartyPayeeResponse {
return new MsgRegisterCounterpartyPayeeResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgRegisterCounterpartyPayeeResponse {
return new MsgRegisterCounterpartyPayeeResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgRegisterCounterpartyPayeeResponse {
return new MsgRegisterCounterpartyPayeeResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgRegisterCounterpartyPayeeResponse | PlainMessage<MsgRegisterCounterpartyPayeeResponse> | undefined, b: MsgRegisterCounterpartyPayeeResponse | PlainMessage<MsgRegisterCounterpartyPayeeResponse> | undefined): boolean {
return proto3.util.equals(MsgRegisterCounterpartyPayeeResponse, a, b);
}
}
/**
* MsgPayPacketFee defines the request type for the PayPacketFee rpc
* This Msg can be used to pay for a packet at the next sequence send & should be combined with the Msg that will be
* paid for
*
* @generated from message ibc.applications.fee.v1.MsgPayPacketFee
*/
export class MsgPayPacketFee extends Message<MsgPayPacketFee> {
/**
* fee encapsulates the recv, ack and timeout fees associated with an IBC packet
*
* @generated from field: ibc.applications.fee.v1.Fee fee = 1;
*/
fee?: Fee;
/**
* the source port unique identifier
*
* @generated from field: string source_port_id = 2;
*/
sourcePortId = "";
/**
* the source channel unique identifier
*
* @generated from field: string source_channel_id = 3;
*/
sourceChannelId = "";
/**
* account address to refund fee if necessary
*
* @generated from field: string signer = 4;
*/
signer = "";
/**
* optional list of relayers permitted to the receive packet fees
*
* @generated from field: repeated string relayers = 5;
*/
relayers: string[] = [];
constructor(data?: PartialMessage<MsgPayPacketFee>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.MsgPayPacketFee";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "fee", kind: "message", T: Fee },
{ no: 2, name: "source_port_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "source_channel_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "signer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 5, name: "relayers", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgPayPacketFee {
return new MsgPayPacketFee().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgPayPacketFee {
return new MsgPayPacketFee().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgPayPacketFee {
return new MsgPayPacketFee().fromJsonString(jsonString, options);
}
static equals(a: MsgPayPacketFee | PlainMessage<MsgPayPacketFee> | undefined, b: MsgPayPacketFee | PlainMessage<MsgPayPacketFee> | undefined): boolean {
return proto3.util.equals(MsgPayPacketFee, a, b);
}
}
/**
* MsgPayPacketFeeResponse defines the response type for the PayPacketFee rpc
*
* @generated from message ibc.applications.fee.v1.MsgPayPacketFeeResponse
*/
export class MsgPayPacketFeeResponse extends Message<MsgPayPacketFeeResponse> {
constructor(data?: PartialMessage<MsgPayPacketFeeResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.MsgPayPacketFeeResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgPayPacketFeeResponse {
return new MsgPayPacketFeeResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgPayPacketFeeResponse {
return new MsgPayPacketFeeResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgPayPacketFeeResponse {
return new MsgPayPacketFeeResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgPayPacketFeeResponse | PlainMessage<MsgPayPacketFeeResponse> | undefined, b: MsgPayPacketFeeResponse | PlainMessage<MsgPayPacketFeeResponse> | undefined): boolean {
return proto3.util.equals(MsgPayPacketFeeResponse, a, b);
}
}
/**
* MsgPayPacketFeeAsync defines the request type for the PayPacketFeeAsync rpc
* This Msg can be used to pay for a packet at a specified sequence (instead of the next sequence send)
*
* @generated from message ibc.applications.fee.v1.MsgPayPacketFeeAsync
*/
export class MsgPayPacketFeeAsync extends Message<MsgPayPacketFeeAsync> {
/**
* unique packet identifier comprised of the channel ID, port ID and sequence
*
* @generated from field: ibc.core.channel.v1.PacketId packet_id = 1;
*/
packetId?: PacketId;
/**
* the packet fee associated with a particular IBC packet
*
* @generated from field: ibc.applications.fee.v1.PacketFee packet_fee = 2;
*/
packetFee?: PacketFee;
constructor(data?: PartialMessage<MsgPayPacketFeeAsync>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.MsgPayPacketFeeAsync";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "packet_id", kind: "message", T: PacketId },
{ no: 2, name: "packet_fee", kind: "message", T: PacketFee },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgPayPacketFeeAsync {
return new MsgPayPacketFeeAsync().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgPayPacketFeeAsync {
return new MsgPayPacketFeeAsync().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgPayPacketFeeAsync {
return new MsgPayPacketFeeAsync().fromJsonString(jsonString, options);
}
static equals(a: MsgPayPacketFeeAsync | PlainMessage<MsgPayPacketFeeAsync> | undefined, b: MsgPayPacketFeeAsync | PlainMessage<MsgPayPacketFeeAsync> | undefined): boolean {
return proto3.util.equals(MsgPayPacketFeeAsync, a, b);
}
}
/**
* MsgPayPacketFeeAsyncResponse defines the response type for the PayPacketFeeAsync rpc
*
* @generated from message ibc.applications.fee.v1.MsgPayPacketFeeAsyncResponse
*/
export class MsgPayPacketFeeAsyncResponse extends Message<MsgPayPacketFeeAsyncResponse> {
constructor(data?: PartialMessage<MsgPayPacketFeeAsyncResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.fee.v1.MsgPayPacketFeeAsyncResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgPayPacketFeeAsyncResponse {
return new MsgPayPacketFeeAsyncResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgPayPacketFeeAsyncResponse {
return new MsgPayPacketFeeAsyncResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgPayPacketFeeAsyncResponse {
return new MsgPayPacketFeeAsyncResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgPayPacketFeeAsyncResponse | PlainMessage<MsgPayPacketFeeAsyncResponse> | undefined, b: MsgPayPacketFeeAsyncResponse | PlainMessage<MsgPayPacketFeeAsyncResponse> | undefined): boolean {
return proto3.util.equals(MsgPayPacketFeeAsyncResponse, a, b);
}
}

50
libs/es-client/src/protobufs/ibc/applications/interchain_accounts/controller/v1/controller_pb.ts Normal file
View File

@ -0,0 +1,50 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/interchain_accounts/controller/v1/controller.proto (package ibc.applications.interchain_accounts.controller.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
/**
* Params defines the set of on-chain interchain accounts parameters.
* The following parameters may be used to disable the controller submodule.
*
* @generated from message ibc.applications.interchain_accounts.controller.v1.Params
*/
export class Params extends Message<Params> {
/**
* controller_enabled enables or disables the controller submodule.
*
* @generated from field: bool controller_enabled = 1;
*/
controllerEnabled = false;
constructor(data?: PartialMessage<Params>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.controller.v1.Params";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "controller_enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Params {
return new Params().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Params {
return new Params().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Params {
return new Params().fromJsonString(jsonString, options);
}
static equals(a: Params | PlainMessage<Params> | undefined, b: Params | PlainMessage<Params> | undefined): boolean {
return proto3.util.equals(Params, a, b);
}
}

33
libs/es-client/src/protobufs/ibc/applications/interchain_accounts/controller/v1/query_cosmes.ts Normal file
View File

@ -0,0 +1,33 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file ibc/applications/interchain_accounts/controller/v1/query.proto (package ibc.applications.interchain_accounts.controller.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { QueryInterchainAccountRequest, QueryInterchainAccountResponse, QueryParamsRequest, QueryParamsResponse } from "./query_pb.js";
const TYPE_NAME = "ibc.applications.interchain_accounts.controller.v1.Query";
/**
* InterchainAccount returns the interchain account address for a given owner address on a given connection
*
* @generated from rpc ibc.applications.interchain_accounts.controller.v1.Query.InterchainAccount
*/
export const QueryInterchainAccountService = {
typeName: TYPE_NAME,
method: "InterchainAccount",
Request: QueryInterchainAccountRequest,
Response: QueryInterchainAccountResponse,
} as const;
/**
* Params queries all parameters of the ICA controller submodule.
*
* @generated from rpc ibc.applications.interchain_accounts.controller.v1.Query.Params
*/
export const QueryParamsService = {
typeName: TYPE_NAME,
method: "Params",
Request: QueryParamsRequest,
Response: QueryParamsResponse,
} as const;

167
libs/es-client/src/protobufs/ibc/applications/interchain_accounts/controller/v1/query_pb.ts Normal file
View File

@ -0,0 +1,167 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/interchain_accounts/controller/v1/query.proto (package ibc.applications.interchain_accounts.controller.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { Params } from "./controller_pb.js";
/**
* QueryInterchainAccountRequest is the request type for the Query/InterchainAccount RPC method.
*
* @generated from message ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountRequest
*/
export class QueryInterchainAccountRequest extends Message<QueryInterchainAccountRequest> {
/**
* @generated from field: string owner = 1;
*/
owner = "";
/**
* @generated from field: string connection_id = 2;
*/
connectionId = "";
constructor(data?: PartialMessage<QueryInterchainAccountRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "owner", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "connection_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryInterchainAccountRequest {
return new QueryInterchainAccountRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryInterchainAccountRequest {
return new QueryInterchainAccountRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryInterchainAccountRequest {
return new QueryInterchainAccountRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryInterchainAccountRequest | PlainMessage<QueryInterchainAccountRequest> | undefined, b: QueryInterchainAccountRequest | PlainMessage<QueryInterchainAccountRequest> | undefined): boolean {
return proto3.util.equals(QueryInterchainAccountRequest, a, b);
}
}
/**
* QueryInterchainAccountResponse the response type for the Query/InterchainAccount RPC method.
*
* @generated from message ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountResponse
*/
export class QueryInterchainAccountResponse extends Message<QueryInterchainAccountResponse> {
/**
* @generated from field: string address = 1;
*/
address = "";
constructor(data?: PartialMessage<QueryInterchainAccountResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryInterchainAccountResponse {
return new QueryInterchainAccountResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryInterchainAccountResponse {
return new QueryInterchainAccountResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryInterchainAccountResponse {
return new QueryInterchainAccountResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryInterchainAccountResponse | PlainMessage<QueryInterchainAccountResponse> | undefined, b: QueryInterchainAccountResponse | PlainMessage<QueryInterchainAccountResponse> | undefined): boolean {
return proto3.util.equals(QueryInterchainAccountResponse, a, b);
}
}
/**
* QueryParamsRequest is the request type for the Query/Params RPC method.
*
* @generated from message ibc.applications.interchain_accounts.controller.v1.QueryParamsRequest
*/
export class QueryParamsRequest extends Message<QueryParamsRequest> {
constructor(data?: PartialMessage<QueryParamsRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.controller.v1.QueryParamsRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryParamsRequest {
return new QueryParamsRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryParamsRequest {
return new QueryParamsRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryParamsRequest {
return new QueryParamsRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryParamsRequest | PlainMessage<QueryParamsRequest> | undefined, b: QueryParamsRequest | PlainMessage<QueryParamsRequest> | undefined): boolean {
return proto3.util.equals(QueryParamsRequest, a, b);
}
}
/**
* QueryParamsResponse is the response type for the Query/Params RPC method.
*
* @generated from message ibc.applications.interchain_accounts.controller.v1.QueryParamsResponse
*/
export class QueryParamsResponse extends Message<QueryParamsResponse> {
/**
* params defines the parameters of the module.
*
* @generated from field: ibc.applications.interchain_accounts.controller.v1.Params params = 1;
*/
params?: Params;
constructor(data?: PartialMessage<QueryParamsResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.controller.v1.QueryParamsResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "params", kind: "message", T: Params },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryParamsResponse {
return new QueryParamsResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryParamsResponse {
return new QueryParamsResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryParamsResponse {
return new QueryParamsResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryParamsResponse | PlainMessage<QueryParamsResponse> | undefined, b: QueryParamsResponse | PlainMessage<QueryParamsResponse> | undefined): boolean {
return proto3.util.equals(QueryParamsResponse, a, b);
}
}

45
libs/es-client/src/protobufs/ibc/applications/interchain_accounts/controller/v1/tx_cosmes.ts Normal file
View File

@ -0,0 +1,45 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file ibc/applications/interchain_accounts/controller/v1/tx.proto (package ibc.applications.interchain_accounts.controller.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { MsgRegisterInterchainAccount, MsgRegisterInterchainAccountResponse, MsgSendTx, MsgSendTxResponse, MsgUpdateParams, MsgUpdateParamsResponse } from "./tx_pb.js";
const TYPE_NAME = "ibc.applications.interchain_accounts.controller.v1.Msg";
/**
* RegisterInterchainAccount defines a rpc handler for MsgRegisterInterchainAccount.
*
* @generated from rpc ibc.applications.interchain_accounts.controller.v1.Msg.RegisterInterchainAccount
*/
export const MsgRegisterInterchainAccountService = {
typeName: TYPE_NAME,
method: "RegisterInterchainAccount",
Request: MsgRegisterInterchainAccount,
Response: MsgRegisterInterchainAccountResponse,
} as const;
/**
* SendTx defines a rpc handler for MsgSendTx.
*
* @generated from rpc ibc.applications.interchain_accounts.controller.v1.Msg.SendTx
*/
export const MsgSendTxService = {
typeName: TYPE_NAME,
method: "SendTx",
Request: MsgSendTx,
Response: MsgSendTxResponse,
} as const;
/**
* UpdateParams defines a rpc handler for MsgUpdateParams.
*
* @generated from rpc ibc.applications.interchain_accounts.controller.v1.Msg.UpdateParams
*/
export const MsgUpdateParamsService = {
typeName: TYPE_NAME,
method: "UpdateParams",
Request: MsgUpdateParams,
Response: MsgUpdateParamsResponse,
} as const;

296
libs/es-client/src/protobufs/ibc/applications/interchain_accounts/controller/v1/tx_pb.ts Normal file
View File

@ -0,0 +1,296 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/interchain_accounts/controller/v1/tx.proto (package ibc.applications.interchain_accounts.controller.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, protoInt64 } from "@bufbuild/protobuf";
import { Order } from "../../../../core/channel/v1/channel_pb.js";
import { InterchainAccountPacketData } from "../../v1/packet_pb.js";
import { Params } from "./controller_pb.js";
/**
* MsgRegisterInterchainAccount defines the payload for Msg/RegisterAccount
*
* @generated from message ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccount
*/
export class MsgRegisterInterchainAccount extends Message<MsgRegisterInterchainAccount> {
/**
* @generated from field: string owner = 1;
*/
owner = "";
/**
* @generated from field: string connection_id = 2;
*/
connectionId = "";
/**
* @generated from field: string version = 3;
*/
version = "";
/**
* @generated from field: ibc.core.channel.v1.Order ordering = 4;
*/
ordering = Order.NONE_UNSPECIFIED;
constructor(data?: PartialMessage<MsgRegisterInterchainAccount>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccount";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "owner", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "connection_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "version", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "ordering", kind: "enum", T: proto3.getEnumType(Order) },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgRegisterInterchainAccount {
return new MsgRegisterInterchainAccount().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgRegisterInterchainAccount {
return new MsgRegisterInterchainAccount().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgRegisterInterchainAccount {
return new MsgRegisterInterchainAccount().fromJsonString(jsonString, options);
}
static equals(a: MsgRegisterInterchainAccount | PlainMessage<MsgRegisterInterchainAccount> | undefined, b: MsgRegisterInterchainAccount | PlainMessage<MsgRegisterInterchainAccount> | undefined): boolean {
return proto3.util.equals(MsgRegisterInterchainAccount, a, b);
}
}
/**
* MsgRegisterInterchainAccountResponse defines the response for Msg/RegisterAccount
*
* @generated from message ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccountResponse
*/
export class MsgRegisterInterchainAccountResponse extends Message<MsgRegisterInterchainAccountResponse> {
/**
* @generated from field: string channel_id = 1;
*/
channelId = "";
/**
* @generated from field: string port_id = 2;
*/
portId = "";
constructor(data?: PartialMessage<MsgRegisterInterchainAccountResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccountResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "channel_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "port_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgRegisterInterchainAccountResponse {
return new MsgRegisterInterchainAccountResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgRegisterInterchainAccountResponse {
return new MsgRegisterInterchainAccountResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgRegisterInterchainAccountResponse {
return new MsgRegisterInterchainAccountResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgRegisterInterchainAccountResponse | PlainMessage<MsgRegisterInterchainAccountResponse> | undefined, b: MsgRegisterInterchainAccountResponse | PlainMessage<MsgRegisterInterchainAccountResponse> | undefined): boolean {
return proto3.util.equals(MsgRegisterInterchainAccountResponse, a, b);
}
}
/**
* MsgSendTx defines the payload for Msg/SendTx
*
* @generated from message ibc.applications.interchain_accounts.controller.v1.MsgSendTx
*/
export class MsgSendTx extends Message<MsgSendTx> {
/**
* @generated from field: string owner = 1;
*/
owner = "";
/**
* @generated from field: string connection_id = 2;
*/
connectionId = "";
/**
* @generated from field: ibc.applications.interchain_accounts.v1.InterchainAccountPacketData packet_data = 3;
*/
packetData?: InterchainAccountPacketData;
/**
* Relative timeout timestamp provided will be added to the current block time during transaction execution.
* The timeout timestamp must be non-zero.
*
* @generated from field: uint64 relative_timeout = 4;
*/
relativeTimeout = protoInt64.zero;
constructor(data?: PartialMessage<MsgSendTx>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.controller.v1.MsgSendTx";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "owner", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "connection_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "packet_data", kind: "message", T: InterchainAccountPacketData },
{ no: 4, name: "relative_timeout", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgSendTx {
return new MsgSendTx().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgSendTx {
return new MsgSendTx().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgSendTx {
return new MsgSendTx().fromJsonString(jsonString, options);
}
static equals(a: MsgSendTx | PlainMessage<MsgSendTx> | undefined, b: MsgSendTx | PlainMessage<MsgSendTx> | undefined): boolean {
return proto3.util.equals(MsgSendTx, a, b);
}
}
/**
* MsgSendTxResponse defines the response for MsgSendTx
*
* @generated from message ibc.applications.interchain_accounts.controller.v1.MsgSendTxResponse
*/
export class MsgSendTxResponse extends Message<MsgSendTxResponse> {
/**
* @generated from field: uint64 sequence = 1;
*/
sequence = protoInt64.zero;
constructor(data?: PartialMessage<MsgSendTxResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.controller.v1.MsgSendTxResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgSendTxResponse {
return new MsgSendTxResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgSendTxResponse {
return new MsgSendTxResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgSendTxResponse {
return new MsgSendTxResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgSendTxResponse | PlainMessage<MsgSendTxResponse> | undefined, b: MsgSendTxResponse | PlainMessage<MsgSendTxResponse> | undefined): boolean {
return proto3.util.equals(MsgSendTxResponse, a, b);
}
}
/**
* MsgUpdateParams defines the payload for Msg/UpdateParams
*
* @generated from message ibc.applications.interchain_accounts.controller.v1.MsgUpdateParams
*/
export class MsgUpdateParams extends Message<MsgUpdateParams> {
/**
* signer address
*
* @generated from field: string signer = 1;
*/
signer = "";
/**
* params defines the 27-interchain-accounts/controller parameters to update.
*
* NOTE: All parameters must be supplied.
*
* @generated from field: ibc.applications.interchain_accounts.controller.v1.Params params = 2;
*/
params?: Params;
constructor(data?: PartialMessage<MsgUpdateParams>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.controller.v1.MsgUpdateParams";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "signer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "params", kind: "message", T: Params },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgUpdateParams {
return new MsgUpdateParams().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgUpdateParams {
return new MsgUpdateParams().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgUpdateParams {
return new MsgUpdateParams().fromJsonString(jsonString, options);
}
static equals(a: MsgUpdateParams | PlainMessage<MsgUpdateParams> | undefined, b: MsgUpdateParams | PlainMessage<MsgUpdateParams> | undefined): boolean {
return proto3.util.equals(MsgUpdateParams, a, b);
}
}
/**
* MsgUpdateParamsResponse defines the response for Msg/UpdateParams
*
* @generated from message ibc.applications.interchain_accounts.controller.v1.MsgUpdateParamsResponse
*/
export class MsgUpdateParamsResponse extends Message<MsgUpdateParamsResponse> {
constructor(data?: PartialMessage<MsgUpdateParamsResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.controller.v1.MsgUpdateParamsResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgUpdateParamsResponse {
return new MsgUpdateParamsResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgUpdateParamsResponse {
return new MsgUpdateParamsResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgUpdateParamsResponse {
return new MsgUpdateParamsResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgUpdateParamsResponse | PlainMessage<MsgUpdateParamsResponse> | undefined, b: MsgUpdateParamsResponse | PlainMessage<MsgUpdateParamsResponse> | undefined): boolean {
return proto3.util.equals(MsgUpdateParamsResponse, a, b);
}
}

278
libs/es-client/src/protobufs/ibc/applications/interchain_accounts/genesis/v1/genesis_pb.ts Normal file
View File

@ -0,0 +1,278 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/interchain_accounts/genesis/v1/genesis.proto (package ibc.applications.interchain_accounts.genesis.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { Params } from "../../controller/v1/controller_pb.js";
import { Params as Params$1 } from "../../host/v1/host_pb.js";
/**
* GenesisState defines the interchain accounts genesis state
*
* @generated from message ibc.applications.interchain_accounts.genesis.v1.GenesisState
*/
export class GenesisState extends Message<GenesisState> {
/**
* @generated from field: ibc.applications.interchain_accounts.genesis.v1.ControllerGenesisState controller_genesis_state = 1;
*/
controllerGenesisState?: ControllerGenesisState;
/**
* @generated from field: ibc.applications.interchain_accounts.genesis.v1.HostGenesisState host_genesis_state = 2;
*/
hostGenesisState?: HostGenesisState;
constructor(data?: PartialMessage<GenesisState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.genesis.v1.GenesisState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "controller_genesis_state", kind: "message", T: ControllerGenesisState },
{ no: 2, name: "host_genesis_state", kind: "message", T: HostGenesisState },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GenesisState {
return new GenesisState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJsonString(jsonString, options);
}
static equals(a: GenesisState | PlainMessage<GenesisState> | undefined, b: GenesisState | PlainMessage<GenesisState> | undefined): boolean {
return proto3.util.equals(GenesisState, a, b);
}
}
/**
* ControllerGenesisState defines the interchain accounts controller genesis state
*
* @generated from message ibc.applications.interchain_accounts.genesis.v1.ControllerGenesisState
*/
export class ControllerGenesisState extends Message<ControllerGenesisState> {
/**
* @generated from field: repeated ibc.applications.interchain_accounts.genesis.v1.ActiveChannel active_channels = 1;
*/
activeChannels: ActiveChannel[] = [];
/**
* @generated from field: repeated ibc.applications.interchain_accounts.genesis.v1.RegisteredInterchainAccount interchain_accounts = 2;
*/
interchainAccounts: RegisteredInterchainAccount[] = [];
/**
* @generated from field: repeated string ports = 3;
*/
ports: string[] = [];
/**
* @generated from field: ibc.applications.interchain_accounts.controller.v1.Params params = 4;
*/
params?: Params;
constructor(data?: PartialMessage<ControllerGenesisState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.genesis.v1.ControllerGenesisState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "active_channels", kind: "message", T: ActiveChannel, repeated: true },
{ no: 2, name: "interchain_accounts", kind: "message", T: RegisteredInterchainAccount, repeated: true },
{ no: 3, name: "ports", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
{ no: 4, name: "params", kind: "message", T: Params },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ControllerGenesisState {
return new ControllerGenesisState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ControllerGenesisState {
return new ControllerGenesisState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ControllerGenesisState {
return new ControllerGenesisState().fromJsonString(jsonString, options);
}
static equals(a: ControllerGenesisState | PlainMessage<ControllerGenesisState> | undefined, b: ControllerGenesisState | PlainMessage<ControllerGenesisState> | undefined): boolean {
return proto3.util.equals(ControllerGenesisState, a, b);
}
}
/**
* HostGenesisState defines the interchain accounts host genesis state
*
* @generated from message ibc.applications.interchain_accounts.genesis.v1.HostGenesisState
*/
export class HostGenesisState extends Message<HostGenesisState> {
/**
* @generated from field: repeated ibc.applications.interchain_accounts.genesis.v1.ActiveChannel active_channels = 1;
*/
activeChannels: ActiveChannel[] = [];
/**
* @generated from field: repeated ibc.applications.interchain_accounts.genesis.v1.RegisteredInterchainAccount interchain_accounts = 2;
*/
interchainAccounts: RegisteredInterchainAccount[] = [];
/**
* @generated from field: string port = 3;
*/
port = "";
/**
* @generated from field: ibc.applications.interchain_accounts.host.v1.Params params = 4;
*/
params?: Params$1;
constructor(data?: PartialMessage<HostGenesisState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.genesis.v1.HostGenesisState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "active_channels", kind: "message", T: ActiveChannel, repeated: true },
{ no: 2, name: "interchain_accounts", kind: "message", T: RegisteredInterchainAccount, repeated: true },
{ no: 3, name: "port", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "params", kind: "message", T: Params$1 },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HostGenesisState {
return new HostGenesisState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HostGenesisState {
return new HostGenesisState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HostGenesisState {
return new HostGenesisState().fromJsonString(jsonString, options);
}
static equals(a: HostGenesisState | PlainMessage<HostGenesisState> | undefined, b: HostGenesisState | PlainMessage<HostGenesisState> | undefined): boolean {
return proto3.util.equals(HostGenesisState, a, b);
}
}
/**
* ActiveChannel contains a connection ID, port ID and associated active channel ID, as well as a boolean flag to
* indicate if the channel is middleware enabled
*
* @generated from message ibc.applications.interchain_accounts.genesis.v1.ActiveChannel
*/
export class ActiveChannel extends Message<ActiveChannel> {
/**
* @generated from field: string connection_id = 1;
*/
connectionId = "";
/**
* @generated from field: string port_id = 2;
*/
portId = "";
/**
* @generated from field: string channel_id = 3;
*/
channelId = "";
/**
* @generated from field: bool is_middleware_enabled = 4;
*/
isMiddlewareEnabled = false;
constructor(data?: PartialMessage<ActiveChannel>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.genesis.v1.ActiveChannel";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "connection_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "port_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "channel_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "is_middleware_enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ActiveChannel {
return new ActiveChannel().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ActiveChannel {
return new ActiveChannel().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ActiveChannel {
return new ActiveChannel().fromJsonString(jsonString, options);
}
static equals(a: ActiveChannel | PlainMessage<ActiveChannel> | undefined, b: ActiveChannel | PlainMessage<ActiveChannel> | undefined): boolean {
return proto3.util.equals(ActiveChannel, a, b);
}
}
/**
* RegisteredInterchainAccount contains a connection ID, port ID and associated interchain account address
*
* @generated from message ibc.applications.interchain_accounts.genesis.v1.RegisteredInterchainAccount
*/
export class RegisteredInterchainAccount extends Message<RegisteredInterchainAccount> {
/**
* @generated from field: string connection_id = 1;
*/
connectionId = "";
/**
* @generated from field: string port_id = 2;
*/
portId = "";
/**
* @generated from field: string account_address = 3;
*/
accountAddress = "";
constructor(data?: PartialMessage<RegisteredInterchainAccount>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.genesis.v1.RegisteredInterchainAccount";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "connection_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "port_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "account_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RegisteredInterchainAccount {
return new RegisteredInterchainAccount().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RegisteredInterchainAccount {
return new RegisteredInterchainAccount().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RegisteredInterchainAccount {
return new RegisteredInterchainAccount().fromJsonString(jsonString, options);
}
static equals(a: RegisteredInterchainAccount | PlainMessage<RegisteredInterchainAccount> | undefined, b: RegisteredInterchainAccount | PlainMessage<RegisteredInterchainAccount> | undefined): boolean {
return proto3.util.equals(RegisteredInterchainAccount, a, b);
}
}

110
libs/es-client/src/protobufs/ibc/applications/interchain_accounts/host/v1/host_pb.ts Normal file
View File

@ -0,0 +1,110 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/interchain_accounts/host/v1/host.proto (package ibc.applications.interchain_accounts.host.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
/**
* Params defines the set of on-chain interchain accounts parameters.
* The following parameters may be used to disable the host submodule.
*
* @generated from message ibc.applications.interchain_accounts.host.v1.Params
*/
export class Params extends Message<Params> {
/**
* host_enabled enables or disables the host submodule.
*
* @generated from field: bool host_enabled = 1;
*/
hostEnabled = false;
/**
* allow_messages defines a list of sdk message typeURLs allowed to be executed on a host chain.
*
* @generated from field: repeated string allow_messages = 2;
*/
allowMessages: string[] = [];
constructor(data?: PartialMessage<Params>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.host.v1.Params";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "host_enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
{ no: 2, name: "allow_messages", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Params {
return new Params().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Params {
return new Params().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Params {
return new Params().fromJsonString(jsonString, options);
}
static equals(a: Params | PlainMessage<Params> | undefined, b: Params | PlainMessage<Params> | undefined): boolean {
return proto3.util.equals(Params, a, b);
}
}
/**
* QueryRequest defines the parameters for a particular query request
* by an interchain account.
*
* @generated from message ibc.applications.interchain_accounts.host.v1.QueryRequest
*/
export class QueryRequest extends Message<QueryRequest> {
/**
* path defines the path of the query request as defined by ADR-021.
* https://github.com/cosmos/cosmos-sdk/blob/main/docs/architecture/adr-021-protobuf-query-encoding.md#custom-query-registration-and-routing
*
* @generated from field: string path = 1;
*/
path = "";
/**
* data defines the payload of the query request as defined by ADR-021.
* https://github.com/cosmos/cosmos-sdk/blob/main/docs/architecture/adr-021-protobuf-query-encoding.md#custom-query-registration-and-routing
*
* @generated from field: bytes data = 2;
*/
data = new Uint8Array(0);
constructor(data?: PartialMessage<QueryRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.host.v1.QueryRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "data", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryRequest {
return new QueryRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryRequest {
return new QueryRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryRequest {
return new QueryRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryRequest | PlainMessage<QueryRequest> | undefined, b: QueryRequest | PlainMessage<QueryRequest> | undefined): boolean {
return proto3.util.equals(QueryRequest, a, b);
}
}

21
libs/es-client/src/protobufs/ibc/applications/interchain_accounts/host/v1/query_cosmes.ts Normal file
View File

@ -0,0 +1,21 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file ibc/applications/interchain_accounts/host/v1/query.proto (package ibc.applications.interchain_accounts.host.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { QueryParamsRequest, QueryParamsResponse } from "./query_pb.js";
const TYPE_NAME = "ibc.applications.interchain_accounts.host.v1.Query";
/**
* Params queries all parameters of the ICA host submodule.
*
* @generated from rpc ibc.applications.interchain_accounts.host.v1.Query.Params
*/
export const QueryParamsService = {
typeName: TYPE_NAME,
method: "Params",
Request: QueryParamsRequest,
Response: QueryParamsResponse,
} as const;

83
libs/es-client/src/protobufs/ibc/applications/interchain_accounts/host/v1/query_pb.ts Normal file
View File

@ -0,0 +1,83 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/interchain_accounts/host/v1/query.proto (package ibc.applications.interchain_accounts.host.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { Params } from "./host_pb.js";
/**
* QueryParamsRequest is the request type for the Query/Params RPC method.
*
* @generated from message ibc.applications.interchain_accounts.host.v1.QueryParamsRequest
*/
export class QueryParamsRequest extends Message<QueryParamsRequest> {
constructor(data?: PartialMessage<QueryParamsRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.host.v1.QueryParamsRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryParamsRequest {
return new QueryParamsRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryParamsRequest {
return new QueryParamsRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryParamsRequest {
return new QueryParamsRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryParamsRequest | PlainMessage<QueryParamsRequest> | undefined, b: QueryParamsRequest | PlainMessage<QueryParamsRequest> | undefined): boolean {
return proto3.util.equals(QueryParamsRequest, a, b);
}
}
/**
* QueryParamsResponse is the response type for the Query/Params RPC method.
*
* @generated from message ibc.applications.interchain_accounts.host.v1.QueryParamsResponse
*/
export class QueryParamsResponse extends Message<QueryParamsResponse> {
/**
* params defines the parameters of the module.
*
* @generated from field: ibc.applications.interchain_accounts.host.v1.Params params = 1;
*/
params?: Params;
constructor(data?: PartialMessage<QueryParamsResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.host.v1.QueryParamsResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "params", kind: "message", T: Params },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryParamsResponse {
return new QueryParamsResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryParamsResponse {
return new QueryParamsResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryParamsResponse {
return new QueryParamsResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryParamsResponse | PlainMessage<QueryParamsResponse> | undefined, b: QueryParamsResponse | PlainMessage<QueryParamsResponse> | undefined): boolean {
return proto3.util.equals(QueryParamsResponse, a, b);
}
}

33
libs/es-client/src/protobufs/ibc/applications/interchain_accounts/host/v1/tx_cosmes.ts Normal file
View File

@ -0,0 +1,33 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file ibc/applications/interchain_accounts/host/v1/tx.proto (package ibc.applications.interchain_accounts.host.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { MsgModuleQuerySafe, MsgModuleQuerySafeResponse, MsgUpdateParams, MsgUpdateParamsResponse } from "./tx_pb.js";
const TYPE_NAME = "ibc.applications.interchain_accounts.host.v1.Msg";
/**
* UpdateParams defines a rpc handler for MsgUpdateParams.
*
* @generated from rpc ibc.applications.interchain_accounts.host.v1.Msg.UpdateParams
*/
export const MsgUpdateParamsService = {
typeName: TYPE_NAME,
method: "UpdateParams",
Request: MsgUpdateParams,
Response: MsgUpdateParamsResponse,
} as const;
/**
* ModuleQuerySafe defines a rpc handler for MsgModuleQuerySafe.
*
* @generated from rpc ibc.applications.interchain_accounts.host.v1.Msg.ModuleQuerySafe
*/
export const MsgModuleQuerySafeService = {
typeName: TYPE_NAME,
method: "ModuleQuerySafe",
Request: MsgModuleQuerySafe,
Response: MsgModuleQuerySafeResponse,
} as const;

191
libs/es-client/src/protobufs/ibc/applications/interchain_accounts/host/v1/tx_pb.ts Normal file
View File

@ -0,0 +1,191 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/interchain_accounts/host/v1/tx.proto (package ibc.applications.interchain_accounts.host.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, protoInt64 } from "@bufbuild/protobuf";
import { Params, QueryRequest } from "./host_pb.js";
/**
* MsgUpdateParams defines the payload for Msg/UpdateParams
*
* @generated from message ibc.applications.interchain_accounts.host.v1.MsgUpdateParams
*/
export class MsgUpdateParams extends Message<MsgUpdateParams> {
/**
* signer address
*
* @generated from field: string signer = 1;
*/
signer = "";
/**
* params defines the 27-interchain-accounts/host parameters to update.
*
* NOTE: All parameters must be supplied.
*
* @generated from field: ibc.applications.interchain_accounts.host.v1.Params params = 2;
*/
params?: Params;
constructor(data?: PartialMessage<MsgUpdateParams>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.host.v1.MsgUpdateParams";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "signer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "params", kind: "message", T: Params },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgUpdateParams {
return new MsgUpdateParams().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgUpdateParams {
return new MsgUpdateParams().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgUpdateParams {
return new MsgUpdateParams().fromJsonString(jsonString, options);
}
static equals(a: MsgUpdateParams | PlainMessage<MsgUpdateParams> | undefined, b: MsgUpdateParams | PlainMessage<MsgUpdateParams> | undefined): boolean {
return proto3.util.equals(MsgUpdateParams, a, b);
}
}
/**
* MsgUpdateParamsResponse defines the response for Msg/UpdateParams
*
* @generated from message ibc.applications.interchain_accounts.host.v1.MsgUpdateParamsResponse
*/
export class MsgUpdateParamsResponse extends Message<MsgUpdateParamsResponse> {
constructor(data?: PartialMessage<MsgUpdateParamsResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.host.v1.MsgUpdateParamsResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgUpdateParamsResponse {
return new MsgUpdateParamsResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgUpdateParamsResponse {
return new MsgUpdateParamsResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgUpdateParamsResponse {
return new MsgUpdateParamsResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgUpdateParamsResponse | PlainMessage<MsgUpdateParamsResponse> | undefined, b: MsgUpdateParamsResponse | PlainMessage<MsgUpdateParamsResponse> | undefined): boolean {
return proto3.util.equals(MsgUpdateParamsResponse, a, b);
}
}
/**
* MsgModuleQuerySafe defines the payload for Msg/ModuleQuerySafe
*
* @generated from message ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafe
*/
export class MsgModuleQuerySafe extends Message<MsgModuleQuerySafe> {
/**
* signer address
*
* @generated from field: string signer = 1;
*/
signer = "";
/**
* requests defines the module safe queries to execute.
*
* @generated from field: repeated ibc.applications.interchain_accounts.host.v1.QueryRequest requests = 2;
*/
requests: QueryRequest[] = [];
constructor(data?: PartialMessage<MsgModuleQuerySafe>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafe";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "signer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "requests", kind: "message", T: QueryRequest, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgModuleQuerySafe {
return new MsgModuleQuerySafe().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgModuleQuerySafe {
return new MsgModuleQuerySafe().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgModuleQuerySafe {
return new MsgModuleQuerySafe().fromJsonString(jsonString, options);
}
static equals(a: MsgModuleQuerySafe | PlainMessage<MsgModuleQuerySafe> | undefined, b: MsgModuleQuerySafe | PlainMessage<MsgModuleQuerySafe> | undefined): boolean {
return proto3.util.equals(MsgModuleQuerySafe, a, b);
}
}
/**
* MsgModuleQuerySafeResponse defines the response for Msg/ModuleQuerySafe
*
* @generated from message ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafeResponse
*/
export class MsgModuleQuerySafeResponse extends Message<MsgModuleQuerySafeResponse> {
/**
* height at which the responses were queried
*
* @generated from field: uint64 height = 1;
*/
height = protoInt64.zero;
/**
* protobuf encoded responses for each query
*
* @generated from field: repeated bytes responses = 2;
*/
responses: Uint8Array[] = [];
constructor(data?: PartialMessage<MsgModuleQuerySafeResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafeResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "height", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 2, name: "responses", kind: "scalar", T: 12 /* ScalarType.BYTES */, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgModuleQuerySafeResponse {
return new MsgModuleQuerySafeResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgModuleQuerySafeResponse {
return new MsgModuleQuerySafeResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgModuleQuerySafeResponse {
return new MsgModuleQuerySafeResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgModuleQuerySafeResponse | PlainMessage<MsgModuleQuerySafeResponse> | undefined, b: MsgModuleQuerySafeResponse | PlainMessage<MsgModuleQuerySafeResponse> | undefined): boolean {
return proto3.util.equals(MsgModuleQuerySafeResponse, a, b);
}
}

54
libs/es-client/src/protobufs/ibc/applications/interchain_accounts/v1/account_pb.ts Normal file
View File

@ -0,0 +1,54 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/interchain_accounts/v1/account.proto (package ibc.applications.interchain_accounts.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { BaseAccount } from "../../../../cosmos/auth/v1beta1/auth_pb.js";
/**
* An InterchainAccount is defined as a BaseAccount & the address of the account owner on the controller chain
*
* @generated from message ibc.applications.interchain_accounts.v1.InterchainAccount
*/
export class InterchainAccount extends Message<InterchainAccount> {
/**
* @generated from field: cosmos.auth.v1beta1.BaseAccount base_account = 1;
*/
baseAccount?: BaseAccount;
/**
* @generated from field: string account_owner = 2;
*/
accountOwner = "";
constructor(data?: PartialMessage<InterchainAccount>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.v1.InterchainAccount";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "base_account", kind: "message", T: BaseAccount },
{ no: 2, name: "account_owner", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InterchainAccount {
return new InterchainAccount().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InterchainAccount {
return new InterchainAccount().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InterchainAccount {
return new InterchainAccount().fromJsonString(jsonString, options);
}
static equals(a: InterchainAccount | PlainMessage<InterchainAccount> | undefined, b: InterchainAccount | PlainMessage<InterchainAccount> | undefined): boolean {
return proto3.util.equals(InterchainAccount, a, b);
}
}

91
libs/es-client/src/protobufs/ibc/applications/interchain_accounts/v1/metadata_pb.ts Normal file
View File

@ -0,0 +1,91 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/interchain_accounts/v1/metadata.proto (package ibc.applications.interchain_accounts.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
/**
* Metadata defines a set of protocol specific data encoded into the ICS27 channel version bytestring
* See ICS004: https://github.com/cosmos/ibc/tree/master/spec/core/ics-004-channel-and-packet-semantics#Versioning
*
* @generated from message ibc.applications.interchain_accounts.v1.Metadata
*/
export class Metadata extends Message<Metadata> {
/**
* version defines the ICS27 protocol version
*
* @generated from field: string version = 1;
*/
version = "";
/**
* controller_connection_id is the connection identifier associated with the controller chain
*
* @generated from field: string controller_connection_id = 2;
*/
controllerConnectionId = "";
/**
* host_connection_id is the connection identifier associated with the host chain
*
* @generated from field: string host_connection_id = 3;
*/
hostConnectionId = "";
/**
* address defines the interchain account address to be fulfilled upon the OnChanOpenTry handshake step
* NOTE: the address field is empty on the OnChanOpenInit handshake step
*
* @generated from field: string address = 4;
*/
address = "";
/**
* encoding defines the supported codec format
*
* @generated from field: string encoding = 5;
*/
encoding = "";
/**
* tx_type defines the type of transactions the interchain account can execute
*
* @generated from field: string tx_type = 6;
*/
txType = "";
constructor(data?: PartialMessage<Metadata>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.v1.Metadata";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "version", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "controller_connection_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "host_connection_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 5, name: "encoding", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 6, name: "tx_type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Metadata {
return new Metadata().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Metadata {
return new Metadata().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Metadata {
return new Metadata().fromJsonString(jsonString, options);
}
static equals(a: Metadata | PlainMessage<Metadata> | undefined, b: Metadata | PlainMessage<Metadata> | undefined): boolean {
return proto3.util.equals(Metadata, a, b);
}
}

125
libs/es-client/src/protobufs/ibc/applications/interchain_accounts/v1/packet_pb.ts Normal file
View File

@ -0,0 +1,125 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/interchain_accounts/v1/packet.proto (package ibc.applications.interchain_accounts.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Any, Message, proto3 } from "@bufbuild/protobuf";
/**
* Type defines a classification of message issued from a controller chain to its associated interchain accounts
* host
*
* @generated from enum ibc.applications.interchain_accounts.v1.Type
*/
export enum Type {
/**
* Default zero value enumeration
*
* @generated from enum value: TYPE_UNSPECIFIED = 0;
*/
UNSPECIFIED = 0,
/**
* Execute a transaction on an interchain accounts host chain
*
* @generated from enum value: TYPE_EXECUTE_TX = 1;
*/
EXECUTE_TX = 1,
}
// Retrieve enum metadata with: proto3.getEnumType(Type)
proto3.util.setEnumType(Type, "ibc.applications.interchain_accounts.v1.Type", [
{ no: 0, name: "TYPE_UNSPECIFIED" },
{ no: 1, name: "TYPE_EXECUTE_TX" },
]);
/**
* InterchainAccountPacketData is comprised of a raw transaction, type of transaction and optional memo field.
*
* @generated from message ibc.applications.interchain_accounts.v1.InterchainAccountPacketData
*/
export class InterchainAccountPacketData extends Message<InterchainAccountPacketData> {
/**
* @generated from field: ibc.applications.interchain_accounts.v1.Type type = 1;
*/
type = Type.UNSPECIFIED;
/**
* @generated from field: bytes data = 2;
*/
data = new Uint8Array(0);
/**
* @generated from field: string memo = 3;
*/
memo = "";
constructor(data?: PartialMessage<InterchainAccountPacketData>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.v1.InterchainAccountPacketData";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "type", kind: "enum", T: proto3.getEnumType(Type) },
{ no: 2, name: "data", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 3, name: "memo", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InterchainAccountPacketData {
return new InterchainAccountPacketData().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InterchainAccountPacketData {
return new InterchainAccountPacketData().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InterchainAccountPacketData {
return new InterchainAccountPacketData().fromJsonString(jsonString, options);
}
static equals(a: InterchainAccountPacketData | PlainMessage<InterchainAccountPacketData> | undefined, b: InterchainAccountPacketData | PlainMessage<InterchainAccountPacketData> | undefined): boolean {
return proto3.util.equals(InterchainAccountPacketData, a, b);
}
}
/**
* CosmosTx contains a list of sdk.Msg's. It should be used when sending transactions to an SDK host chain.
*
* @generated from message ibc.applications.interchain_accounts.v1.CosmosTx
*/
export class CosmosTx extends Message<CosmosTx> {
/**
* @generated from field: repeated google.protobuf.Any messages = 1;
*/
messages: Any[] = [];
constructor(data?: PartialMessage<CosmosTx>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.interchain_accounts.v1.CosmosTx";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "messages", kind: "message", T: Any, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CosmosTx {
return new CosmosTx().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CosmosTx {
return new CosmosTx().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CosmosTx {
return new CosmosTx().fromJsonString(jsonString, options);
}
static equals(a: CosmosTx | PlainMessage<CosmosTx> | undefined, b: CosmosTx | PlainMessage<CosmosTx> | undefined): boolean {
return proto3.util.equals(CosmosTx, a, b);
}
}

176
libs/es-client/src/protobufs/ibc/applications/transfer/v1/authz_pb.ts Normal file
View File

@ -0,0 +1,176 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/transfer/v1/authz.proto (package ibc.applications.transfer.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { Coin } from "../../../../cosmos/base/v1beta1/coin_pb.js";
import { Hop } from "./transfer_pb.js";
/**
* Allocation defines the spend limit for a particular port and channel
*
* @generated from message ibc.applications.transfer.v1.Allocation
*/
export class Allocation extends Message<Allocation> {
/**
* the port on which the packet will be sent
*
* @generated from field: string source_port = 1;
*/
sourcePort = "";
/**
* the channel by which the packet will be sent
*
* @generated from field: string source_channel = 2;
*/
sourceChannel = "";
/**
* spend limitation on the channel
*
* @generated from field: repeated cosmos.base.v1beta1.Coin spend_limit = 3;
*/
spendLimit: Coin[] = [];
/**
* allow list of receivers, an empty allow list permits any receiver address
*
* @generated from field: repeated string allow_list = 4;
*/
allowList: string[] = [];
/**
* allow list of memo strings, an empty list prohibits all memo strings;
* a list only with "*" permits any memo string
*
* @generated from field: repeated string allowed_packet_data = 5;
*/
allowedPacketData: string[] = [];
/**
* Forwarding options that are allowed.
*
* @generated from field: repeated ibc.applications.transfer.v1.AllowedForwarding allowed_forwarding = 6;
*/
allowedForwarding: AllowedForwarding[] = [];
constructor(data?: PartialMessage<Allocation>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v1.Allocation";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "source_port", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "source_channel", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "spend_limit", kind: "message", T: Coin, repeated: true },
{ no: 4, name: "allow_list", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
{ no: 5, name: "allowed_packet_data", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
{ no: 6, name: "allowed_forwarding", kind: "message", T: AllowedForwarding, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Allocation {
return new Allocation().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Allocation {
return new Allocation().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Allocation {
return new Allocation().fromJsonString(jsonString, options);
}
static equals(a: Allocation | PlainMessage<Allocation> | undefined, b: Allocation | PlainMessage<Allocation> | undefined): boolean {
return proto3.util.equals(Allocation, a, b);
}
}
/**
* AllowedForwarding defines which options are allowed for forwarding.
*
* @generated from message ibc.applications.transfer.v1.AllowedForwarding
*/
export class AllowedForwarding extends Message<AllowedForwarding> {
/**
* a list of allowed source port ID/channel ID pairs through which the packet is allowed to be forwarded until final
* destination
*
* @generated from field: repeated ibc.applications.transfer.v1.Hop hops = 1;
*/
hops: Hop[] = [];
constructor(data?: PartialMessage<AllowedForwarding>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v1.AllowedForwarding";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "hops", kind: "message", T: Hop, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AllowedForwarding {
return new AllowedForwarding().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AllowedForwarding {
return new AllowedForwarding().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AllowedForwarding {
return new AllowedForwarding().fromJsonString(jsonString, options);
}
static equals(a: AllowedForwarding | PlainMessage<AllowedForwarding> | undefined, b: AllowedForwarding | PlainMessage<AllowedForwarding> | undefined): boolean {
return proto3.util.equals(AllowedForwarding, a, b);
}
}
/**
* TransferAuthorization allows the grantee to spend up to spend_limit coins from
* the granter's account for ibc transfer on a specific channel
*
* @generated from message ibc.applications.transfer.v1.TransferAuthorization
*/
export class TransferAuthorization extends Message<TransferAuthorization> {
/**
* port and channel amounts
*
* @generated from field: repeated ibc.applications.transfer.v1.Allocation allocations = 1;
*/
allocations: Allocation[] = [];
constructor(data?: PartialMessage<TransferAuthorization>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v1.TransferAuthorization";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "allocations", kind: "message", T: Allocation, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TransferAuthorization {
return new TransferAuthorization().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TransferAuthorization {
return new TransferAuthorization().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TransferAuthorization {
return new TransferAuthorization().fromJsonString(jsonString, options);
}
static equals(a: TransferAuthorization | PlainMessage<TransferAuthorization> | undefined, b: TransferAuthorization | PlainMessage<TransferAuthorization> | undefined): boolean {
return proto3.util.equals(TransferAuthorization, a, b);
}
}

60
libs/es-client/src/protobufs/ibc/applications/transfer/v1/denomtrace_pb.ts Normal file
View File

@ -0,0 +1,60 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/transfer/v1/denomtrace.proto (package ibc.applications.transfer.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
/**
* DenomTrace contains the base denomination for ICS20 fungible tokens and the
* source tracing information path.
*
* @generated from message ibc.applications.transfer.v1.DenomTrace
* @deprecated
*/
export class DenomTrace extends Message<DenomTrace> {
/**
* path defines the chain of port/channel identifiers used for tracing the
* source of the fungible token.
*
* @generated from field: string path = 1;
*/
path = "";
/**
* base denomination of the relayed fungible token.
*
* @generated from field: string base_denom = 2;
*/
baseDenom = "";
constructor(data?: PartialMessage<DenomTrace>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v1.DenomTrace";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "base_denom", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DenomTrace {
return new DenomTrace().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DenomTrace {
return new DenomTrace().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DenomTrace {
return new DenomTrace().fromJsonString(jsonString, options);
}
static equals(a: DenomTrace | PlainMessage<DenomTrace> | undefined, b: DenomTrace | PlainMessage<DenomTrace> | undefined): boolean {
return proto3.util.equals(DenomTrace, a, b);
}
}

57
libs/es-client/src/protobufs/ibc/applications/transfer/v1/query_cosmes.ts Normal file
View File

@ -0,0 +1,57 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file ibc/applications/transfer/v1/query.proto (package ibc.applications.transfer.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { QueryDenomHashRequest, QueryDenomHashResponse, QueryEscrowAddressRequest, QueryEscrowAddressResponse, QueryParamsRequest, QueryParamsResponse, QueryTotalEscrowForDenomRequest, QueryTotalEscrowForDenomResponse } from "./query_pb.js";
const TYPE_NAME = "ibc.applications.transfer.v1.Query";
/**
* Params queries all parameters of the ibc-transfer module.
*
* @generated from rpc ibc.applications.transfer.v1.Query.Params
*/
export const QueryParamsService = {
typeName: TYPE_NAME,
method: "Params",
Request: QueryParamsRequest,
Response: QueryParamsResponse,
} as const;
/**
* DenomHash queries a denomination hash information.
*
* @generated from rpc ibc.applications.transfer.v1.Query.DenomHash
*/
export const QueryDenomHashService = {
typeName: TYPE_NAME,
method: "DenomHash",
Request: QueryDenomHashRequest,
Response: QueryDenomHashResponse,
} as const;
/**
* EscrowAddress returns the escrow address for a particular port and channel id.
*
* @generated from rpc ibc.applications.transfer.v1.Query.EscrowAddress
*/
export const QueryEscrowAddressService = {
typeName: TYPE_NAME,
method: "EscrowAddress",
Request: QueryEscrowAddressRequest,
Response: QueryEscrowAddressResponse,
} as const;
/**
* TotalEscrowForDenom returns the total amount of tokens in escrow based on the denom.
*
* @generated from rpc ibc.applications.transfer.v1.Query.TotalEscrowForDenom
*/
export const QueryTotalEscrowForDenomService = {
typeName: TYPE_NAME,
method: "TotalEscrowForDenom",
Request: QueryTotalEscrowForDenomRequest,
Response: QueryTotalEscrowForDenomResponse,
} as const;

336
libs/es-client/src/protobufs/ibc/applications/transfer/v1/query_pb.ts Normal file
View File

@ -0,0 +1,336 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/transfer/v1/query.proto (package ibc.applications.transfer.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { Params } from "./transfer_pb.js";
import { Coin } from "../../../../cosmos/base/v1beta1/coin_pb.js";
/**
* QueryParamsRequest is the request type for the Query/Params RPC method.
*
* @generated from message ibc.applications.transfer.v1.QueryParamsRequest
*/
export class QueryParamsRequest extends Message<QueryParamsRequest> {
constructor(data?: PartialMessage<QueryParamsRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v1.QueryParamsRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryParamsRequest {
return new QueryParamsRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryParamsRequest {
return new QueryParamsRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryParamsRequest {
return new QueryParamsRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryParamsRequest | PlainMessage<QueryParamsRequest> | undefined, b: QueryParamsRequest | PlainMessage<QueryParamsRequest> | undefined): boolean {
return proto3.util.equals(QueryParamsRequest, a, b);
}
}
/**
* QueryParamsResponse is the response type for the Query/Params RPC method.
*
* @generated from message ibc.applications.transfer.v1.QueryParamsResponse
*/
export class QueryParamsResponse extends Message<QueryParamsResponse> {
/**
* params defines the parameters of the module.
*
* @generated from field: ibc.applications.transfer.v1.Params params = 1;
*/
params?: Params;
constructor(data?: PartialMessage<QueryParamsResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v1.QueryParamsResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "params", kind: "message", T: Params },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryParamsResponse {
return new QueryParamsResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryParamsResponse {
return new QueryParamsResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryParamsResponse {
return new QueryParamsResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryParamsResponse | PlainMessage<QueryParamsResponse> | undefined, b: QueryParamsResponse | PlainMessage<QueryParamsResponse> | undefined): boolean {
return proto3.util.equals(QueryParamsResponse, a, b);
}
}
/**
* QueryDenomHashRequest is the request type for the Query/DenomHash RPC
* method
*
* @generated from message ibc.applications.transfer.v1.QueryDenomHashRequest
*/
export class QueryDenomHashRequest extends Message<QueryDenomHashRequest> {
/**
* The denomination trace ([port_id]/[channel_id])+/[denom]
*
* @generated from field: string trace = 1;
*/
trace = "";
constructor(data?: PartialMessage<QueryDenomHashRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v1.QueryDenomHashRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "trace", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryDenomHashRequest {
return new QueryDenomHashRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryDenomHashRequest {
return new QueryDenomHashRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryDenomHashRequest {
return new QueryDenomHashRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryDenomHashRequest | PlainMessage<QueryDenomHashRequest> | undefined, b: QueryDenomHashRequest | PlainMessage<QueryDenomHashRequest> | undefined): boolean {
return proto3.util.equals(QueryDenomHashRequest, a, b);
}
}
/**
* QueryDenomHashResponse is the response type for the Query/DenomHash RPC
* method.
*
* @generated from message ibc.applications.transfer.v1.QueryDenomHashResponse
*/
export class QueryDenomHashResponse extends Message<QueryDenomHashResponse> {
/**
* hash (in hex format) of the denomination trace information.
*
* @generated from field: string hash = 1;
*/
hash = "";
constructor(data?: PartialMessage<QueryDenomHashResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v1.QueryDenomHashResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "hash", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryDenomHashResponse {
return new QueryDenomHashResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryDenomHashResponse {
return new QueryDenomHashResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryDenomHashResponse {
return new QueryDenomHashResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryDenomHashResponse | PlainMessage<QueryDenomHashResponse> | undefined, b: QueryDenomHashResponse | PlainMessage<QueryDenomHashResponse> | undefined): boolean {
return proto3.util.equals(QueryDenomHashResponse, a, b);
}
}
/**
* QueryEscrowAddressRequest is the request type for the EscrowAddress RPC method.
*
* @generated from message ibc.applications.transfer.v1.QueryEscrowAddressRequest
*/
export class QueryEscrowAddressRequest extends Message<QueryEscrowAddressRequest> {
/**
* unique port identifier
*
* @generated from field: string port_id = 1;
*/
portId = "";
/**
* unique channel identifier
*
* @generated from field: string channel_id = 2;
*/
channelId = "";
constructor(data?: PartialMessage<QueryEscrowAddressRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v1.QueryEscrowAddressRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "port_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "channel_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryEscrowAddressRequest {
return new QueryEscrowAddressRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryEscrowAddressRequest {
return new QueryEscrowAddressRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryEscrowAddressRequest {
return new QueryEscrowAddressRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryEscrowAddressRequest | PlainMessage<QueryEscrowAddressRequest> | undefined, b: QueryEscrowAddressRequest | PlainMessage<QueryEscrowAddressRequest> | undefined): boolean {
return proto3.util.equals(QueryEscrowAddressRequest, a, b);
}
}
/**
* QueryEscrowAddressResponse is the response type of the EscrowAddress RPC method.
*
* @generated from message ibc.applications.transfer.v1.QueryEscrowAddressResponse
*/
export class QueryEscrowAddressResponse extends Message<QueryEscrowAddressResponse> {
/**
* the escrow account address
*
* @generated from field: string escrow_address = 1;
*/
escrowAddress = "";
constructor(data?: PartialMessage<QueryEscrowAddressResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v1.QueryEscrowAddressResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "escrow_address", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryEscrowAddressResponse {
return new QueryEscrowAddressResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryEscrowAddressResponse {
return new QueryEscrowAddressResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryEscrowAddressResponse {
return new QueryEscrowAddressResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryEscrowAddressResponse | PlainMessage<QueryEscrowAddressResponse> | undefined, b: QueryEscrowAddressResponse | PlainMessage<QueryEscrowAddressResponse> | undefined): boolean {
return proto3.util.equals(QueryEscrowAddressResponse, a, b);
}
}
/**
* QueryTotalEscrowForDenomRequest is the request type for TotalEscrowForDenom RPC method.
*
* @generated from message ibc.applications.transfer.v1.QueryTotalEscrowForDenomRequest
*/
export class QueryTotalEscrowForDenomRequest extends Message<QueryTotalEscrowForDenomRequest> {
/**
* @generated from field: string denom = 1;
*/
denom = "";
constructor(data?: PartialMessage<QueryTotalEscrowForDenomRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v1.QueryTotalEscrowForDenomRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "denom", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryTotalEscrowForDenomRequest {
return new QueryTotalEscrowForDenomRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryTotalEscrowForDenomRequest {
return new QueryTotalEscrowForDenomRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryTotalEscrowForDenomRequest {
return new QueryTotalEscrowForDenomRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryTotalEscrowForDenomRequest | PlainMessage<QueryTotalEscrowForDenomRequest> | undefined, b: QueryTotalEscrowForDenomRequest | PlainMessage<QueryTotalEscrowForDenomRequest> | undefined): boolean {
return proto3.util.equals(QueryTotalEscrowForDenomRequest, a, b);
}
}
/**
* QueryTotalEscrowForDenomResponse is the response type for TotalEscrowForDenom RPC method.
*
* @generated from message ibc.applications.transfer.v1.QueryTotalEscrowForDenomResponse
*/
export class QueryTotalEscrowForDenomResponse extends Message<QueryTotalEscrowForDenomResponse> {
/**
* @generated from field: cosmos.base.v1beta1.Coin amount = 1;
*/
amount?: Coin;
constructor(data?: PartialMessage<QueryTotalEscrowForDenomResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v1.QueryTotalEscrowForDenomResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "amount", kind: "message", T: Coin },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryTotalEscrowForDenomResponse {
return new QueryTotalEscrowForDenomResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryTotalEscrowForDenomResponse {
return new QueryTotalEscrowForDenomResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryTotalEscrowForDenomResponse {
return new QueryTotalEscrowForDenomResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryTotalEscrowForDenomResponse | PlainMessage<QueryTotalEscrowForDenomResponse> | undefined, b: QueryTotalEscrowForDenomResponse | PlainMessage<QueryTotalEscrowForDenomResponse> | undefined): boolean {
return proto3.util.equals(QueryTotalEscrowForDenomResponse, a, b);
}
}

159
libs/es-client/src/protobufs/ibc/applications/transfer/v1/transfer_pb.ts Normal file
View File

@ -0,0 +1,159 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/transfer/v1/transfer.proto (package ibc.applications.transfer.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
/**
* Params defines the set of IBC transfer parameters.
* NOTE: To prevent a single token from being transferred, set the
* TransfersEnabled parameter to true and then set the bank module's SendEnabled
* parameter for the denomination to false.
*
* @generated from message ibc.applications.transfer.v1.Params
*/
export class Params extends Message<Params> {
/**
* send_enabled enables or disables all cross-chain token transfers from this
* chain.
*
* @generated from field: bool send_enabled = 1;
*/
sendEnabled = false;
/**
* receive_enabled enables or disables all cross-chain token transfers to this
* chain.
*
* @generated from field: bool receive_enabled = 2;
*/
receiveEnabled = false;
constructor(data?: PartialMessage<Params>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v1.Params";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "send_enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
{ no: 2, name: "receive_enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Params {
return new Params().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Params {
return new Params().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Params {
return new Params().fromJsonString(jsonString, options);
}
static equals(a: Params | PlainMessage<Params> | undefined, b: Params | PlainMessage<Params> | undefined): boolean {
return proto3.util.equals(Params, a, b);
}
}
/**
* Forwarding defines a list of port ID, channel ID pairs determining the path
* through which a packet must be forwarded, and an unwind boolean indicating if
* the coin should be unwinded to its native chain before forwarding.
*
* @generated from message ibc.applications.transfer.v1.Forwarding
*/
export class Forwarding extends Message<Forwarding> {
/**
* optional unwinding for the token transferred
*
* @generated from field: bool unwind = 1;
*/
unwind = false;
/**
* optional intermediate path through which packet will be forwarded
*
* @generated from field: repeated ibc.applications.transfer.v1.Hop hops = 2;
*/
hops: Hop[] = [];
constructor(data?: PartialMessage<Forwarding>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v1.Forwarding";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "unwind", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
{ no: 2, name: "hops", kind: "message", T: Hop, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Forwarding {
return new Forwarding().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Forwarding {
return new Forwarding().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Forwarding {
return new Forwarding().fromJsonString(jsonString, options);
}
static equals(a: Forwarding | PlainMessage<Forwarding> | undefined, b: Forwarding | PlainMessage<Forwarding> | undefined): boolean {
return proto3.util.equals(Forwarding, a, b);
}
}
/**
* Hop defines a port ID, channel ID pair specifying where tokens must be forwarded
* next in a multihop transfer.
*
* @generated from message ibc.applications.transfer.v1.Hop
*/
export class Hop extends Message<Hop> {
/**
* @generated from field: string port_id = 1;
*/
portId = "";
/**
* @generated from field: string channel_id = 2;
*/
channelId = "";
constructor(data?: PartialMessage<Hop>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v1.Hop";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "port_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "channel_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Hop {
return new Hop().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Hop {
return new Hop().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Hop {
return new Hop().fromJsonString(jsonString, options);
}
static equals(a: Hop | PlainMessage<Hop> | undefined, b: Hop | PlainMessage<Hop> | undefined): boolean {
return proto3.util.equals(Hop, a, b);
}
}

33
libs/es-client/src/protobufs/ibc/applications/transfer/v1/tx_cosmes.ts Normal file
View File

@ -0,0 +1,33 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file ibc/applications/transfer/v1/tx.proto (package ibc.applications.transfer.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { MsgTransfer, MsgTransferResponse, MsgUpdateParams, MsgUpdateParamsResponse } from "./tx_pb.js";
const TYPE_NAME = "ibc.applications.transfer.v1.Msg";
/**
* Transfer defines a rpc handler method for MsgTransfer.
*
* @generated from rpc ibc.applications.transfer.v1.Msg.Transfer
*/
export const MsgTransferService = {
typeName: TYPE_NAME,
method: "Transfer",
Request: MsgTransfer,
Response: MsgTransferResponse,
} as const;
/**
* UpdateParams defines a rpc handler for MsgUpdateParams.
*
* @generated from rpc ibc.applications.transfer.v1.Msg.UpdateParams
*/
export const MsgUpdateParamsService = {
typeName: TYPE_NAME,
method: "UpdateParams",
Request: MsgUpdateParams,
Response: MsgUpdateParamsResponse,
} as const;

255
libs/es-client/src/protobufs/ibc/applications/transfer/v1/tx_pb.ts Normal file
View File

@ -0,0 +1,255 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/transfer/v1/tx.proto (package ibc.applications.transfer.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, protoInt64 } from "@bufbuild/protobuf";
import { Coin } from "../../../../cosmos/base/v1beta1/coin_pb.js";
import { Height } from "../../../core/client/v1/client_pb.js";
import { Forwarding, Params } from "./transfer_pb.js";
/**
* MsgTransfer defines a msg to transfer fungible tokens (i.e Coins) between
* ICS20 enabled chains. See ICS Spec here:
* https://github.com/cosmos/ibc/tree/master/spec/app/ics-020-fungible-token-transfer#data-structures
*
* @generated from message ibc.applications.transfer.v1.MsgTransfer
*/
export class MsgTransfer extends Message<MsgTransfer> {
/**
* the port on which the packet will be sent
*
* @generated from field: string source_port = 1;
*/
sourcePort = "";
/**
* the channel by which the packet will be sent
*
* @generated from field: string source_channel = 2;
*/
sourceChannel = "";
/**
* the token to be transferred. this field has been replaced by the tokens field.
*
* @generated from field: cosmos.base.v1beta1.Coin token = 3 [deprecated = true];
* @deprecated
*/
token?: Coin;
/**
* the sender address
*
* @generated from field: string sender = 4;
*/
sender = "";
/**
* the recipient address on the destination chain
*
* @generated from field: string receiver = 5;
*/
receiver = "";
/**
* Timeout height relative to the current block height.
* The timeout is disabled when set to 0.
*
* @generated from field: ibc.core.client.v1.Height timeout_height = 6;
*/
timeoutHeight?: Height;
/**
* Timeout timestamp in absolute nanoseconds since unix epoch.
* The timeout is disabled when set to 0.
*
* @generated from field: uint64 timeout_timestamp = 7;
*/
timeoutTimestamp = protoInt64.zero;
/**
* optional memo
*
* @generated from field: string memo = 8;
*/
memo = "";
/**
* tokens to be transferred
*
* @generated from field: repeated cosmos.base.v1beta1.Coin tokens = 9;
*/
tokens: Coin[] = [];
/**
* optional forwarding information
*
* @generated from field: ibc.applications.transfer.v1.Forwarding forwarding = 10;
*/
forwarding?: Forwarding;
constructor(data?: PartialMessage<MsgTransfer>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v1.MsgTransfer";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "source_port", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "source_channel", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "token", kind: "message", T: Coin },
{ no: 4, name: "sender", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 5, name: "receiver", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 6, name: "timeout_height", kind: "message", T: Height },
{ no: 7, name: "timeout_timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 8, name: "memo", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 9, name: "tokens", kind: "message", T: Coin, repeated: true },
{ no: 10, name: "forwarding", kind: "message", T: Forwarding },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgTransfer {
return new MsgTransfer().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgTransfer {
return new MsgTransfer().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgTransfer {
return new MsgTransfer().fromJsonString(jsonString, options);
}
static equals(a: MsgTransfer | PlainMessage<MsgTransfer> | undefined, b: MsgTransfer | PlainMessage<MsgTransfer> | undefined): boolean {
return proto3.util.equals(MsgTransfer, a, b);
}
}
/**
* MsgTransferResponse defines the Msg/Transfer response type.
*
* @generated from message ibc.applications.transfer.v1.MsgTransferResponse
*/
export class MsgTransferResponse extends Message<MsgTransferResponse> {
/**
* sequence number of the transfer packet sent
*
* @generated from field: uint64 sequence = 1;
*/
sequence = protoInt64.zero;
constructor(data?: PartialMessage<MsgTransferResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v1.MsgTransferResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgTransferResponse {
return new MsgTransferResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgTransferResponse {
return new MsgTransferResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgTransferResponse {
return new MsgTransferResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgTransferResponse | PlainMessage<MsgTransferResponse> | undefined, b: MsgTransferResponse | PlainMessage<MsgTransferResponse> | undefined): boolean {
return proto3.util.equals(MsgTransferResponse, a, b);
}
}
/**
* MsgUpdateParams is the Msg/UpdateParams request type.
*
* @generated from message ibc.applications.transfer.v1.MsgUpdateParams
*/
export class MsgUpdateParams extends Message<MsgUpdateParams> {
/**
* signer address
*
* @generated from field: string signer = 1;
*/
signer = "";
/**
* params defines the transfer parameters to update.
*
* NOTE: All parameters must be supplied.
*
* @generated from field: ibc.applications.transfer.v1.Params params = 2;
*/
params?: Params;
constructor(data?: PartialMessage<MsgUpdateParams>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v1.MsgUpdateParams";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "signer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "params", kind: "message", T: Params },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgUpdateParams {
return new MsgUpdateParams().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgUpdateParams {
return new MsgUpdateParams().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgUpdateParams {
return new MsgUpdateParams().fromJsonString(jsonString, options);
}
static equals(a: MsgUpdateParams | PlainMessage<MsgUpdateParams> | undefined, b: MsgUpdateParams | PlainMessage<MsgUpdateParams> | undefined): boolean {
return proto3.util.equals(MsgUpdateParams, a, b);
}
}
/**
* MsgUpdateParamsResponse defines the response structure for executing a
* MsgUpdateParams message.
*
* @generated from message ibc.applications.transfer.v1.MsgUpdateParamsResponse
*/
export class MsgUpdateParamsResponse extends Message<MsgUpdateParamsResponse> {
constructor(data?: PartialMessage<MsgUpdateParamsResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v1.MsgUpdateParamsResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgUpdateParamsResponse {
return new MsgUpdateParamsResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgUpdateParamsResponse {
return new MsgUpdateParamsResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgUpdateParamsResponse {
return new MsgUpdateParamsResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgUpdateParamsResponse | PlainMessage<MsgUpdateParamsResponse> | undefined, b: MsgUpdateParamsResponse | PlainMessage<MsgUpdateParamsResponse> | undefined): boolean {
return proto3.util.equals(MsgUpdateParamsResponse, a, b);
}
}

126
libs/es-client/src/protobufs/ibc/applications/transfer/v2/genesis_pb.ts Normal file
View File

@ -0,0 +1,126 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/transfer/v2/genesis.proto (package ibc.applications.transfer.v2, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { Denom } from "./token_pb.js";
import { Params } from "../v1/transfer_pb.js";
import { Coin } from "../../../../cosmos/base/v1beta1/coin_pb.js";
import { Packet, PacketId } from "../../../core/channel/v1/channel_pb.js";
/**
* GenesisState defines the ibc-transfer genesis state
*
* @generated from message ibc.applications.transfer.v2.GenesisState
*/
export class GenesisState extends Message<GenesisState> {
/**
* @generated from field: string port_id = 1;
*/
portId = "";
/**
* @generated from field: repeated ibc.applications.transfer.v2.Denom denoms = 2;
*/
denoms: Denom[] = [];
/**
* @generated from field: ibc.applications.transfer.v1.Params params = 3;
*/
params?: Params;
/**
* total_escrowed contains the total amount of tokens escrowed
* by the transfer module
*
* @generated from field: repeated cosmos.base.v1beta1.Coin total_escrowed = 4;
*/
totalEscrowed: Coin[] = [];
/**
* forwarded_packets contains the forwarded packets stored as part of the
* packet forwarding lifecycle
*
* @generated from field: repeated ibc.applications.transfer.v2.ForwardedPacket forwarded_packets = 5;
*/
forwardedPackets: ForwardedPacket[] = [];
constructor(data?: PartialMessage<GenesisState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v2.GenesisState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "port_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "denoms", kind: "message", T: Denom, repeated: true },
{ no: 3, name: "params", kind: "message", T: Params },
{ no: 4, name: "total_escrowed", kind: "message", T: Coin, repeated: true },
{ no: 5, name: "forwarded_packets", kind: "message", T: ForwardedPacket, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GenesisState {
return new GenesisState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJsonString(jsonString, options);
}
static equals(a: GenesisState | PlainMessage<GenesisState> | undefined, b: GenesisState | PlainMessage<GenesisState> | undefined): boolean {
return proto3.util.equals(GenesisState, a, b);
}
}
/**
* ForwardedPacket defines the genesis type necessary to retrieve and store forwarded packets.
*
* @generated from message ibc.applications.transfer.v2.ForwardedPacket
*/
export class ForwardedPacket extends Message<ForwardedPacket> {
/**
* @generated from field: ibc.core.channel.v1.PacketId forward_key = 1;
*/
forwardKey?: PacketId;
/**
* @generated from field: ibc.core.channel.v1.Packet packet = 2;
*/
packet?: Packet;
constructor(data?: PartialMessage<ForwardedPacket>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v2.ForwardedPacket";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "forward_key", kind: "message", T: PacketId },
{ no: 2, name: "packet", kind: "message", T: Packet },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ForwardedPacket {
return new ForwardedPacket().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ForwardedPacket {
return new ForwardedPacket().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ForwardedPacket {
return new ForwardedPacket().fromJsonString(jsonString, options);
}
static equals(a: ForwardedPacket | PlainMessage<ForwardedPacket> | undefined, b: ForwardedPacket | PlainMessage<ForwardedPacket> | undefined): boolean {
return proto3.util.equals(ForwardedPacket, a, b);
}
}

211
libs/es-client/src/protobufs/ibc/applications/transfer/v2/packet_pb.ts Normal file
View File

@ -0,0 +1,211 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/transfer/v2/packet.proto (package ibc.applications.transfer.v2, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { Token } from "./token_pb.js";
import { Hop } from "../v1/transfer_pb.js";
/**
* FungibleTokenPacketData defines a struct for the packet payload
* See FungibleTokenPacketData spec:
* https://github.com/cosmos/ibc/tree/master/spec/app/ics-020-fungible-token-transfer#data-structures
*
* @generated from message ibc.applications.transfer.v2.FungibleTokenPacketData
*/
export class FungibleTokenPacketData extends Message<FungibleTokenPacketData> {
/**
* the token denomination to be transferred
*
* @generated from field: string denom = 1;
*/
denom = "";
/**
* the token amount to be transferred
*
* @generated from field: string amount = 2;
*/
amount = "";
/**
* the sender address
*
* @generated from field: string sender = 3;
*/
sender = "";
/**
* the recipient address on the destination chain
*
* @generated from field: string receiver = 4;
*/
receiver = "";
/**
* optional memo
*
* @generated from field: string memo = 5;
*/
memo = "";
constructor(data?: PartialMessage<FungibleTokenPacketData>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v2.FungibleTokenPacketData";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "denom", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "amount", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "sender", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "receiver", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 5, name: "memo", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FungibleTokenPacketData {
return new FungibleTokenPacketData().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FungibleTokenPacketData {
return new FungibleTokenPacketData().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FungibleTokenPacketData {
return new FungibleTokenPacketData().fromJsonString(jsonString, options);
}
static equals(a: FungibleTokenPacketData | PlainMessage<FungibleTokenPacketData> | undefined, b: FungibleTokenPacketData | PlainMessage<FungibleTokenPacketData> | undefined): boolean {
return proto3.util.equals(FungibleTokenPacketData, a, b);
}
}
/**
* FungibleTokenPacketDataV2 defines a struct for the packet payload
* See FungibleTokenPacketDataV2 spec:
* https://github.com/cosmos/ibc/tree/master/spec/app/ics-020-fungible-token-transfer#data-structures
*
* @generated from message ibc.applications.transfer.v2.FungibleTokenPacketDataV2
*/
export class FungibleTokenPacketDataV2 extends Message<FungibleTokenPacketDataV2> {
/**
* the tokens to be transferred
*
* @generated from field: repeated ibc.applications.transfer.v2.Token tokens = 1;
*/
tokens: Token[] = [];
/**
* the sender address
*
* @generated from field: string sender = 2;
*/
sender = "";
/**
* the recipient address on the destination chain
*
* @generated from field: string receiver = 3;
*/
receiver = "";
/**
* optional memo
*
* @generated from field: string memo = 4;
*/
memo = "";
/**
* optional forwarding information
*
* @generated from field: ibc.applications.transfer.v2.ForwardingPacketData forwarding = 5;
*/
forwarding?: ForwardingPacketData;
constructor(data?: PartialMessage<FungibleTokenPacketDataV2>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v2.FungibleTokenPacketDataV2";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "tokens", kind: "message", T: Token, repeated: true },
{ no: 2, name: "sender", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "receiver", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "memo", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 5, name: "forwarding", kind: "message", T: ForwardingPacketData },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FungibleTokenPacketDataV2 {
return new FungibleTokenPacketDataV2().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FungibleTokenPacketDataV2 {
return new FungibleTokenPacketDataV2().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FungibleTokenPacketDataV2 {
return new FungibleTokenPacketDataV2().fromJsonString(jsonString, options);
}
static equals(a: FungibleTokenPacketDataV2 | PlainMessage<FungibleTokenPacketDataV2> | undefined, b: FungibleTokenPacketDataV2 | PlainMessage<FungibleTokenPacketDataV2> | undefined): boolean {
return proto3.util.equals(FungibleTokenPacketDataV2, a, b);
}
}
/**
* ForwardingPacketData defines a list of port ID, channel ID pairs determining the path
* through which a packet must be forwarded, and the destination memo string to be used in the
* final destination of the tokens.
*
* @generated from message ibc.applications.transfer.v2.ForwardingPacketData
*/
export class ForwardingPacketData extends Message<ForwardingPacketData> {
/**
* optional memo consumed by final destination chain
*
* @generated from field: string destination_memo = 1;
*/
destinationMemo = "";
/**
* optional intermediate path through which packet will be forwarded.
*
* @generated from field: repeated ibc.applications.transfer.v1.Hop hops = 2;
*/
hops: Hop[] = [];
constructor(data?: PartialMessage<ForwardingPacketData>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v2.ForwardingPacketData";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "destination_memo", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "hops", kind: "message", T: Hop, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ForwardingPacketData {
return new ForwardingPacketData().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ForwardingPacketData {
return new ForwardingPacketData().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ForwardingPacketData {
return new ForwardingPacketData().fromJsonString(jsonString, options);
}
static equals(a: ForwardingPacketData | PlainMessage<ForwardingPacketData> | undefined, b: ForwardingPacketData | PlainMessage<ForwardingPacketData> | undefined): boolean {
return proto3.util.equals(ForwardingPacketData, a, b);
}
}

33
libs/es-client/src/protobufs/ibc/applications/transfer/v2/queryv2_cosmes.ts Normal file
View File

@ -0,0 +1,33 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file ibc/applications/transfer/v2/queryv2.proto (package ibc.applications.transfer.v2, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { QueryDenomRequest, QueryDenomResponse, QueryDenomsRequest, QueryDenomsResponse } from "./queryv2_pb.js";
const TYPE_NAME = "ibc.applications.transfer.v2.QueryV2";
/**
* Denoms queries all denominations
*
* @generated from rpc ibc.applications.transfer.v2.QueryV2.Denoms
*/
export const QueryV2DenomsService = {
typeName: TYPE_NAME,
method: "Denoms",
Request: QueryDenomsRequest,
Response: QueryDenomsResponse,
} as const;
/**
* Denom queries a denomination
*
* @generated from rpc ibc.applications.transfer.v2.QueryV2.Denom
*/
export const QueryV2DenomService = {
typeName: TYPE_NAME,
method: "Denom",
Request: QueryDenomRequest,
Response: QueryDenomResponse,
} as const;

186
libs/es-client/src/protobufs/ibc/applications/transfer/v2/queryv2_pb.ts Normal file
View File

@ -0,0 +1,186 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/transfer/v2/queryv2.proto (package ibc.applications.transfer.v2, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { Denom } from "./token_pb.js";
import { PageRequest, PageResponse } from "../../../../cosmos/base/query/v1beta1/pagination_pb.js";
/**
* QueryDenomRequest is the request type for the Query/Denom RPC
* method
*
* @generated from message ibc.applications.transfer.v2.QueryDenomRequest
*/
export class QueryDenomRequest extends Message<QueryDenomRequest> {
/**
* hash (in hex format) or denom (full denom with ibc prefix) of the on chain denomination.
*
* @generated from field: string hash = 1;
*/
hash = "";
constructor(data?: PartialMessage<QueryDenomRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v2.QueryDenomRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "hash", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryDenomRequest {
return new QueryDenomRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryDenomRequest {
return new QueryDenomRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryDenomRequest {
return new QueryDenomRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryDenomRequest | PlainMessage<QueryDenomRequest> | undefined, b: QueryDenomRequest | PlainMessage<QueryDenomRequest> | undefined): boolean {
return proto3.util.equals(QueryDenomRequest, a, b);
}
}
/**
* QueryDenomResponse is the response type for the Query/Denom RPC
* method.
*
* @generated from message ibc.applications.transfer.v2.QueryDenomResponse
*/
export class QueryDenomResponse extends Message<QueryDenomResponse> {
/**
* denom returns the requested denomination.
*
* @generated from field: ibc.applications.transfer.v2.Denom denom = 1;
*/
denom?: Denom;
constructor(data?: PartialMessage<QueryDenomResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v2.QueryDenomResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "denom", kind: "message", T: Denom },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryDenomResponse {
return new QueryDenomResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryDenomResponse {
return new QueryDenomResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryDenomResponse {
return new QueryDenomResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryDenomResponse | PlainMessage<QueryDenomResponse> | undefined, b: QueryDenomResponse | PlainMessage<QueryDenomResponse> | undefined): boolean {
return proto3.util.equals(QueryDenomResponse, a, b);
}
}
/**
* QueryDenomsRequest is the request type for the Query/Denoms RPC
* method
*
* @generated from message ibc.applications.transfer.v2.QueryDenomsRequest
*/
export class QueryDenomsRequest extends Message<QueryDenomsRequest> {
/**
* pagination defines an optional pagination for the request.
*
* @generated from field: cosmos.base.query.v1beta1.PageRequest pagination = 1;
*/
pagination?: PageRequest;
constructor(data?: PartialMessage<QueryDenomsRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v2.QueryDenomsRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "pagination", kind: "message", T: PageRequest },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryDenomsRequest {
return new QueryDenomsRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryDenomsRequest {
return new QueryDenomsRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryDenomsRequest {
return new QueryDenomsRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryDenomsRequest | PlainMessage<QueryDenomsRequest> | undefined, b: QueryDenomsRequest | PlainMessage<QueryDenomsRequest> | undefined): boolean {
return proto3.util.equals(QueryDenomsRequest, a, b);
}
}
/**
* QueryDenomsResponse is the response type for the Query/Denoms RPC
* method.
*
* @generated from message ibc.applications.transfer.v2.QueryDenomsResponse
*/
export class QueryDenomsResponse extends Message<QueryDenomsResponse> {
/**
* denoms returns all denominations.
*
* @generated from field: repeated ibc.applications.transfer.v2.Denom denoms = 1;
*/
denoms: Denom[] = [];
/**
* pagination defines the pagination in the response.
*
* @generated from field: cosmos.base.query.v1beta1.PageResponse pagination = 2;
*/
pagination?: PageResponse;
constructor(data?: PartialMessage<QueryDenomsResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v2.QueryDenomsResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "denoms", kind: "message", T: Denom, repeated: true },
{ no: 2, name: "pagination", kind: "message", T: PageResponse },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryDenomsResponse {
return new QueryDenomsResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryDenomsResponse {
return new QueryDenomsResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryDenomsResponse {
return new QueryDenomsResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryDenomsResponse | PlainMessage<QueryDenomsResponse> | undefined, b: QueryDenomsResponse | PlainMessage<QueryDenomsResponse> | undefined): boolean {
return proto3.util.equals(QueryDenomsResponse, a, b);
}
}

107
libs/es-client/src/protobufs/ibc/applications/transfer/v2/token_pb.ts Normal file
View File

@ -0,0 +1,107 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/applications/transfer/v2/token.proto (package ibc.applications.transfer.v2, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { Hop } from "../v1/transfer_pb.js";
/**
* Token defines a struct which represents a token to be transferred.
*
* @generated from message ibc.applications.transfer.v2.Token
*/
export class Token extends Message<Token> {
/**
* the token denomination
*
* @generated from field: ibc.applications.transfer.v2.Denom denom = 1;
*/
denom?: Denom;
/**
* the token amount to be transferred
*
* @generated from field: string amount = 2;
*/
amount = "";
constructor(data?: PartialMessage<Token>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v2.Token";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "denom", kind: "message", T: Denom },
{ no: 2, name: "amount", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Token {
return new Token().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Token {
return new Token().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Token {
return new Token().fromJsonString(jsonString, options);
}
static equals(a: Token | PlainMessage<Token> | undefined, b: Token | PlainMessage<Token> | undefined): boolean {
return proto3.util.equals(Token, a, b);
}
}
/**
* Denom holds the base denom of a Token and a trace of the chains it was sent through.
*
* @generated from message ibc.applications.transfer.v2.Denom
*/
export class Denom extends Message<Denom> {
/**
* the base token denomination
*
* @generated from field: string base = 1;
*/
base = "";
/**
* the trace of the token
*
* @generated from field: repeated ibc.applications.transfer.v1.Hop trace = 3;
*/
trace: Hop[] = [];
constructor(data?: PartialMessage<Denom>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.applications.transfer.v2.Denom";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "base", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "trace", kind: "message", T: Hop, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Denom {
return new Denom().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Denom {
return new Denom().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Denom {
return new Denom().fromJsonString(jsonString, options);
}
static equals(a: Denom | PlainMessage<Denom> | undefined, b: Denom | PlainMessage<Denom> | undefined): boolean {
return proto3.util.equals(Denom, a, b);
}
}

725
libs/es-client/src/protobufs/ibc/core/channel/v1/channel_pb.ts Normal file
View File

@ -0,0 +1,725 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/core/channel/v1/channel.proto (package ibc.core.channel.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, protoInt64 } from "@bufbuild/protobuf";
import { Height } from "../../client/v1/client_pb.js";
/**
* State defines if a channel is in one of the following states:
* CLOSED, INIT, TRYOPEN, OPEN, FLUSHING, FLUSHCOMPLETE or UNINITIALIZED.
*
* @generated from enum ibc.core.channel.v1.State
*/
export enum State {
/**
* Default State
*
* @generated from enum value: STATE_UNINITIALIZED_UNSPECIFIED = 0;
*/
UNINITIALIZED_UNSPECIFIED = 0,
/**
* A channel has just started the opening handshake.
*
* @generated from enum value: STATE_INIT = 1;
*/
INIT = 1,
/**
* A channel has acknowledged the handshake step on the counterparty chain.
*
* @generated from enum value: STATE_TRYOPEN = 2;
*/
TRYOPEN = 2,
/**
* A channel has completed the handshake. Open channels are
* ready to send and receive packets.
*
* @generated from enum value: STATE_OPEN = 3;
*/
OPEN = 3,
/**
* A channel has been closed and can no longer be used to send or receive
* packets.
*
* @generated from enum value: STATE_CLOSED = 4;
*/
CLOSED = 4,
/**
* A channel has just accepted the upgrade handshake attempt and is flushing in-flight packets.
*
* @generated from enum value: STATE_FLUSHING = 5;
*/
FLUSHING = 5,
/**
* A channel has just completed flushing any in-flight packets.
*
* @generated from enum value: STATE_FLUSHCOMPLETE = 6;
*/
FLUSHCOMPLETE = 6,
}
// Retrieve enum metadata with: proto3.getEnumType(State)
proto3.util.setEnumType(State, "ibc.core.channel.v1.State", [
{ no: 0, name: "STATE_UNINITIALIZED_UNSPECIFIED" },
{ no: 1, name: "STATE_INIT" },
{ no: 2, name: "STATE_TRYOPEN" },
{ no: 3, name: "STATE_OPEN" },
{ no: 4, name: "STATE_CLOSED" },
{ no: 5, name: "STATE_FLUSHING" },
{ no: 6, name: "STATE_FLUSHCOMPLETE" },
]);
/**
* Order defines if a channel is ORDERED or UNORDERED
*
* @generated from enum ibc.core.channel.v1.Order
*/
export enum Order {
/**
* zero-value for channel ordering
*
* @generated from enum value: ORDER_NONE_UNSPECIFIED = 0;
*/
NONE_UNSPECIFIED = 0,
/**
* packets can be delivered in any order, which may differ from the order in
* which they were sent.
*
* @generated from enum value: ORDER_UNORDERED = 1;
*/
UNORDERED = 1,
/**
* packets are delivered exactly in the order which they were sent
*
* @generated from enum value: ORDER_ORDERED = 2;
*/
ORDERED = 2,
}
// Retrieve enum metadata with: proto3.getEnumType(Order)
proto3.util.setEnumType(Order, "ibc.core.channel.v1.Order", [
{ no: 0, name: "ORDER_NONE_UNSPECIFIED" },
{ no: 1, name: "ORDER_UNORDERED" },
{ no: 2, name: "ORDER_ORDERED" },
]);
/**
* Channel defines pipeline for exactly-once packet delivery between specific
* modules on separate blockchains, which has at least one end capable of
* sending packets and one end capable of receiving packets.
*
* @generated from message ibc.core.channel.v1.Channel
*/
export class Channel extends Message<Channel> {
/**
* current state of the channel end
*
* @generated from field: ibc.core.channel.v1.State state = 1;
*/
state = State.UNINITIALIZED_UNSPECIFIED;
/**
* whether the channel is ordered or unordered
*
* @generated from field: ibc.core.channel.v1.Order ordering = 2;
*/
ordering = Order.NONE_UNSPECIFIED;
/**
* counterparty channel end
*
* @generated from field: ibc.core.channel.v1.Counterparty counterparty = 3;
*/
counterparty?: Counterparty;
/**
* list of connection identifiers, in order, along which packets sent on
* this channel will travel
*
* @generated from field: repeated string connection_hops = 4;
*/
connectionHops: string[] = [];
/**
* opaque channel version, which is agreed upon during the handshake
*
* @generated from field: string version = 5;
*/
version = "";
/**
* upgrade sequence indicates the latest upgrade attempt performed by this channel
* the value of 0 indicates the channel has never been upgraded
*
* @generated from field: uint64 upgrade_sequence = 6;
*/
upgradeSequence = protoInt64.zero;
constructor(data?: PartialMessage<Channel>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.channel.v1.Channel";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "state", kind: "enum", T: proto3.getEnumType(State) },
{ no: 2, name: "ordering", kind: "enum", T: proto3.getEnumType(Order) },
{ no: 3, name: "counterparty", kind: "message", T: Counterparty },
{ no: 4, name: "connection_hops", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
{ no: 5, name: "version", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 6, name: "upgrade_sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Channel {
return new Channel().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Channel {
return new Channel().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Channel {
return new Channel().fromJsonString(jsonString, options);
}
static equals(a: Channel | PlainMessage<Channel> | undefined, b: Channel | PlainMessage<Channel> | undefined): boolean {
return proto3.util.equals(Channel, a, b);
}
}
/**
* IdentifiedChannel defines a channel with additional port and channel
* identifier fields.
*
* @generated from message ibc.core.channel.v1.IdentifiedChannel
*/
export class IdentifiedChannel extends Message<IdentifiedChannel> {
/**
* current state of the channel end
*
* @generated from field: ibc.core.channel.v1.State state = 1;
*/
state = State.UNINITIALIZED_UNSPECIFIED;
/**
* whether the channel is ordered or unordered
*
* @generated from field: ibc.core.channel.v1.Order ordering = 2;
*/
ordering = Order.NONE_UNSPECIFIED;
/**
* counterparty channel end
*
* @generated from field: ibc.core.channel.v1.Counterparty counterparty = 3;
*/
counterparty?: Counterparty;
/**
* list of connection identifiers, in order, along which packets sent on
* this channel will travel
*
* @generated from field: repeated string connection_hops = 4;
*/
connectionHops: string[] = [];
/**
* opaque channel version, which is agreed upon during the handshake
*
* @generated from field: string version = 5;
*/
version = "";
/**
* port identifier
*
* @generated from field: string port_id = 6;
*/
portId = "";
/**
* channel identifier
*
* @generated from field: string channel_id = 7;
*/
channelId = "";
/**
* upgrade sequence indicates the latest upgrade attempt performed by this channel
* the value of 0 indicates the channel has never been upgraded
*
* @generated from field: uint64 upgrade_sequence = 8;
*/
upgradeSequence = protoInt64.zero;
constructor(data?: PartialMessage<IdentifiedChannel>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.channel.v1.IdentifiedChannel";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "state", kind: "enum", T: proto3.getEnumType(State) },
{ no: 2, name: "ordering", kind: "enum", T: proto3.getEnumType(Order) },
{ no: 3, name: "counterparty", kind: "message", T: Counterparty },
{ no: 4, name: "connection_hops", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
{ no: 5, name: "version", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 6, name: "port_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 7, name: "channel_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 8, name: "upgrade_sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): IdentifiedChannel {
return new IdentifiedChannel().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): IdentifiedChannel {
return new IdentifiedChannel().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): IdentifiedChannel {
return new IdentifiedChannel().fromJsonString(jsonString, options);
}
static equals(a: IdentifiedChannel | PlainMessage<IdentifiedChannel> | undefined, b: IdentifiedChannel | PlainMessage<IdentifiedChannel> | undefined): boolean {
return proto3.util.equals(IdentifiedChannel, a, b);
}
}
/**
* Counterparty defines a channel end counterparty
*
* @generated from message ibc.core.channel.v1.Counterparty
*/
export class Counterparty extends Message<Counterparty> {
/**
* port on the counterparty chain which owns the other end of the channel.
*
* @generated from field: string port_id = 1;
*/
portId = "";
/**
* channel end on the counterparty chain
*
* @generated from field: string channel_id = 2;
*/
channelId = "";
constructor(data?: PartialMessage<Counterparty>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.channel.v1.Counterparty";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "port_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "channel_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Counterparty {
return new Counterparty().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Counterparty {
return new Counterparty().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Counterparty {
return new Counterparty().fromJsonString(jsonString, options);
}
static equals(a: Counterparty | PlainMessage<Counterparty> | undefined, b: Counterparty | PlainMessage<Counterparty> | undefined): boolean {
return proto3.util.equals(Counterparty, a, b);
}
}
/**
* Packet defines a type that carries data across different chains through IBC
*
* @generated from message ibc.core.channel.v1.Packet
*/
export class Packet extends Message<Packet> {
/**
* number corresponds to the order of sends and receives, where a Packet
* with an earlier sequence number must be sent and received before a Packet
* with a later sequence number.
*
* @generated from field: uint64 sequence = 1;
*/
sequence = protoInt64.zero;
/**
* identifies the port on the sending chain.
*
* @generated from field: string source_port = 2;
*/
sourcePort = "";
/**
* identifies the channel end on the sending chain.
*
* @generated from field: string source_channel = 3;
*/
sourceChannel = "";
/**
* identifies the port on the receiving chain.
*
* @generated from field: string destination_port = 4;
*/
destinationPort = "";
/**
* identifies the channel end on the receiving chain.
*
* @generated from field: string destination_channel = 5;
*/
destinationChannel = "";
/**
* actual opaque bytes transferred directly to the application module
*
* @generated from field: bytes data = 6;
*/
data = new Uint8Array(0);
/**
* block height after which the packet times out
*
* @generated from field: ibc.core.client.v1.Height timeout_height = 7;
*/
timeoutHeight?: Height;
/**
* block timestamp (in nanoseconds) after which the packet times out
*
* @generated from field: uint64 timeout_timestamp = 8;
*/
timeoutTimestamp = protoInt64.zero;
constructor(data?: PartialMessage<Packet>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.channel.v1.Packet";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 2, name: "source_port", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "source_channel", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "destination_port", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 5, name: "destination_channel", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 6, name: "data", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 7, name: "timeout_height", kind: "message", T: Height },
{ no: 8, name: "timeout_timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Packet {
return new Packet().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Packet {
return new Packet().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Packet {
return new Packet().fromJsonString(jsonString, options);
}
static equals(a: Packet | PlainMessage<Packet> | undefined, b: Packet | PlainMessage<Packet> | undefined): boolean {
return proto3.util.equals(Packet, a, b);
}
}
/**
* PacketState defines the generic type necessary to retrieve and store
* packet commitments, acknowledgements, and receipts.
* Caller is responsible for knowing the context necessary to interpret this
* state as a commitment, acknowledgement, or a receipt.
*
* @generated from message ibc.core.channel.v1.PacketState
*/
export class PacketState extends Message<PacketState> {
/**
* channel port identifier.
*
* @generated from field: string port_id = 1;
*/
portId = "";
/**
* channel unique identifier.
*
* @generated from field: string channel_id = 2;
*/
channelId = "";
/**
* packet sequence.
*
* @generated from field: uint64 sequence = 3;
*/
sequence = protoInt64.zero;
/**
* embedded data that represents packet state.
*
* @generated from field: bytes data = 4;
*/
data = new Uint8Array(0);
constructor(data?: PartialMessage<PacketState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.channel.v1.PacketState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "port_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "channel_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 4, name: "data", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PacketState {
return new PacketState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PacketState {
return new PacketState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PacketState {
return new PacketState().fromJsonString(jsonString, options);
}
static equals(a: PacketState | PlainMessage<PacketState> | undefined, b: PacketState | PlainMessage<PacketState> | undefined): boolean {
return proto3.util.equals(PacketState, a, b);
}
}
/**
* PacketId is an identifier for a unique Packet
* Source chains refer to packets by source port/channel
* Destination chains refer to packets by destination port/channel
*
* @generated from message ibc.core.channel.v1.PacketId
*/
export class PacketId extends Message<PacketId> {
/**
* channel port identifier
*
* @generated from field: string port_id = 1;
*/
portId = "";
/**
* channel unique identifier
*
* @generated from field: string channel_id = 2;
*/
channelId = "";
/**
* packet sequence
*
* @generated from field: uint64 sequence = 3;
*/
sequence = protoInt64.zero;
constructor(data?: PartialMessage<PacketId>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.channel.v1.PacketId";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "port_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "channel_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PacketId {
return new PacketId().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PacketId {
return new PacketId().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PacketId {
return new PacketId().fromJsonString(jsonString, options);
}
static equals(a: PacketId | PlainMessage<PacketId> | undefined, b: PacketId | PlainMessage<PacketId> | undefined): boolean {
return proto3.util.equals(PacketId, a, b);
}
}
/**
* Acknowledgement is the recommended acknowledgement format to be used by
* app-specific protocols.
* NOTE: The field numbers 21 and 22 were explicitly chosen to avoid accidental
* conflicts with other protobuf message formats used for acknowledgements.
* The first byte of any message with this format will be the non-ASCII values
* `0xaa` (result) or `0xb2` (error). Implemented as defined by ICS:
* https://github.com/cosmos/ibc/tree/master/spec/core/ics-004-channel-and-packet-semantics#acknowledgement-envelope
*
* @generated from message ibc.core.channel.v1.Acknowledgement
*/
export class Acknowledgement extends Message<Acknowledgement> {
/**
* response contains either a result or an error and must be non-empty
*
* @generated from oneof ibc.core.channel.v1.Acknowledgement.response
*/
response: {
/**
* @generated from field: bytes result = 21;
*/
value: Uint8Array;
case: "result";
} | {
/**
* @generated from field: string error = 22;
*/
value: string;
case: "error";
} | { case: undefined; value?: undefined } = { case: undefined };
constructor(data?: PartialMessage<Acknowledgement>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.channel.v1.Acknowledgement";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 21, name: "result", kind: "scalar", T: 12 /* ScalarType.BYTES */, oneof: "response" },
{ no: 22, name: "error", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "response" },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Acknowledgement {
return new Acknowledgement().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Acknowledgement {
return new Acknowledgement().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Acknowledgement {
return new Acknowledgement().fromJsonString(jsonString, options);
}
static equals(a: Acknowledgement | PlainMessage<Acknowledgement> | undefined, b: Acknowledgement | PlainMessage<Acknowledgement> | undefined): boolean {
return proto3.util.equals(Acknowledgement, a, b);
}
}
/**
* Timeout defines an execution deadline structure for 04-channel handlers.
* This includes packet lifecycle handlers as well as the upgrade handshake handlers.
* A valid Timeout contains either one or both of a timestamp and block height (sequence).
*
* @generated from message ibc.core.channel.v1.Timeout
*/
export class Timeout extends Message<Timeout> {
/**
* block height after which the packet or upgrade times out
*
* @generated from field: ibc.core.client.v1.Height height = 1;
*/
height?: Height;
/**
* block timestamp (in nanoseconds) after which the packet or upgrade times out
*
* @generated from field: uint64 timestamp = 2;
*/
timestamp = protoInt64.zero;
constructor(data?: PartialMessage<Timeout>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.channel.v1.Timeout";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "height", kind: "message", T: Height },
{ no: 2, name: "timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Timeout {
return new Timeout().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Timeout {
return new Timeout().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Timeout {
return new Timeout().fromJsonString(jsonString, options);
}
static equals(a: Timeout | PlainMessage<Timeout> | undefined, b: Timeout | PlainMessage<Timeout> | undefined): boolean {
return proto3.util.equals(Timeout, a, b);
}
}
/**
* Params defines the set of IBC channel parameters.
*
* @generated from message ibc.core.channel.v1.Params
*/
export class Params extends Message<Params> {
/**
* the relative timeout after which channel upgrades will time out.
*
* @generated from field: ibc.core.channel.v1.Timeout upgrade_timeout = 1;
*/
upgradeTimeout?: Timeout;
constructor(data?: PartialMessage<Params>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.channel.v1.Params";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "upgrade_timeout", kind: "message", T: Timeout },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Params {
return new Params().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Params {
return new Params().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Params {
return new Params().fromJsonString(jsonString, options);
}
static equals(a: Params | PlainMessage<Params> | undefined, b: Params | PlainMessage<Params> | undefined): boolean {
return proto3.util.equals(Params, a, b);
}
}

150
libs/es-client/src/protobufs/ibc/core/channel/v1/genesis_pb.ts Normal file
View File

@ -0,0 +1,150 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/core/channel/v1/genesis.proto (package ibc.core.channel.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, protoInt64 } from "@bufbuild/protobuf";
import { IdentifiedChannel, PacketState, Params } from "./channel_pb.js";
/**
* GenesisState defines the ibc channel submodule's genesis state.
*
* @generated from message ibc.core.channel.v1.GenesisState
*/
export class GenesisState extends Message<GenesisState> {
/**
* @generated from field: repeated ibc.core.channel.v1.IdentifiedChannel channels = 1;
*/
channels: IdentifiedChannel[] = [];
/**
* @generated from field: repeated ibc.core.channel.v1.PacketState acknowledgements = 2;
*/
acknowledgements: PacketState[] = [];
/**
* @generated from field: repeated ibc.core.channel.v1.PacketState commitments = 3;
*/
commitments: PacketState[] = [];
/**
* @generated from field: repeated ibc.core.channel.v1.PacketState receipts = 4;
*/
receipts: PacketState[] = [];
/**
* @generated from field: repeated ibc.core.channel.v1.PacketSequence send_sequences = 5;
*/
sendSequences: PacketSequence[] = [];
/**
* @generated from field: repeated ibc.core.channel.v1.PacketSequence recv_sequences = 6;
*/
recvSequences: PacketSequence[] = [];
/**
* @generated from field: repeated ibc.core.channel.v1.PacketSequence ack_sequences = 7;
*/
ackSequences: PacketSequence[] = [];
/**
* the sequence for the next generated channel identifier
*
* @generated from field: uint64 next_channel_sequence = 8;
*/
nextChannelSequence = protoInt64.zero;
/**
* @generated from field: ibc.core.channel.v1.Params params = 9;
*/
params?: Params;
constructor(data?: PartialMessage<GenesisState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.channel.v1.GenesisState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "channels", kind: "message", T: IdentifiedChannel, repeated: true },
{ no: 2, name: "acknowledgements", kind: "message", T: PacketState, repeated: true },
{ no: 3, name: "commitments", kind: "message", T: PacketState, repeated: true },
{ no: 4, name: "receipts", kind: "message", T: PacketState, repeated: true },
{ no: 5, name: "send_sequences", kind: "message", T: PacketSequence, repeated: true },
{ no: 6, name: "recv_sequences", kind: "message", T: PacketSequence, repeated: true },
{ no: 7, name: "ack_sequences", kind: "message", T: PacketSequence, repeated: true },
{ no: 8, name: "next_channel_sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 9, name: "params", kind: "message", T: Params },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GenesisState {
return new GenesisState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJsonString(jsonString, options);
}
static equals(a: GenesisState | PlainMessage<GenesisState> | undefined, b: GenesisState | PlainMessage<GenesisState> | undefined): boolean {
return proto3.util.equals(GenesisState, a, b);
}
}
/**
* PacketSequence defines the genesis type necessary to retrieve and store
* next send and receive sequences.
*
* @generated from message ibc.core.channel.v1.PacketSequence
*/
export class PacketSequence extends Message<PacketSequence> {
/**
* @generated from field: string port_id = 1;
*/
portId = "";
/**
* @generated from field: string channel_id = 2;
*/
channelId = "";
/**
* @generated from field: uint64 sequence = 3;
*/
sequence = protoInt64.zero;
constructor(data?: PartialMessage<PacketSequence>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.channel.v1.PacketSequence";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "port_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "channel_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PacketSequence {
return new PacketSequence().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PacketSequence {
return new PacketSequence().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PacketSequence {
return new PacketSequence().fromJsonString(jsonString, options);
}
static equals(a: PacketSequence | PlainMessage<PacketSequence> | undefined, b: PacketSequence | PlainMessage<PacketSequence> | undefined): boolean {
return proto3.util.equals(PacketSequence, a, b);
}
}

221
libs/es-client/src/protobufs/ibc/core/channel/v1/query_cosmes.ts Normal file
View File

@ -0,0 +1,221 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file ibc/core/channel/v1/query.proto (package ibc.core.channel.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { QueryChannelClientStateRequest, QueryChannelClientStateResponse, QueryChannelConsensusStateRequest, QueryChannelConsensusStateResponse, QueryChannelParamsRequest, QueryChannelParamsResponse, QueryChannelRequest, QueryChannelResponse, QueryChannelsRequest, QueryChannelsResponse, QueryConnectionChannelsRequest, QueryConnectionChannelsResponse, QueryNextSequenceReceiveRequest, QueryNextSequenceReceiveResponse, QueryNextSequenceSendRequest, QueryNextSequenceSendResponse, QueryPacketAcknowledgementRequest, QueryPacketAcknowledgementResponse, QueryPacketAcknowledgementsRequest, QueryPacketAcknowledgementsResponse, QueryPacketCommitmentRequest, QueryPacketCommitmentResponse, QueryPacketCommitmentsRequest, QueryPacketCommitmentsResponse, QueryPacketReceiptRequest, QueryPacketReceiptResponse, QueryUnreceivedAcksRequest, QueryUnreceivedAcksResponse, QueryUnreceivedPacketsRequest, QueryUnreceivedPacketsResponse, QueryUpgradeErrorRequest, QueryUpgradeErrorResponse, QueryUpgradeRequest, QueryUpgradeResponse } from "./query_pb.js";
const TYPE_NAME = "ibc.core.channel.v1.Query";
/**
* Channel queries an IBC Channel.
*
* @generated from rpc ibc.core.channel.v1.Query.Channel
*/
export const QueryChannelService = {
typeName: TYPE_NAME,
method: "Channel",
Request: QueryChannelRequest,
Response: QueryChannelResponse,
} as const;
/**
* Channels queries all the IBC channels of a chain.
*
* @generated from rpc ibc.core.channel.v1.Query.Channels
*/
export const QueryChannelsService = {
typeName: TYPE_NAME,
method: "Channels",
Request: QueryChannelsRequest,
Response: QueryChannelsResponse,
} as const;
/**
* ConnectionChannels queries all the channels associated with a connection
* end.
*
* @generated from rpc ibc.core.channel.v1.Query.ConnectionChannels
*/
export const QueryConnectionChannelsService = {
typeName: TYPE_NAME,
method: "ConnectionChannels",
Request: QueryConnectionChannelsRequest,
Response: QueryConnectionChannelsResponse,
} as const;
/**
* ChannelClientState queries for the client state for the channel associated
* with the provided channel identifiers.
*
* @generated from rpc ibc.core.channel.v1.Query.ChannelClientState
*/
export const QueryChannelClientStateService = {
typeName: TYPE_NAME,
method: "ChannelClientState",
Request: QueryChannelClientStateRequest,
Response: QueryChannelClientStateResponse,
} as const;
/**
* ChannelConsensusState queries for the consensus state for the channel
* associated with the provided channel identifiers.
*
* @generated from rpc ibc.core.channel.v1.Query.ChannelConsensusState
*/
export const QueryChannelConsensusStateService = {
typeName: TYPE_NAME,
method: "ChannelConsensusState",
Request: QueryChannelConsensusStateRequest,
Response: QueryChannelConsensusStateResponse,
} as const;
/**
* PacketCommitment queries a stored packet commitment hash.
*
* @generated from rpc ibc.core.channel.v1.Query.PacketCommitment
*/
export const QueryPacketCommitmentService = {
typeName: TYPE_NAME,
method: "PacketCommitment",
Request: QueryPacketCommitmentRequest,
Response: QueryPacketCommitmentResponse,
} as const;
/**
* PacketCommitments returns all the packet commitments hashes associated
* with a channel.
*
* @generated from rpc ibc.core.channel.v1.Query.PacketCommitments
*/
export const QueryPacketCommitmentsService = {
typeName: TYPE_NAME,
method: "PacketCommitments",
Request: QueryPacketCommitmentsRequest,
Response: QueryPacketCommitmentsResponse,
} as const;
/**
* PacketReceipt queries if a given packet sequence has been received on the
* queried chain
*
* @generated from rpc ibc.core.channel.v1.Query.PacketReceipt
*/
export const QueryPacketReceiptService = {
typeName: TYPE_NAME,
method: "PacketReceipt",
Request: QueryPacketReceiptRequest,
Response: QueryPacketReceiptResponse,
} as const;
/**
* PacketAcknowledgement queries a stored packet acknowledgement hash.
*
* @generated from rpc ibc.core.channel.v1.Query.PacketAcknowledgement
*/
export const QueryPacketAcknowledgementService = {
typeName: TYPE_NAME,
method: "PacketAcknowledgement",
Request: QueryPacketAcknowledgementRequest,
Response: QueryPacketAcknowledgementResponse,
} as const;
/**
* PacketAcknowledgements returns all the packet acknowledgements associated
* with a channel.
*
* @generated from rpc ibc.core.channel.v1.Query.PacketAcknowledgements
*/
export const QueryPacketAcknowledgementsService = {
typeName: TYPE_NAME,
method: "PacketAcknowledgements",
Request: QueryPacketAcknowledgementsRequest,
Response: QueryPacketAcknowledgementsResponse,
} as const;
/**
* UnreceivedPackets returns all the unreceived IBC packets associated with a
* channel and sequences.
*
* @generated from rpc ibc.core.channel.v1.Query.UnreceivedPackets
*/
export const QueryUnreceivedPacketsService = {
typeName: TYPE_NAME,
method: "UnreceivedPackets",
Request: QueryUnreceivedPacketsRequest,
Response: QueryUnreceivedPacketsResponse,
} as const;
/**
* UnreceivedAcks returns all the unreceived IBC acknowledgements associated
* with a channel and sequences.
*
* @generated from rpc ibc.core.channel.v1.Query.UnreceivedAcks
*/
export const QueryUnreceivedAcksService = {
typeName: TYPE_NAME,
method: "UnreceivedAcks",
Request: QueryUnreceivedAcksRequest,
Response: QueryUnreceivedAcksResponse,
} as const;
/**
* NextSequenceReceive returns the next receive sequence for a given channel.
*
* @generated from rpc ibc.core.channel.v1.Query.NextSequenceReceive
*/
export const QueryNextSequenceReceiveService = {
typeName: TYPE_NAME,
method: "NextSequenceReceive",
Request: QueryNextSequenceReceiveRequest,
Response: QueryNextSequenceReceiveResponse,
} as const;
/**
* NextSequenceSend returns the next send sequence for a given channel.
*
* @generated from rpc ibc.core.channel.v1.Query.NextSequenceSend
*/
export const QueryNextSequenceSendService = {
typeName: TYPE_NAME,
method: "NextSequenceSend",
Request: QueryNextSequenceSendRequest,
Response: QueryNextSequenceSendResponse,
} as const;
/**
* UpgradeError returns the error receipt if the upgrade handshake failed.
*
* @generated from rpc ibc.core.channel.v1.Query.UpgradeError
*/
export const QueryUpgradeErrorService = {
typeName: TYPE_NAME,
method: "UpgradeError",
Request: QueryUpgradeErrorRequest,
Response: QueryUpgradeErrorResponse,
} as const;
/**
* Upgrade returns the upgrade for a given port and channel id.
*
* @generated from rpc ibc.core.channel.v1.Query.Upgrade
*/
export const QueryUpgradeService = {
typeName: TYPE_NAME,
method: "Upgrade",
Request: QueryUpgradeRequest,
Response: QueryUpgradeResponse,
} as const;
/**
* ChannelParams queries all parameters of the ibc channel submodule.
*
* @generated from rpc ibc.core.channel.v1.Query.ChannelParams
*/
export const QueryChannelParamsService = {
typeName: TYPE_NAME,
method: "ChannelParams",
Request: QueryChannelParamsRequest,
Response: QueryChannelParamsResponse,
} as const;

1859
libs/es-client/src/protobufs/ibc/core/channel/v1/query_pb.ts Normal file
View File

File diff suppressed because it is too large Load Diff

238
libs/es-client/src/protobufs/ibc/core/channel/v1/tx_cosmes.ts Normal file
View File

@ -0,0 +1,238 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file ibc/core/channel/v1/tx.proto (package ibc.core.channel.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { MsgAcknowledgement, MsgAcknowledgementResponse, MsgChannelCloseConfirm, MsgChannelCloseConfirmResponse, MsgChannelCloseInit, MsgChannelCloseInitResponse, MsgChannelOpenAck, MsgChannelOpenAckResponse, MsgChannelOpenConfirm, MsgChannelOpenConfirmResponse, MsgChannelOpenInit, MsgChannelOpenInitResponse, MsgChannelOpenTry, MsgChannelOpenTryResponse, MsgChannelUpgradeAck, MsgChannelUpgradeAckResponse, MsgChannelUpgradeCancel, MsgChannelUpgradeCancelResponse, MsgChannelUpgradeConfirm, MsgChannelUpgradeConfirmResponse, MsgChannelUpgradeInit, MsgChannelUpgradeInitResponse, MsgChannelUpgradeOpen, MsgChannelUpgradeOpenResponse, MsgChannelUpgradeTimeout, MsgChannelUpgradeTimeoutResponse, MsgChannelUpgradeTry, MsgChannelUpgradeTryResponse, MsgPruneAcknowledgements, MsgPruneAcknowledgementsResponse, MsgRecvPacket, MsgRecvPacketResponse, MsgTimeout, MsgTimeoutOnClose, MsgTimeoutOnCloseResponse, MsgTimeoutResponse, MsgUpdateParams, MsgUpdateParamsResponse } from "./tx_pb.js";
const TYPE_NAME = "ibc.core.channel.v1.Msg";
/**
* ChannelOpenInit defines a rpc handler method for MsgChannelOpenInit.
*
* @generated from rpc ibc.core.channel.v1.Msg.ChannelOpenInit
*/
export const MsgChannelOpenInitService = {
typeName: TYPE_NAME,
method: "ChannelOpenInit",
Request: MsgChannelOpenInit,
Response: MsgChannelOpenInitResponse,
} as const;
/**
* ChannelOpenTry defines a rpc handler method for MsgChannelOpenTry.
*
* @generated from rpc ibc.core.channel.v1.Msg.ChannelOpenTry
*/
export const MsgChannelOpenTryService = {
typeName: TYPE_NAME,
method: "ChannelOpenTry",
Request: MsgChannelOpenTry,
Response: MsgChannelOpenTryResponse,
} as const;
/**
* ChannelOpenAck defines a rpc handler method for MsgChannelOpenAck.
*
* @generated from rpc ibc.core.channel.v1.Msg.ChannelOpenAck
*/
export const MsgChannelOpenAckService = {
typeName: TYPE_NAME,
method: "ChannelOpenAck",
Request: MsgChannelOpenAck,
Response: MsgChannelOpenAckResponse,
} as const;
/**
* ChannelOpenConfirm defines a rpc handler method for MsgChannelOpenConfirm.
*
* @generated from rpc ibc.core.channel.v1.Msg.ChannelOpenConfirm
*/
export const MsgChannelOpenConfirmService = {
typeName: TYPE_NAME,
method: "ChannelOpenConfirm",
Request: MsgChannelOpenConfirm,
Response: MsgChannelOpenConfirmResponse,
} as const;
/**
* ChannelCloseInit defines a rpc handler method for MsgChannelCloseInit.
*
* @generated from rpc ibc.core.channel.v1.Msg.ChannelCloseInit
*/
export const MsgChannelCloseInitService = {
typeName: TYPE_NAME,
method: "ChannelCloseInit",
Request: MsgChannelCloseInit,
Response: MsgChannelCloseInitResponse,
} as const;
/**
* ChannelCloseConfirm defines a rpc handler method for
* MsgChannelCloseConfirm.
*
* @generated from rpc ibc.core.channel.v1.Msg.ChannelCloseConfirm
*/
export const MsgChannelCloseConfirmService = {
typeName: TYPE_NAME,
method: "ChannelCloseConfirm",
Request: MsgChannelCloseConfirm,
Response: MsgChannelCloseConfirmResponse,
} as const;
/**
* RecvPacket defines a rpc handler method for MsgRecvPacket.
*
* @generated from rpc ibc.core.channel.v1.Msg.RecvPacket
*/
export const MsgRecvPacketService = {
typeName: TYPE_NAME,
method: "RecvPacket",
Request: MsgRecvPacket,
Response: MsgRecvPacketResponse,
} as const;
/**
* Timeout defines a rpc handler method for MsgTimeout.
*
* @generated from rpc ibc.core.channel.v1.Msg.Timeout
*/
export const MsgTimeoutService = {
typeName: TYPE_NAME,
method: "Timeout",
Request: MsgTimeout,
Response: MsgTimeoutResponse,
} as const;
/**
* TimeoutOnClose defines a rpc handler method for MsgTimeoutOnClose.
*
* @generated from rpc ibc.core.channel.v1.Msg.TimeoutOnClose
*/
export const MsgTimeoutOnCloseService = {
typeName: TYPE_NAME,
method: "TimeoutOnClose",
Request: MsgTimeoutOnClose,
Response: MsgTimeoutOnCloseResponse,
} as const;
/**
* Acknowledgement defines a rpc handler method for MsgAcknowledgement.
*
* @generated from rpc ibc.core.channel.v1.Msg.Acknowledgement
*/
export const MsgAcknowledgementService = {
typeName: TYPE_NAME,
method: "Acknowledgement",
Request: MsgAcknowledgement,
Response: MsgAcknowledgementResponse,
} as const;
/**
* ChannelUpgradeInit defines a rpc handler method for MsgChannelUpgradeInit.
*
* @generated from rpc ibc.core.channel.v1.Msg.ChannelUpgradeInit
*/
export const MsgChannelUpgradeInitService = {
typeName: TYPE_NAME,
method: "ChannelUpgradeInit",
Request: MsgChannelUpgradeInit,
Response: MsgChannelUpgradeInitResponse,
} as const;
/**
* ChannelUpgradeTry defines a rpc handler method for MsgChannelUpgradeTry.
*
* @generated from rpc ibc.core.channel.v1.Msg.ChannelUpgradeTry
*/
export const MsgChannelUpgradeTryService = {
typeName: TYPE_NAME,
method: "ChannelUpgradeTry",
Request: MsgChannelUpgradeTry,
Response: MsgChannelUpgradeTryResponse,
} as const;
/**
* ChannelUpgradeAck defines a rpc handler method for MsgChannelUpgradeAck.
*
* @generated from rpc ibc.core.channel.v1.Msg.ChannelUpgradeAck
*/
export const MsgChannelUpgradeAckService = {
typeName: TYPE_NAME,
method: "ChannelUpgradeAck",
Request: MsgChannelUpgradeAck,
Response: MsgChannelUpgradeAckResponse,
} as const;
/**
* ChannelUpgradeConfirm defines a rpc handler method for MsgChannelUpgradeConfirm.
*
* @generated from rpc ibc.core.channel.v1.Msg.ChannelUpgradeConfirm
*/
export const MsgChannelUpgradeConfirmService = {
typeName: TYPE_NAME,
method: "ChannelUpgradeConfirm",
Request: MsgChannelUpgradeConfirm,
Response: MsgChannelUpgradeConfirmResponse,
} as const;
/**
* ChannelUpgradeOpen defines a rpc handler method for MsgChannelUpgradeOpen.
*
* @generated from rpc ibc.core.channel.v1.Msg.ChannelUpgradeOpen
*/
export const MsgChannelUpgradeOpenService = {
typeName: TYPE_NAME,
method: "ChannelUpgradeOpen",
Request: MsgChannelUpgradeOpen,
Response: MsgChannelUpgradeOpenResponse,
} as const;
/**
* ChannelUpgradeTimeout defines a rpc handler method for MsgChannelUpgradeTimeout.
*
* @generated from rpc ibc.core.channel.v1.Msg.ChannelUpgradeTimeout
*/
export const MsgChannelUpgradeTimeoutService = {
typeName: TYPE_NAME,
method: "ChannelUpgradeTimeout",
Request: MsgChannelUpgradeTimeout,
Response: MsgChannelUpgradeTimeoutResponse,
} as const;
/**
* ChannelUpgradeCancel defines a rpc handler method for MsgChannelUpgradeCancel.
*
* @generated from rpc ibc.core.channel.v1.Msg.ChannelUpgradeCancel
*/
export const MsgChannelUpgradeCancelService = {
typeName: TYPE_NAME,
method: "ChannelUpgradeCancel",
Request: MsgChannelUpgradeCancel,
Response: MsgChannelUpgradeCancelResponse,
} as const;
/**
* UpdateChannelParams defines a rpc handler method for MsgUpdateParams.
*
* @generated from rpc ibc.core.channel.v1.Msg.UpdateChannelParams
*/
export const MsgUpdateChannelParamsService = {
typeName: TYPE_NAME,
method: "UpdateChannelParams",
Request: MsgUpdateParams,
Response: MsgUpdateParamsResponse,
} as const;
/**
* PruneAcknowledgements defines a rpc handler method for MsgPruneAcknowledgements.
*
* @generated from rpc ibc.core.channel.v1.Msg.PruneAcknowledgements
*/
export const MsgPruneAcknowledgementsService = {
typeName: TYPE_NAME,
method: "PruneAcknowledgements",
Request: MsgPruneAcknowledgements,
Response: MsgPruneAcknowledgementsResponse,
} as const;

2068
libs/es-client/src/protobufs/ibc/core/channel/v1/tx_pb.ts Normal file
View File

File diff suppressed because it is too large Load Diff

167
libs/es-client/src/protobufs/ibc/core/channel/v1/upgrade_pb.ts Normal file
View File

@ -0,0 +1,167 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/core/channel/v1/upgrade.proto (package ibc.core.channel.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, protoInt64 } from "@bufbuild/protobuf";
import { Order, Timeout } from "./channel_pb.js";
/**
* Upgrade is a verifiable type which contains the relevant information
* for an attempted upgrade. It provides the proposed changes to the channel
* end, the timeout for this upgrade attempt and the next packet sequence
* which allows the counterparty to efficiently know the highest sequence it has received.
* The next sequence send is used for pruning and upgrading from unordered to ordered channels.
*
* @generated from message ibc.core.channel.v1.Upgrade
*/
export class Upgrade extends Message<Upgrade> {
/**
* @generated from field: ibc.core.channel.v1.UpgradeFields fields = 1;
*/
fields?: UpgradeFields;
/**
* @generated from field: ibc.core.channel.v1.Timeout timeout = 2;
*/
timeout?: Timeout;
/**
* @generated from field: uint64 next_sequence_send = 3;
*/
nextSequenceSend = protoInt64.zero;
constructor(data?: PartialMessage<Upgrade>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.channel.v1.Upgrade";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "fields", kind: "message", T: UpgradeFields },
{ no: 2, name: "timeout", kind: "message", T: Timeout },
{ no: 3, name: "next_sequence_send", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Upgrade {
return new Upgrade().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Upgrade {
return new Upgrade().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Upgrade {
return new Upgrade().fromJsonString(jsonString, options);
}
static equals(a: Upgrade | PlainMessage<Upgrade> | undefined, b: Upgrade | PlainMessage<Upgrade> | undefined): boolean {
return proto3.util.equals(Upgrade, a, b);
}
}
/**
* UpgradeFields are the fields in a channel end which may be changed
* during a channel upgrade.
*
* @generated from message ibc.core.channel.v1.UpgradeFields
*/
export class UpgradeFields extends Message<UpgradeFields> {
/**
* @generated from field: ibc.core.channel.v1.Order ordering = 1;
*/
ordering = Order.NONE_UNSPECIFIED;
/**
* @generated from field: repeated string connection_hops = 2;
*/
connectionHops: string[] = [];
/**
* @generated from field: string version = 3;
*/
version = "";
constructor(data?: PartialMessage<UpgradeFields>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.channel.v1.UpgradeFields";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "ordering", kind: "enum", T: proto3.getEnumType(Order) },
{ no: 2, name: "connection_hops", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
{ no: 3, name: "version", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpgradeFields {
return new UpgradeFields().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpgradeFields {
return new UpgradeFields().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpgradeFields {
return new UpgradeFields().fromJsonString(jsonString, options);
}
static equals(a: UpgradeFields | PlainMessage<UpgradeFields> | undefined, b: UpgradeFields | PlainMessage<UpgradeFields> | undefined): boolean {
return proto3.util.equals(UpgradeFields, a, b);
}
}
/**
* ErrorReceipt defines a type which encapsulates the upgrade sequence and error associated with the
* upgrade handshake failure. When a channel upgrade handshake is aborted both chains are expected to increment to the
* next sequence.
*
* @generated from message ibc.core.channel.v1.ErrorReceipt
*/
export class ErrorReceipt extends Message<ErrorReceipt> {
/**
* the channel upgrade sequence
*
* @generated from field: uint64 sequence = 1;
*/
sequence = protoInt64.zero;
/**
* the error message detailing the cause of failure
*
* @generated from field: string message = 2;
*/
message = "";
constructor(data?: PartialMessage<ErrorReceipt>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.channel.v1.ErrorReceipt";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 2, name: "message", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ErrorReceipt {
return new ErrorReceipt().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ErrorReceipt {
return new ErrorReceipt().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ErrorReceipt {
return new ErrorReceipt().fromJsonString(jsonString, options);
}
static equals(a: ErrorReceipt | PlainMessage<ErrorReceipt> | undefined, b: ErrorReceipt | PlainMessage<ErrorReceipt> | undefined): boolean {
return proto3.util.equals(ErrorReceipt, a, b);
}
}

262
libs/es-client/src/protobufs/ibc/core/client/v1/client_pb.ts Normal file
View File

@ -0,0 +1,262 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/core/client/v1/client.proto (package ibc.core.client.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Any, Message, proto3, protoInt64 } from "@bufbuild/protobuf";
/**
* IdentifiedClientState defines a client state with an additional client
* identifier field.
*
* @generated from message ibc.core.client.v1.IdentifiedClientState
*/
export class IdentifiedClientState extends Message<IdentifiedClientState> {
/**
* client identifier
*
* @generated from field: string client_id = 1;
*/
clientId = "";
/**
* client state
*
* @generated from field: google.protobuf.Any client_state = 2;
*/
clientState?: Any;
constructor(data?: PartialMessage<IdentifiedClientState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.IdentifiedClientState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "client_state", kind: "message", T: Any },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): IdentifiedClientState {
return new IdentifiedClientState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): IdentifiedClientState {
return new IdentifiedClientState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): IdentifiedClientState {
return new IdentifiedClientState().fromJsonString(jsonString, options);
}
static equals(a: IdentifiedClientState | PlainMessage<IdentifiedClientState> | undefined, b: IdentifiedClientState | PlainMessage<IdentifiedClientState> | undefined): boolean {
return proto3.util.equals(IdentifiedClientState, a, b);
}
}
/**
* ConsensusStateWithHeight defines a consensus state with an additional height
* field.
*
* @generated from message ibc.core.client.v1.ConsensusStateWithHeight
*/
export class ConsensusStateWithHeight extends Message<ConsensusStateWithHeight> {
/**
* consensus state height
*
* @generated from field: ibc.core.client.v1.Height height = 1;
*/
height?: Height;
/**
* consensus state
*
* @generated from field: google.protobuf.Any consensus_state = 2;
*/
consensusState?: Any;
constructor(data?: PartialMessage<ConsensusStateWithHeight>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.ConsensusStateWithHeight";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "height", kind: "message", T: Height },
{ no: 2, name: "consensus_state", kind: "message", T: Any },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConsensusStateWithHeight {
return new ConsensusStateWithHeight().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConsensusStateWithHeight {
return new ConsensusStateWithHeight().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConsensusStateWithHeight {
return new ConsensusStateWithHeight().fromJsonString(jsonString, options);
}
static equals(a: ConsensusStateWithHeight | PlainMessage<ConsensusStateWithHeight> | undefined, b: ConsensusStateWithHeight | PlainMessage<ConsensusStateWithHeight> | undefined): boolean {
return proto3.util.equals(ConsensusStateWithHeight, a, b);
}
}
/**
* ClientConsensusStates defines all the stored consensus states for a given
* client.
*
* @generated from message ibc.core.client.v1.ClientConsensusStates
*/
export class ClientConsensusStates extends Message<ClientConsensusStates> {
/**
* client identifier
*
* @generated from field: string client_id = 1;
*/
clientId = "";
/**
* consensus states and their heights associated with the client
*
* @generated from field: repeated ibc.core.client.v1.ConsensusStateWithHeight consensus_states = 2;
*/
consensusStates: ConsensusStateWithHeight[] = [];
constructor(data?: PartialMessage<ClientConsensusStates>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.ClientConsensusStates";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "consensus_states", kind: "message", T: ConsensusStateWithHeight, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ClientConsensusStates {
return new ClientConsensusStates().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ClientConsensusStates {
return new ClientConsensusStates().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ClientConsensusStates {
return new ClientConsensusStates().fromJsonString(jsonString, options);
}
static equals(a: ClientConsensusStates | PlainMessage<ClientConsensusStates> | undefined, b: ClientConsensusStates | PlainMessage<ClientConsensusStates> | undefined): boolean {
return proto3.util.equals(ClientConsensusStates, a, b);
}
}
/**
* Height is a monotonically increasing data type
* that can be compared against another Height for the purposes of updating and
* freezing clients
*
* Normally the RevisionHeight is incremented at each height while keeping
* RevisionNumber the same. However some consensus algorithms may choose to
* reset the height in certain conditions e.g. hard forks, state-machine
* breaking changes In these cases, the RevisionNumber is incremented so that
* height continues to be monitonically increasing even as the RevisionHeight
* gets reset
*
* Please note that json tags for generated Go code are overridden to explicitly exclude the omitempty jsontag.
* This enforces the Go json marshaller to always emit zero values for both revision_number and revision_height.
*
* @generated from message ibc.core.client.v1.Height
*/
export class Height extends Message<Height> {
/**
* the revision that the client is currently on
*
* @generated from field: uint64 revision_number = 1;
*/
revisionNumber = protoInt64.zero;
/**
* the height within the given revision
*
* @generated from field: uint64 revision_height = 2;
*/
revisionHeight = protoInt64.zero;
constructor(data?: PartialMessage<Height>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.Height";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "revision_number", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 2, name: "revision_height", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Height {
return new Height().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Height {
return new Height().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Height {
return new Height().fromJsonString(jsonString, options);
}
static equals(a: Height | PlainMessage<Height> | undefined, b: Height | PlainMessage<Height> | undefined): boolean {
return proto3.util.equals(Height, a, b);
}
}
/**
* Params defines the set of IBC light client parameters.
*
* @generated from message ibc.core.client.v1.Params
*/
export class Params extends Message<Params> {
/**
* allowed_clients defines the list of allowed client state types which can be created
* and interacted with. If a client type is removed from the allowed clients list, usage
* of this client will be disabled until it is added again to the list.
*
* @generated from field: repeated string allowed_clients = 1;
*/
allowedClients: string[] = [];
constructor(data?: PartialMessage<Params>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.Params";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "allowed_clients", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Params {
return new Params().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Params {
return new Params().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Params {
return new Params().fromJsonString(jsonString, options);
}
static equals(a: Params | PlainMessage<Params> | undefined, b: Params | PlainMessage<Params> | undefined): boolean {
return proto3.util.equals(Params, a, b);
}
}

186
libs/es-client/src/protobufs/ibc/core/client/v1/genesis_pb.ts Normal file
View File

@ -0,0 +1,186 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/core/client/v1/genesis.proto (package ibc.core.client.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, protoInt64 } from "@bufbuild/protobuf";
import { ClientConsensusStates, IdentifiedClientState, Params } from "./client_pb.js";
/**
* GenesisState defines the ibc client submodule's genesis state.
*
* @generated from message ibc.core.client.v1.GenesisState
*/
export class GenesisState extends Message<GenesisState> {
/**
* client states with their corresponding identifiers
*
* @generated from field: repeated ibc.core.client.v1.IdentifiedClientState clients = 1;
*/
clients: IdentifiedClientState[] = [];
/**
* consensus states from each client
*
* @generated from field: repeated ibc.core.client.v1.ClientConsensusStates clients_consensus = 2;
*/
clientsConsensus: ClientConsensusStates[] = [];
/**
* metadata from each client
*
* @generated from field: repeated ibc.core.client.v1.IdentifiedGenesisMetadata clients_metadata = 3;
*/
clientsMetadata: IdentifiedGenesisMetadata[] = [];
/**
* @generated from field: ibc.core.client.v1.Params params = 4;
*/
params?: Params;
/**
* Deprecated: create_localhost has been deprecated.
* The localhost client is automatically created at genesis.
*
* @generated from field: bool create_localhost = 5 [deprecated = true];
* @deprecated
*/
createLocalhost = false;
/**
* the sequence for the next generated client identifier
*
* @generated from field: uint64 next_client_sequence = 6;
*/
nextClientSequence = protoInt64.zero;
constructor(data?: PartialMessage<GenesisState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.GenesisState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "clients", kind: "message", T: IdentifiedClientState, repeated: true },
{ no: 2, name: "clients_consensus", kind: "message", T: ClientConsensusStates, repeated: true },
{ no: 3, name: "clients_metadata", kind: "message", T: IdentifiedGenesisMetadata, repeated: true },
{ no: 4, name: "params", kind: "message", T: Params },
{ no: 5, name: "create_localhost", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
{ no: 6, name: "next_client_sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GenesisState {
return new GenesisState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJsonString(jsonString, options);
}
static equals(a: GenesisState | PlainMessage<GenesisState> | undefined, b: GenesisState | PlainMessage<GenesisState> | undefined): boolean {
return proto3.util.equals(GenesisState, a, b);
}
}
/**
* GenesisMetadata defines the genesis type for metadata that will be used
* to export all client store keys that are not client or consensus states.
*
* @generated from message ibc.core.client.v1.GenesisMetadata
*/
export class GenesisMetadata extends Message<GenesisMetadata> {
/**
* store key of metadata without clientID-prefix
*
* @generated from field: bytes key = 1;
*/
key = new Uint8Array(0);
/**
* metadata value
*
* @generated from field: bytes value = 2;
*/
value = new Uint8Array(0);
constructor(data?: PartialMessage<GenesisMetadata>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.GenesisMetadata";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "key", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "value", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GenesisMetadata {
return new GenesisMetadata().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GenesisMetadata {
return new GenesisMetadata().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GenesisMetadata {
return new GenesisMetadata().fromJsonString(jsonString, options);
}
static equals(a: GenesisMetadata | PlainMessage<GenesisMetadata> | undefined, b: GenesisMetadata | PlainMessage<GenesisMetadata> | undefined): boolean {
return proto3.util.equals(GenesisMetadata, a, b);
}
}
/**
* IdentifiedGenesisMetadata has the client metadata with the corresponding
* client id.
*
* @generated from message ibc.core.client.v1.IdentifiedGenesisMetadata
*/
export class IdentifiedGenesisMetadata extends Message<IdentifiedGenesisMetadata> {
/**
* @generated from field: string client_id = 1;
*/
clientId = "";
/**
* @generated from field: repeated ibc.core.client.v1.GenesisMetadata client_metadata = 2;
*/
clientMetadata: GenesisMetadata[] = [];
constructor(data?: PartialMessage<IdentifiedGenesisMetadata>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.IdentifiedGenesisMetadata";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "client_metadata", kind: "message", T: GenesisMetadata, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): IdentifiedGenesisMetadata {
return new IdentifiedGenesisMetadata().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): IdentifiedGenesisMetadata {
return new IdentifiedGenesisMetadata().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): IdentifiedGenesisMetadata {
return new IdentifiedGenesisMetadata().fromJsonString(jsonString, options);
}
static equals(a: IdentifiedGenesisMetadata | PlainMessage<IdentifiedGenesisMetadata> | undefined, b: IdentifiedGenesisMetadata | PlainMessage<IdentifiedGenesisMetadata> | undefined): boolean {
return proto3.util.equals(IdentifiedGenesisMetadata, a, b);
}
}

131
libs/es-client/src/protobufs/ibc/core/client/v1/query_cosmes.ts Normal file
View File

@ -0,0 +1,131 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file ibc/core/client/v1/query.proto (package ibc.core.client.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { QueryClientParamsRequest, QueryClientParamsResponse, QueryClientStateRequest, QueryClientStateResponse, QueryClientStatesRequest, QueryClientStatesResponse, QueryClientStatusRequest, QueryClientStatusResponse, QueryConsensusStateHeightsRequest, QueryConsensusStateHeightsResponse, QueryConsensusStateRequest, QueryConsensusStateResponse, QueryConsensusStatesRequest, QueryConsensusStatesResponse, QueryUpgradedClientStateRequest, QueryUpgradedClientStateResponse, QueryUpgradedConsensusStateRequest, QueryUpgradedConsensusStateResponse, QueryVerifyMembershipRequest, QueryVerifyMembershipResponse } from "./query_pb.js";
const TYPE_NAME = "ibc.core.client.v1.Query";
/**
* ClientState queries an IBC light client.
*
* @generated from rpc ibc.core.client.v1.Query.ClientState
*/
export const QueryClientStateService = {
typeName: TYPE_NAME,
method: "ClientState",
Request: QueryClientStateRequest,
Response: QueryClientStateResponse,
} as const;
/**
* ClientStates queries all the IBC light clients of a chain.
*
* @generated from rpc ibc.core.client.v1.Query.ClientStates
*/
export const QueryClientStatesService = {
typeName: TYPE_NAME,
method: "ClientStates",
Request: QueryClientStatesRequest,
Response: QueryClientStatesResponse,
} as const;
/**
* ConsensusState queries a consensus state associated with a client state at
* a given height.
*
* @generated from rpc ibc.core.client.v1.Query.ConsensusState
*/
export const QueryConsensusStateService = {
typeName: TYPE_NAME,
method: "ConsensusState",
Request: QueryConsensusStateRequest,
Response: QueryConsensusStateResponse,
} as const;
/**
* ConsensusStates queries all the consensus state associated with a given
* client.
*
* @generated from rpc ibc.core.client.v1.Query.ConsensusStates
*/
export const QueryConsensusStatesService = {
typeName: TYPE_NAME,
method: "ConsensusStates",
Request: QueryConsensusStatesRequest,
Response: QueryConsensusStatesResponse,
} as const;
/**
* ConsensusStateHeights queries the height of every consensus states associated with a given client.
*
* @generated from rpc ibc.core.client.v1.Query.ConsensusStateHeights
*/
export const QueryConsensusStateHeightsService = {
typeName: TYPE_NAME,
method: "ConsensusStateHeights",
Request: QueryConsensusStateHeightsRequest,
Response: QueryConsensusStateHeightsResponse,
} as const;
/**
* Status queries the status of an IBC client.
*
* @generated from rpc ibc.core.client.v1.Query.ClientStatus
*/
export const QueryClientStatusService = {
typeName: TYPE_NAME,
method: "ClientStatus",
Request: QueryClientStatusRequest,
Response: QueryClientStatusResponse,
} as const;
/**
* ClientParams queries all parameters of the ibc client submodule.
*
* @generated from rpc ibc.core.client.v1.Query.ClientParams
*/
export const QueryClientParamsService = {
typeName: TYPE_NAME,
method: "ClientParams",
Request: QueryClientParamsRequest,
Response: QueryClientParamsResponse,
} as const;
/**
* UpgradedClientState queries an Upgraded IBC light client.
*
* @generated from rpc ibc.core.client.v1.Query.UpgradedClientState
*/
export const QueryUpgradedClientStateService = {
typeName: TYPE_NAME,
method: "UpgradedClientState",
Request: QueryUpgradedClientStateRequest,
Response: QueryUpgradedClientStateResponse,
} as const;
/**
* UpgradedConsensusState queries an Upgraded IBC consensus state.
*
* @generated from rpc ibc.core.client.v1.Query.UpgradedConsensusState
*/
export const QueryUpgradedConsensusStateService = {
typeName: TYPE_NAME,
method: "UpgradedConsensusState",
Request: QueryUpgradedConsensusStateRequest,
Response: QueryUpgradedConsensusStateResponse,
} as const;
/**
* VerifyMembership queries an IBC light client for proof verification of a value at a given key path.
*
* @generated from rpc ibc.core.client.v1.Query.VerifyMembership
*/
export const QueryVerifyMembershipService = {
typeName: TYPE_NAME,
method: "VerifyMembership",
Request: QueryVerifyMembershipRequest,
Response: QueryVerifyMembershipResponse,
} as const;

970
libs/es-client/src/protobufs/ibc/core/client/v1/query_pb.ts Normal file
View File

@ -0,0 +1,970 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/core/client/v1/query.proto (package ibc.core.client.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Any, Message, proto3, protoInt64 } from "@bufbuild/protobuf";
import { ConsensusStateWithHeight, Height, IdentifiedClientState, Params } from "./client_pb.js";
import { PageRequest, PageResponse } from "../../../../cosmos/base/query/v1beta1/pagination_pb.js";
import { MerklePath } from "../../commitment/v2/commitment_pb.js";
/**
* QueryClientStateRequest is the request type for the Query/ClientState RPC
* method
*
* @generated from message ibc.core.client.v1.QueryClientStateRequest
*/
export class QueryClientStateRequest extends Message<QueryClientStateRequest> {
/**
* client state unique identifier
*
* @generated from field: string client_id = 1;
*/
clientId = "";
constructor(data?: PartialMessage<QueryClientStateRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.QueryClientStateRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryClientStateRequest {
return new QueryClientStateRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryClientStateRequest {
return new QueryClientStateRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryClientStateRequest {
return new QueryClientStateRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryClientStateRequest | PlainMessage<QueryClientStateRequest> | undefined, b: QueryClientStateRequest | PlainMessage<QueryClientStateRequest> | undefined): boolean {
return proto3.util.equals(QueryClientStateRequest, a, b);
}
}
/**
* QueryClientStateResponse is the response type for the Query/ClientState RPC
* method. Besides the client state, it includes a proof and the height from
* which the proof was retrieved.
*
* @generated from message ibc.core.client.v1.QueryClientStateResponse
*/
export class QueryClientStateResponse extends Message<QueryClientStateResponse> {
/**
* client state associated with the request identifier
*
* @generated from field: google.protobuf.Any client_state = 1;
*/
clientState?: Any;
/**
* merkle proof of existence
*
* @generated from field: bytes proof = 2;
*/
proof = new Uint8Array(0);
/**
* height at which the proof was retrieved
*
* @generated from field: ibc.core.client.v1.Height proof_height = 3;
*/
proofHeight?: Height;
constructor(data?: PartialMessage<QueryClientStateResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.QueryClientStateResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_state", kind: "message", T: Any },
{ no: 2, name: "proof", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 3, name: "proof_height", kind: "message", T: Height },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryClientStateResponse {
return new QueryClientStateResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryClientStateResponse {
return new QueryClientStateResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryClientStateResponse {
return new QueryClientStateResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryClientStateResponse | PlainMessage<QueryClientStateResponse> | undefined, b: QueryClientStateResponse | PlainMessage<QueryClientStateResponse> | undefined): boolean {
return proto3.util.equals(QueryClientStateResponse, a, b);
}
}
/**
* QueryClientStatesRequest is the request type for the Query/ClientStates RPC
* method
*
* @generated from message ibc.core.client.v1.QueryClientStatesRequest
*/
export class QueryClientStatesRequest extends Message<QueryClientStatesRequest> {
/**
* pagination request
*
* @generated from field: cosmos.base.query.v1beta1.PageRequest pagination = 1;
*/
pagination?: PageRequest;
constructor(data?: PartialMessage<QueryClientStatesRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.QueryClientStatesRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "pagination", kind: "message", T: PageRequest },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryClientStatesRequest {
return new QueryClientStatesRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryClientStatesRequest {
return new QueryClientStatesRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryClientStatesRequest {
return new QueryClientStatesRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryClientStatesRequest | PlainMessage<QueryClientStatesRequest> | undefined, b: QueryClientStatesRequest | PlainMessage<QueryClientStatesRequest> | undefined): boolean {
return proto3.util.equals(QueryClientStatesRequest, a, b);
}
}
/**
* QueryClientStatesResponse is the response type for the Query/ClientStates RPC
* method.
*
* @generated from message ibc.core.client.v1.QueryClientStatesResponse
*/
export class QueryClientStatesResponse extends Message<QueryClientStatesResponse> {
/**
* list of stored ClientStates of the chain.
*
* @generated from field: repeated ibc.core.client.v1.IdentifiedClientState client_states = 1;
*/
clientStates: IdentifiedClientState[] = [];
/**
* pagination response
*
* @generated from field: cosmos.base.query.v1beta1.PageResponse pagination = 2;
*/
pagination?: PageResponse;
constructor(data?: PartialMessage<QueryClientStatesResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.QueryClientStatesResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_states", kind: "message", T: IdentifiedClientState, repeated: true },
{ no: 2, name: "pagination", kind: "message", T: PageResponse },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryClientStatesResponse {
return new QueryClientStatesResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryClientStatesResponse {
return new QueryClientStatesResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryClientStatesResponse {
return new QueryClientStatesResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryClientStatesResponse | PlainMessage<QueryClientStatesResponse> | undefined, b: QueryClientStatesResponse | PlainMessage<QueryClientStatesResponse> | undefined): boolean {
return proto3.util.equals(QueryClientStatesResponse, a, b);
}
}
/**
* QueryConsensusStateRequest is the request type for the Query/ConsensusState
* RPC method. Besides the consensus state, it includes a proof and the height
* from which the proof was retrieved.
*
* @generated from message ibc.core.client.v1.QueryConsensusStateRequest
*/
export class QueryConsensusStateRequest extends Message<QueryConsensusStateRequest> {
/**
* client identifier
*
* @generated from field: string client_id = 1;
*/
clientId = "";
/**
* consensus state revision number
*
* @generated from field: uint64 revision_number = 2;
*/
revisionNumber = protoInt64.zero;
/**
* consensus state revision height
*
* @generated from field: uint64 revision_height = 3;
*/
revisionHeight = protoInt64.zero;
/**
* latest_height overrides the height field and queries the latest stored
* ConsensusState
*
* @generated from field: bool latest_height = 4;
*/
latestHeight = false;
constructor(data?: PartialMessage<QueryConsensusStateRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.QueryConsensusStateRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "revision_number", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 3, name: "revision_height", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 4, name: "latest_height", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryConsensusStateRequest {
return new QueryConsensusStateRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryConsensusStateRequest {
return new QueryConsensusStateRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryConsensusStateRequest {
return new QueryConsensusStateRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryConsensusStateRequest | PlainMessage<QueryConsensusStateRequest> | undefined, b: QueryConsensusStateRequest | PlainMessage<QueryConsensusStateRequest> | undefined): boolean {
return proto3.util.equals(QueryConsensusStateRequest, a, b);
}
}
/**
* QueryConsensusStateResponse is the response type for the Query/ConsensusState
* RPC method
*
* @generated from message ibc.core.client.v1.QueryConsensusStateResponse
*/
export class QueryConsensusStateResponse extends Message<QueryConsensusStateResponse> {
/**
* consensus state associated with the client identifier at the given height
*
* @generated from field: google.protobuf.Any consensus_state = 1;
*/
consensusState?: Any;
/**
* merkle proof of existence
*
* @generated from field: bytes proof = 2;
*/
proof = new Uint8Array(0);
/**
* height at which the proof was retrieved
*
* @generated from field: ibc.core.client.v1.Height proof_height = 3;
*/
proofHeight?: Height;
constructor(data?: PartialMessage<QueryConsensusStateResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.QueryConsensusStateResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "consensus_state", kind: "message", T: Any },
{ no: 2, name: "proof", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 3, name: "proof_height", kind: "message", T: Height },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryConsensusStateResponse {
return new QueryConsensusStateResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryConsensusStateResponse {
return new QueryConsensusStateResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryConsensusStateResponse {
return new QueryConsensusStateResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryConsensusStateResponse | PlainMessage<QueryConsensusStateResponse> | undefined, b: QueryConsensusStateResponse | PlainMessage<QueryConsensusStateResponse> | undefined): boolean {
return proto3.util.equals(QueryConsensusStateResponse, a, b);
}
}
/**
* QueryConsensusStatesRequest is the request type for the Query/ConsensusStates
* RPC method.
*
* @generated from message ibc.core.client.v1.QueryConsensusStatesRequest
*/
export class QueryConsensusStatesRequest extends Message<QueryConsensusStatesRequest> {
/**
* client identifier
*
* @generated from field: string client_id = 1;
*/
clientId = "";
/**
* pagination request
*
* @generated from field: cosmos.base.query.v1beta1.PageRequest pagination = 2;
*/
pagination?: PageRequest;
constructor(data?: PartialMessage<QueryConsensusStatesRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.QueryConsensusStatesRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "pagination", kind: "message", T: PageRequest },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryConsensusStatesRequest {
return new QueryConsensusStatesRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryConsensusStatesRequest {
return new QueryConsensusStatesRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryConsensusStatesRequest {
return new QueryConsensusStatesRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryConsensusStatesRequest | PlainMessage<QueryConsensusStatesRequest> | undefined, b: QueryConsensusStatesRequest | PlainMessage<QueryConsensusStatesRequest> | undefined): boolean {
return proto3.util.equals(QueryConsensusStatesRequest, a, b);
}
}
/**
* QueryConsensusStatesResponse is the response type for the
* Query/ConsensusStates RPC method
*
* @generated from message ibc.core.client.v1.QueryConsensusStatesResponse
*/
export class QueryConsensusStatesResponse extends Message<QueryConsensusStatesResponse> {
/**
* consensus states associated with the identifier
*
* @generated from field: repeated ibc.core.client.v1.ConsensusStateWithHeight consensus_states = 1;
*/
consensusStates: ConsensusStateWithHeight[] = [];
/**
* pagination response
*
* @generated from field: cosmos.base.query.v1beta1.PageResponse pagination = 2;
*/
pagination?: PageResponse;
constructor(data?: PartialMessage<QueryConsensusStatesResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.QueryConsensusStatesResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "consensus_states", kind: "message", T: ConsensusStateWithHeight, repeated: true },
{ no: 2, name: "pagination", kind: "message", T: PageResponse },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryConsensusStatesResponse {
return new QueryConsensusStatesResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryConsensusStatesResponse {
return new QueryConsensusStatesResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryConsensusStatesResponse {
return new QueryConsensusStatesResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryConsensusStatesResponse | PlainMessage<QueryConsensusStatesResponse> | undefined, b: QueryConsensusStatesResponse | PlainMessage<QueryConsensusStatesResponse> | undefined): boolean {
return proto3.util.equals(QueryConsensusStatesResponse, a, b);
}
}
/**
* QueryConsensusStateHeightsRequest is the request type for Query/ConsensusStateHeights
* RPC method.
*
* @generated from message ibc.core.client.v1.QueryConsensusStateHeightsRequest
*/
export class QueryConsensusStateHeightsRequest extends Message<QueryConsensusStateHeightsRequest> {
/**
* client identifier
*
* @generated from field: string client_id = 1;
*/
clientId = "";
/**
* pagination request
*
* @generated from field: cosmos.base.query.v1beta1.PageRequest pagination = 2;
*/
pagination?: PageRequest;
constructor(data?: PartialMessage<QueryConsensusStateHeightsRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.QueryConsensusStateHeightsRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "pagination", kind: "message", T: PageRequest },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryConsensusStateHeightsRequest {
return new QueryConsensusStateHeightsRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryConsensusStateHeightsRequest {
return new QueryConsensusStateHeightsRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryConsensusStateHeightsRequest {
return new QueryConsensusStateHeightsRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryConsensusStateHeightsRequest | PlainMessage<QueryConsensusStateHeightsRequest> | undefined, b: QueryConsensusStateHeightsRequest | PlainMessage<QueryConsensusStateHeightsRequest> | undefined): boolean {
return proto3.util.equals(QueryConsensusStateHeightsRequest, a, b);
}
}
/**
* QueryConsensusStateHeightsResponse is the response type for the
* Query/ConsensusStateHeights RPC method
*
* @generated from message ibc.core.client.v1.QueryConsensusStateHeightsResponse
*/
export class QueryConsensusStateHeightsResponse extends Message<QueryConsensusStateHeightsResponse> {
/**
* consensus state heights
*
* @generated from field: repeated ibc.core.client.v1.Height consensus_state_heights = 1;
*/
consensusStateHeights: Height[] = [];
/**
* pagination response
*
* @generated from field: cosmos.base.query.v1beta1.PageResponse pagination = 2;
*/
pagination?: PageResponse;
constructor(data?: PartialMessage<QueryConsensusStateHeightsResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.QueryConsensusStateHeightsResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "consensus_state_heights", kind: "message", T: Height, repeated: true },
{ no: 2, name: "pagination", kind: "message", T: PageResponse },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryConsensusStateHeightsResponse {
return new QueryConsensusStateHeightsResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryConsensusStateHeightsResponse {
return new QueryConsensusStateHeightsResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryConsensusStateHeightsResponse {
return new QueryConsensusStateHeightsResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryConsensusStateHeightsResponse | PlainMessage<QueryConsensusStateHeightsResponse> | undefined, b: QueryConsensusStateHeightsResponse | PlainMessage<QueryConsensusStateHeightsResponse> | undefined): boolean {
return proto3.util.equals(QueryConsensusStateHeightsResponse, a, b);
}
}
/**
* QueryClientStatusRequest is the request type for the Query/ClientStatus RPC
* method
*
* @generated from message ibc.core.client.v1.QueryClientStatusRequest
*/
export class QueryClientStatusRequest extends Message<QueryClientStatusRequest> {
/**
* client unique identifier
*
* @generated from field: string client_id = 1;
*/
clientId = "";
constructor(data?: PartialMessage<QueryClientStatusRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.QueryClientStatusRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryClientStatusRequest {
return new QueryClientStatusRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryClientStatusRequest {
return new QueryClientStatusRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryClientStatusRequest {
return new QueryClientStatusRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryClientStatusRequest | PlainMessage<QueryClientStatusRequest> | undefined, b: QueryClientStatusRequest | PlainMessage<QueryClientStatusRequest> | undefined): boolean {
return proto3.util.equals(QueryClientStatusRequest, a, b);
}
}
/**
* QueryClientStatusResponse is the response type for the Query/ClientStatus RPC
* method. It returns the current status of the IBC client.
*
* @generated from message ibc.core.client.v1.QueryClientStatusResponse
*/
export class QueryClientStatusResponse extends Message<QueryClientStatusResponse> {
/**
* @generated from field: string status = 1;
*/
status = "";
constructor(data?: PartialMessage<QueryClientStatusResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.QueryClientStatusResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "status", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryClientStatusResponse {
return new QueryClientStatusResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryClientStatusResponse {
return new QueryClientStatusResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryClientStatusResponse {
return new QueryClientStatusResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryClientStatusResponse | PlainMessage<QueryClientStatusResponse> | undefined, b: QueryClientStatusResponse | PlainMessage<QueryClientStatusResponse> | undefined): boolean {
return proto3.util.equals(QueryClientStatusResponse, a, b);
}
}
/**
* QueryClientParamsRequest is the request type for the Query/ClientParams RPC
* method.
*
* @generated from message ibc.core.client.v1.QueryClientParamsRequest
*/
export class QueryClientParamsRequest extends Message<QueryClientParamsRequest> {
constructor(data?: PartialMessage<QueryClientParamsRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.QueryClientParamsRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryClientParamsRequest {
return new QueryClientParamsRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryClientParamsRequest {
return new QueryClientParamsRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryClientParamsRequest {
return new QueryClientParamsRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryClientParamsRequest | PlainMessage<QueryClientParamsRequest> | undefined, b: QueryClientParamsRequest | PlainMessage<QueryClientParamsRequest> | undefined): boolean {
return proto3.util.equals(QueryClientParamsRequest, a, b);
}
}
/**
* QueryClientParamsResponse is the response type for the Query/ClientParams RPC
* method.
*
* @generated from message ibc.core.client.v1.QueryClientParamsResponse
*/
export class QueryClientParamsResponse extends Message<QueryClientParamsResponse> {
/**
* params defines the parameters of the module.
*
* @generated from field: ibc.core.client.v1.Params params = 1;
*/
params?: Params;
constructor(data?: PartialMessage<QueryClientParamsResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.QueryClientParamsResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "params", kind: "message", T: Params },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryClientParamsResponse {
return new QueryClientParamsResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryClientParamsResponse {
return new QueryClientParamsResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryClientParamsResponse {
return new QueryClientParamsResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryClientParamsResponse | PlainMessage<QueryClientParamsResponse> | undefined, b: QueryClientParamsResponse | PlainMessage<QueryClientParamsResponse> | undefined): boolean {
return proto3.util.equals(QueryClientParamsResponse, a, b);
}
}
/**
* QueryUpgradedClientStateRequest is the request type for the
* Query/UpgradedClientState RPC method
*
* @generated from message ibc.core.client.v1.QueryUpgradedClientStateRequest
*/
export class QueryUpgradedClientStateRequest extends Message<QueryUpgradedClientStateRequest> {
constructor(data?: PartialMessage<QueryUpgradedClientStateRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.QueryUpgradedClientStateRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryUpgradedClientStateRequest {
return new QueryUpgradedClientStateRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryUpgradedClientStateRequest {
return new QueryUpgradedClientStateRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryUpgradedClientStateRequest {
return new QueryUpgradedClientStateRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryUpgradedClientStateRequest | PlainMessage<QueryUpgradedClientStateRequest> | undefined, b: QueryUpgradedClientStateRequest | PlainMessage<QueryUpgradedClientStateRequest> | undefined): boolean {
return proto3.util.equals(QueryUpgradedClientStateRequest, a, b);
}
}
/**
* QueryUpgradedClientStateResponse is the response type for the
* Query/UpgradedClientState RPC method.
*
* @generated from message ibc.core.client.v1.QueryUpgradedClientStateResponse
*/
export class QueryUpgradedClientStateResponse extends Message<QueryUpgradedClientStateResponse> {
/**
* client state associated with the request identifier
*
* @generated from field: google.protobuf.Any upgraded_client_state = 1;
*/
upgradedClientState?: Any;
constructor(data?: PartialMessage<QueryUpgradedClientStateResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.QueryUpgradedClientStateResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "upgraded_client_state", kind: "message", T: Any },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryUpgradedClientStateResponse {
return new QueryUpgradedClientStateResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryUpgradedClientStateResponse {
return new QueryUpgradedClientStateResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryUpgradedClientStateResponse {
return new QueryUpgradedClientStateResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryUpgradedClientStateResponse | PlainMessage<QueryUpgradedClientStateResponse> | undefined, b: QueryUpgradedClientStateResponse | PlainMessage<QueryUpgradedClientStateResponse> | undefined): boolean {
return proto3.util.equals(QueryUpgradedClientStateResponse, a, b);
}
}
/**
* QueryUpgradedConsensusStateRequest is the request type for the
* Query/UpgradedConsensusState RPC method
*
* @generated from message ibc.core.client.v1.QueryUpgradedConsensusStateRequest
*/
export class QueryUpgradedConsensusStateRequest extends Message<QueryUpgradedConsensusStateRequest> {
constructor(data?: PartialMessage<QueryUpgradedConsensusStateRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.QueryUpgradedConsensusStateRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryUpgradedConsensusStateRequest {
return new QueryUpgradedConsensusStateRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryUpgradedConsensusStateRequest {
return new QueryUpgradedConsensusStateRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryUpgradedConsensusStateRequest {
return new QueryUpgradedConsensusStateRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryUpgradedConsensusStateRequest | PlainMessage<QueryUpgradedConsensusStateRequest> | undefined, b: QueryUpgradedConsensusStateRequest | PlainMessage<QueryUpgradedConsensusStateRequest> | undefined): boolean {
return proto3.util.equals(QueryUpgradedConsensusStateRequest, a, b);
}
}
/**
* QueryUpgradedConsensusStateResponse is the response type for the
* Query/UpgradedConsensusState RPC method.
*
* @generated from message ibc.core.client.v1.QueryUpgradedConsensusStateResponse
*/
export class QueryUpgradedConsensusStateResponse extends Message<QueryUpgradedConsensusStateResponse> {
/**
* Consensus state associated with the request identifier
*
* @generated from field: google.protobuf.Any upgraded_consensus_state = 1;
*/
upgradedConsensusState?: Any;
constructor(data?: PartialMessage<QueryUpgradedConsensusStateResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.QueryUpgradedConsensusStateResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "upgraded_consensus_state", kind: "message", T: Any },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryUpgradedConsensusStateResponse {
return new QueryUpgradedConsensusStateResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryUpgradedConsensusStateResponse {
return new QueryUpgradedConsensusStateResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryUpgradedConsensusStateResponse {
return new QueryUpgradedConsensusStateResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryUpgradedConsensusStateResponse | PlainMessage<QueryUpgradedConsensusStateResponse> | undefined, b: QueryUpgradedConsensusStateResponse | PlainMessage<QueryUpgradedConsensusStateResponse> | undefined): boolean {
return proto3.util.equals(QueryUpgradedConsensusStateResponse, a, b);
}
}
/**
* QueryVerifyMembershipRequest is the request type for the Query/VerifyMembership RPC method
*
* @generated from message ibc.core.client.v1.QueryVerifyMembershipRequest
*/
export class QueryVerifyMembershipRequest extends Message<QueryVerifyMembershipRequest> {
/**
* client unique identifier.
*
* @generated from field: string client_id = 1;
*/
clientId = "";
/**
* the proof to be verified by the client.
*
* @generated from field: bytes proof = 2;
*/
proof = new Uint8Array(0);
/**
* the height of the commitment root at which the proof is verified.
*
* @generated from field: ibc.core.client.v1.Height proof_height = 3;
*/
proofHeight?: Height;
/**
* the value which is proven.
*
* @generated from field: bytes value = 5;
*/
value = new Uint8Array(0);
/**
* optional time delay
*
* @generated from field: uint64 time_delay = 6;
*/
timeDelay = protoInt64.zero;
/**
* optional block delay
*
* @generated from field: uint64 block_delay = 7;
*/
blockDelay = protoInt64.zero;
/**
* the commitment key path.
*
* @generated from field: ibc.core.commitment.v2.MerklePath merkle_path = 8;
*/
merklePath?: MerklePath;
constructor(data?: PartialMessage<QueryVerifyMembershipRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.QueryVerifyMembershipRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "proof", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 3, name: "proof_height", kind: "message", T: Height },
{ no: 5, name: "value", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 6, name: "time_delay", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 7, name: "block_delay", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 8, name: "merkle_path", kind: "message", T: MerklePath },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryVerifyMembershipRequest {
return new QueryVerifyMembershipRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryVerifyMembershipRequest {
return new QueryVerifyMembershipRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryVerifyMembershipRequest {
return new QueryVerifyMembershipRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryVerifyMembershipRequest | PlainMessage<QueryVerifyMembershipRequest> | undefined, b: QueryVerifyMembershipRequest | PlainMessage<QueryVerifyMembershipRequest> | undefined): boolean {
return proto3.util.equals(QueryVerifyMembershipRequest, a, b);
}
}
/**
* QueryVerifyMembershipResponse is the response type for the Query/VerifyMembership RPC method
*
* @generated from message ibc.core.client.v1.QueryVerifyMembershipResponse
*/
export class QueryVerifyMembershipResponse extends Message<QueryVerifyMembershipResponse> {
/**
* boolean indicating success or failure of proof verification.
*
* @generated from field: bool success = 1;
*/
success = false;
constructor(data?: PartialMessage<QueryVerifyMembershipResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.QueryVerifyMembershipResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "success", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryVerifyMembershipResponse {
return new QueryVerifyMembershipResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryVerifyMembershipResponse {
return new QueryVerifyMembershipResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryVerifyMembershipResponse {
return new QueryVerifyMembershipResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryVerifyMembershipResponse | PlainMessage<QueryVerifyMembershipResponse> | undefined, b: QueryVerifyMembershipResponse | PlainMessage<QueryVerifyMembershipResponse> | undefined): boolean {
return proto3.util.equals(QueryVerifyMembershipResponse, a, b);
}
}

93
libs/es-client/src/protobufs/ibc/core/client/v1/tx_cosmes.ts Normal file
View File

@ -0,0 +1,93 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file ibc/core/client/v1/tx.proto (package ibc.core.client.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { MsgCreateClient, MsgCreateClientResponse, MsgIBCSoftwareUpgrade, MsgIBCSoftwareUpgradeResponse, MsgRecoverClient, MsgRecoverClientResponse, MsgSubmitMisbehaviour, MsgSubmitMisbehaviourResponse, MsgUpdateClient, MsgUpdateClientResponse, MsgUpdateParams, MsgUpdateParamsResponse, MsgUpgradeClient, MsgUpgradeClientResponse } from "./tx_pb.js";
const TYPE_NAME = "ibc.core.client.v1.Msg";
/**
* CreateClient defines a rpc handler method for MsgCreateClient.
*
* @generated from rpc ibc.core.client.v1.Msg.CreateClient
*/
export const MsgCreateClientService = {
typeName: TYPE_NAME,
method: "CreateClient",
Request: MsgCreateClient,
Response: MsgCreateClientResponse,
} as const;
/**
* UpdateClient defines a rpc handler method for MsgUpdateClient.
*
* @generated from rpc ibc.core.client.v1.Msg.UpdateClient
*/
export const MsgUpdateClientService = {
typeName: TYPE_NAME,
method: "UpdateClient",
Request: MsgUpdateClient,
Response: MsgUpdateClientResponse,
} as const;
/**
* UpgradeClient defines a rpc handler method for MsgUpgradeClient.
*
* @generated from rpc ibc.core.client.v1.Msg.UpgradeClient
*/
export const MsgUpgradeClientService = {
typeName: TYPE_NAME,
method: "UpgradeClient",
Request: MsgUpgradeClient,
Response: MsgUpgradeClientResponse,
} as const;
/**
* SubmitMisbehaviour defines a rpc handler method for MsgSubmitMisbehaviour.
*
* @generated from rpc ibc.core.client.v1.Msg.SubmitMisbehaviour
*/
export const MsgSubmitMisbehaviourService = {
typeName: TYPE_NAME,
method: "SubmitMisbehaviour",
Request: MsgSubmitMisbehaviour,
Response: MsgSubmitMisbehaviourResponse,
} as const;
/**
* RecoverClient defines a rpc handler method for MsgRecoverClient.
*
* @generated from rpc ibc.core.client.v1.Msg.RecoverClient
*/
export const MsgRecoverClientService = {
typeName: TYPE_NAME,
method: "RecoverClient",
Request: MsgRecoverClient,
Response: MsgRecoverClientResponse,
} as const;
/**
* IBCSoftwareUpgrade defines a rpc handler method for MsgIBCSoftwareUpgrade.
*
* @generated from rpc ibc.core.client.v1.Msg.IBCSoftwareUpgrade
*/
export const MsgIBCSoftwareUpgradeService = {
typeName: TYPE_NAME,
method: "IBCSoftwareUpgrade",
Request: MsgIBCSoftwareUpgrade,
Response: MsgIBCSoftwareUpgradeResponse,
} as const;
/**
* UpdateClientParams defines a rpc handler method for MsgUpdateParams.
*
* @generated from rpc ibc.core.client.v1.Msg.UpdateClientParams
*/
export const MsgUpdateClientParamsService = {
typeName: TYPE_NAME,
method: "UpdateClientParams",
Request: MsgUpdateParams,
Response: MsgUpdateParamsResponse,
} as const;

678
libs/es-client/src/protobufs/ibc/core/client/v1/tx_pb.ts Normal file
View File

@ -0,0 +1,678 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/core/client/v1/tx.proto (package ibc.core.client.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Any, Message, proto3 } from "@bufbuild/protobuf";
import { Plan } from "../../../../cosmos/upgrade/v1beta1/upgrade_pb.js";
import { Params } from "./client_pb.js";
/**
* MsgCreateClient defines a message to create an IBC client
*
* @generated from message ibc.core.client.v1.MsgCreateClient
*/
export class MsgCreateClient extends Message<MsgCreateClient> {
/**
* light client state
*
* @generated from field: google.protobuf.Any client_state = 1;
*/
clientState?: Any;
/**
* consensus state associated with the client that corresponds to a given
* height.
*
* @generated from field: google.protobuf.Any consensus_state = 2;
*/
consensusState?: Any;
/**
* signer address
*
* @generated from field: string signer = 3;
*/
signer = "";
constructor(data?: PartialMessage<MsgCreateClient>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.MsgCreateClient";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_state", kind: "message", T: Any },
{ no: 2, name: "consensus_state", kind: "message", T: Any },
{ no: 3, name: "signer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgCreateClient {
return new MsgCreateClient().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgCreateClient {
return new MsgCreateClient().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgCreateClient {
return new MsgCreateClient().fromJsonString(jsonString, options);
}
static equals(a: MsgCreateClient | PlainMessage<MsgCreateClient> | undefined, b: MsgCreateClient | PlainMessage<MsgCreateClient> | undefined): boolean {
return proto3.util.equals(MsgCreateClient, a, b);
}
}
/**
* MsgCreateClientResponse defines the Msg/CreateClient response type.
*
* @generated from message ibc.core.client.v1.MsgCreateClientResponse
*/
export class MsgCreateClientResponse extends Message<MsgCreateClientResponse> {
/**
* @generated from field: string client_id = 1;
*/
clientId = "";
constructor(data?: PartialMessage<MsgCreateClientResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.MsgCreateClientResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgCreateClientResponse {
return new MsgCreateClientResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgCreateClientResponse {
return new MsgCreateClientResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgCreateClientResponse {
return new MsgCreateClientResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgCreateClientResponse | PlainMessage<MsgCreateClientResponse> | undefined, b: MsgCreateClientResponse | PlainMessage<MsgCreateClientResponse> | undefined): boolean {
return proto3.util.equals(MsgCreateClientResponse, a, b);
}
}
/**
* MsgUpdateClient defines an sdk.Msg to update a IBC client state using
* the given client message.
*
* @generated from message ibc.core.client.v1.MsgUpdateClient
*/
export class MsgUpdateClient extends Message<MsgUpdateClient> {
/**
* client unique identifier
*
* @generated from field: string client_id = 1;
*/
clientId = "";
/**
* client message to update the light client
*
* @generated from field: google.protobuf.Any client_message = 2;
*/
clientMessage?: Any;
/**
* signer address
*
* @generated from field: string signer = 3;
*/
signer = "";
constructor(data?: PartialMessage<MsgUpdateClient>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.MsgUpdateClient";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "client_message", kind: "message", T: Any },
{ no: 3, name: "signer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgUpdateClient {
return new MsgUpdateClient().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgUpdateClient {
return new MsgUpdateClient().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgUpdateClient {
return new MsgUpdateClient().fromJsonString(jsonString, options);
}
static equals(a: MsgUpdateClient | PlainMessage<MsgUpdateClient> | undefined, b: MsgUpdateClient | PlainMessage<MsgUpdateClient> | undefined): boolean {
return proto3.util.equals(MsgUpdateClient, a, b);
}
}
/**
* MsgUpdateClientResponse defines the Msg/UpdateClient response type.
*
* @generated from message ibc.core.client.v1.MsgUpdateClientResponse
*/
export class MsgUpdateClientResponse extends Message<MsgUpdateClientResponse> {
constructor(data?: PartialMessage<MsgUpdateClientResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.MsgUpdateClientResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgUpdateClientResponse {
return new MsgUpdateClientResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgUpdateClientResponse {
return new MsgUpdateClientResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgUpdateClientResponse {
return new MsgUpdateClientResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgUpdateClientResponse | PlainMessage<MsgUpdateClientResponse> | undefined, b: MsgUpdateClientResponse | PlainMessage<MsgUpdateClientResponse> | undefined): boolean {
return proto3.util.equals(MsgUpdateClientResponse, a, b);
}
}
/**
* MsgUpgradeClient defines an sdk.Msg to upgrade an IBC client to a new client
* state
*
* @generated from message ibc.core.client.v1.MsgUpgradeClient
*/
export class MsgUpgradeClient extends Message<MsgUpgradeClient> {
/**
* client unique identifier
*
* @generated from field: string client_id = 1;
*/
clientId = "";
/**
* upgraded client state
*
* @generated from field: google.protobuf.Any client_state = 2;
*/
clientState?: Any;
/**
* upgraded consensus state, only contains enough information to serve as a
* basis of trust in update logic
*
* @generated from field: google.protobuf.Any consensus_state = 3;
*/
consensusState?: Any;
/**
* proof that old chain committed to new client
*
* @generated from field: bytes proof_upgrade_client = 4;
*/
proofUpgradeClient = new Uint8Array(0);
/**
* proof that old chain committed to new consensus state
*
* @generated from field: bytes proof_upgrade_consensus_state = 5;
*/
proofUpgradeConsensusState = new Uint8Array(0);
/**
* signer address
*
* @generated from field: string signer = 6;
*/
signer = "";
constructor(data?: PartialMessage<MsgUpgradeClient>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.MsgUpgradeClient";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "client_state", kind: "message", T: Any },
{ no: 3, name: "consensus_state", kind: "message", T: Any },
{ no: 4, name: "proof_upgrade_client", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 5, name: "proof_upgrade_consensus_state", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 6, name: "signer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgUpgradeClient {
return new MsgUpgradeClient().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgUpgradeClient {
return new MsgUpgradeClient().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgUpgradeClient {
return new MsgUpgradeClient().fromJsonString(jsonString, options);
}
static equals(a: MsgUpgradeClient | PlainMessage<MsgUpgradeClient> | undefined, b: MsgUpgradeClient | PlainMessage<MsgUpgradeClient> | undefined): boolean {
return proto3.util.equals(MsgUpgradeClient, a, b);
}
}
/**
* MsgUpgradeClientResponse defines the Msg/UpgradeClient response type.
*
* @generated from message ibc.core.client.v1.MsgUpgradeClientResponse
*/
export class MsgUpgradeClientResponse extends Message<MsgUpgradeClientResponse> {
constructor(data?: PartialMessage<MsgUpgradeClientResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.MsgUpgradeClientResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgUpgradeClientResponse {
return new MsgUpgradeClientResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgUpgradeClientResponse {
return new MsgUpgradeClientResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgUpgradeClientResponse {
return new MsgUpgradeClientResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgUpgradeClientResponse | PlainMessage<MsgUpgradeClientResponse> | undefined, b: MsgUpgradeClientResponse | PlainMessage<MsgUpgradeClientResponse> | undefined): boolean {
return proto3.util.equals(MsgUpgradeClientResponse, a, b);
}
}
/**
* MsgSubmitMisbehaviour defines an sdk.Msg type that submits Evidence for
* light client misbehaviour.
* This message has been deprecated. Use MsgUpdateClient instead.
*
* @generated from message ibc.core.client.v1.MsgSubmitMisbehaviour
* @deprecated
*/
export class MsgSubmitMisbehaviour extends Message<MsgSubmitMisbehaviour> {
/**
* client unique identifier
*
* @generated from field: string client_id = 1;
*/
clientId = "";
/**
* misbehaviour used for freezing the light client
*
* @generated from field: google.protobuf.Any misbehaviour = 2;
*/
misbehaviour?: Any;
/**
* signer address
*
* @generated from field: string signer = 3;
*/
signer = "";
constructor(data?: PartialMessage<MsgSubmitMisbehaviour>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.MsgSubmitMisbehaviour";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "misbehaviour", kind: "message", T: Any },
{ no: 3, name: "signer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgSubmitMisbehaviour {
return new MsgSubmitMisbehaviour().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgSubmitMisbehaviour {
return new MsgSubmitMisbehaviour().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgSubmitMisbehaviour {
return new MsgSubmitMisbehaviour().fromJsonString(jsonString, options);
}
static equals(a: MsgSubmitMisbehaviour | PlainMessage<MsgSubmitMisbehaviour> | undefined, b: MsgSubmitMisbehaviour | PlainMessage<MsgSubmitMisbehaviour> | undefined): boolean {
return proto3.util.equals(MsgSubmitMisbehaviour, a, b);
}
}
/**
* MsgSubmitMisbehaviourResponse defines the Msg/SubmitMisbehaviour response
* type.
*
* @generated from message ibc.core.client.v1.MsgSubmitMisbehaviourResponse
*/
export class MsgSubmitMisbehaviourResponse extends Message<MsgSubmitMisbehaviourResponse> {
constructor(data?: PartialMessage<MsgSubmitMisbehaviourResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.MsgSubmitMisbehaviourResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgSubmitMisbehaviourResponse {
return new MsgSubmitMisbehaviourResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgSubmitMisbehaviourResponse {
return new MsgSubmitMisbehaviourResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgSubmitMisbehaviourResponse {
return new MsgSubmitMisbehaviourResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgSubmitMisbehaviourResponse | PlainMessage<MsgSubmitMisbehaviourResponse> | undefined, b: MsgSubmitMisbehaviourResponse | PlainMessage<MsgSubmitMisbehaviourResponse> | undefined): boolean {
return proto3.util.equals(MsgSubmitMisbehaviourResponse, a, b);
}
}
/**
* MsgRecoverClient defines the message used to recover a frozen or expired client.
*
* @generated from message ibc.core.client.v1.MsgRecoverClient
*/
export class MsgRecoverClient extends Message<MsgRecoverClient> {
/**
* the client identifier for the client to be updated if the proposal passes
*
* @generated from field: string subject_client_id = 1;
*/
subjectClientId = "";
/**
* the substitute client identifier for the client which will replace the subject
* client
*
* @generated from field: string substitute_client_id = 2;
*/
substituteClientId = "";
/**
* signer address
*
* @generated from field: string signer = 3;
*/
signer = "";
constructor(data?: PartialMessage<MsgRecoverClient>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.MsgRecoverClient";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "subject_client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "substitute_client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "signer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgRecoverClient {
return new MsgRecoverClient().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgRecoverClient {
return new MsgRecoverClient().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgRecoverClient {
return new MsgRecoverClient().fromJsonString(jsonString, options);
}
static equals(a: MsgRecoverClient | PlainMessage<MsgRecoverClient> | undefined, b: MsgRecoverClient | PlainMessage<MsgRecoverClient> | undefined): boolean {
return proto3.util.equals(MsgRecoverClient, a, b);
}
}
/**
* MsgRecoverClientResponse defines the Msg/RecoverClient response type.
*
* @generated from message ibc.core.client.v1.MsgRecoverClientResponse
*/
export class MsgRecoverClientResponse extends Message<MsgRecoverClientResponse> {
constructor(data?: PartialMessage<MsgRecoverClientResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.MsgRecoverClientResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgRecoverClientResponse {
return new MsgRecoverClientResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgRecoverClientResponse {
return new MsgRecoverClientResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgRecoverClientResponse {
return new MsgRecoverClientResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgRecoverClientResponse | PlainMessage<MsgRecoverClientResponse> | undefined, b: MsgRecoverClientResponse | PlainMessage<MsgRecoverClientResponse> | undefined): boolean {
return proto3.util.equals(MsgRecoverClientResponse, a, b);
}
}
/**
* MsgIBCSoftwareUpgrade defines the message used to schedule an upgrade of an IBC client using a v1 governance proposal
*
* @generated from message ibc.core.client.v1.MsgIBCSoftwareUpgrade
*/
export class MsgIBCSoftwareUpgrade extends Message<MsgIBCSoftwareUpgrade> {
/**
* @generated from field: cosmos.upgrade.v1beta1.Plan plan = 1;
*/
plan?: Plan;
/**
* An UpgradedClientState must be provided to perform an IBC breaking upgrade.
* This will make the chain commit to the correct upgraded (self) client state
* before the upgrade occurs, so that connecting chains can verify that the
* new upgraded client is valid by verifying a proof on the previous version
* of the chain. This will allow IBC connections to persist smoothly across
* planned chain upgrades. Correspondingly, the UpgradedClientState field has been
* deprecated in the Cosmos SDK to allow for this logic to exist solely in
* the 02-client module.
*
* @generated from field: google.protobuf.Any upgraded_client_state = 2;
*/
upgradedClientState?: Any;
/**
* signer address
*
* @generated from field: string signer = 3;
*/
signer = "";
constructor(data?: PartialMessage<MsgIBCSoftwareUpgrade>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.MsgIBCSoftwareUpgrade";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "plan", kind: "message", T: Plan },
{ no: 2, name: "upgraded_client_state", kind: "message", T: Any },
{ no: 3, name: "signer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgIBCSoftwareUpgrade {
return new MsgIBCSoftwareUpgrade().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgIBCSoftwareUpgrade {
return new MsgIBCSoftwareUpgrade().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgIBCSoftwareUpgrade {
return new MsgIBCSoftwareUpgrade().fromJsonString(jsonString, options);
}
static equals(a: MsgIBCSoftwareUpgrade | PlainMessage<MsgIBCSoftwareUpgrade> | undefined, b: MsgIBCSoftwareUpgrade | PlainMessage<MsgIBCSoftwareUpgrade> | undefined): boolean {
return proto3.util.equals(MsgIBCSoftwareUpgrade, a, b);
}
}
/**
* MsgIBCSoftwareUpgradeResponse defines the Msg/IBCSoftwareUpgrade response type.
*
* @generated from message ibc.core.client.v1.MsgIBCSoftwareUpgradeResponse
*/
export class MsgIBCSoftwareUpgradeResponse extends Message<MsgIBCSoftwareUpgradeResponse> {
constructor(data?: PartialMessage<MsgIBCSoftwareUpgradeResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.MsgIBCSoftwareUpgradeResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgIBCSoftwareUpgradeResponse {
return new MsgIBCSoftwareUpgradeResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgIBCSoftwareUpgradeResponse {
return new MsgIBCSoftwareUpgradeResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgIBCSoftwareUpgradeResponse {
return new MsgIBCSoftwareUpgradeResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgIBCSoftwareUpgradeResponse | PlainMessage<MsgIBCSoftwareUpgradeResponse> | undefined, b: MsgIBCSoftwareUpgradeResponse | PlainMessage<MsgIBCSoftwareUpgradeResponse> | undefined): boolean {
return proto3.util.equals(MsgIBCSoftwareUpgradeResponse, a, b);
}
}
/**
* MsgUpdateParams defines the sdk.Msg type to update the client parameters.
*
* @generated from message ibc.core.client.v1.MsgUpdateParams
*/
export class MsgUpdateParams extends Message<MsgUpdateParams> {
/**
* signer address
*
* @generated from field: string signer = 1;
*/
signer = "";
/**
* params defines the client parameters to update.
*
* NOTE: All parameters must be supplied.
*
* @generated from field: ibc.core.client.v1.Params params = 2;
*/
params?: Params;
constructor(data?: PartialMessage<MsgUpdateParams>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.MsgUpdateParams";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "signer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "params", kind: "message", T: Params },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgUpdateParams {
return new MsgUpdateParams().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgUpdateParams {
return new MsgUpdateParams().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgUpdateParams {
return new MsgUpdateParams().fromJsonString(jsonString, options);
}
static equals(a: MsgUpdateParams | PlainMessage<MsgUpdateParams> | undefined, b: MsgUpdateParams | PlainMessage<MsgUpdateParams> | undefined): boolean {
return proto3.util.equals(MsgUpdateParams, a, b);
}
}
/**
* MsgUpdateParamsResponse defines the MsgUpdateParams response type.
*
* @generated from message ibc.core.client.v1.MsgUpdateParamsResponse
*/
export class MsgUpdateParamsResponse extends Message<MsgUpdateParamsResponse> {
constructor(data?: PartialMessage<MsgUpdateParamsResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.client.v1.MsgUpdateParamsResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgUpdateParamsResponse {
return new MsgUpdateParamsResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgUpdateParamsResponse {
return new MsgUpdateParamsResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgUpdateParamsResponse {
return new MsgUpdateParamsResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgUpdateParamsResponse | PlainMessage<MsgUpdateParamsResponse> | undefined, b: MsgUpdateParamsResponse | PlainMessage<MsgUpdateParamsResponse> | undefined): boolean {
return proto3.util.equals(MsgUpdateParamsResponse, a, b);
}
}

133
libs/es-client/src/protobufs/ibc/core/commitment/v1/commitment_pb.ts Normal file
View File

@ -0,0 +1,133 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/core/commitment/v1/commitment.proto (package ibc.core.commitment.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { CommitmentProof } from "../../../../cosmos/ics23/v1/proofs_pb.js";
/**
* MerkleRoot defines a merkle root hash.
* In the Cosmos SDK, the AppHash of a block header becomes the root.
*
* @generated from message ibc.core.commitment.v1.MerkleRoot
*/
export class MerkleRoot extends Message<MerkleRoot> {
/**
* @generated from field: bytes hash = 1;
*/
hash = new Uint8Array(0);
constructor(data?: PartialMessage<MerkleRoot>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.commitment.v1.MerkleRoot";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "hash", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MerkleRoot {
return new MerkleRoot().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MerkleRoot {
return new MerkleRoot().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MerkleRoot {
return new MerkleRoot().fromJsonString(jsonString, options);
}
static equals(a: MerkleRoot | PlainMessage<MerkleRoot> | undefined, b: MerkleRoot | PlainMessage<MerkleRoot> | undefined): boolean {
return proto3.util.equals(MerkleRoot, a, b);
}
}
/**
* MerklePrefix is merkle path prefixed to the key.
* The constructed key from the Path and the key will be append(Path.KeyPath,
* append(Path.KeyPrefix, key...))
*
* @generated from message ibc.core.commitment.v1.MerklePrefix
*/
export class MerklePrefix extends Message<MerklePrefix> {
/**
* @generated from field: bytes key_prefix = 1;
*/
keyPrefix = new Uint8Array(0);
constructor(data?: PartialMessage<MerklePrefix>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.commitment.v1.MerklePrefix";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "key_prefix", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MerklePrefix {
return new MerklePrefix().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MerklePrefix {
return new MerklePrefix().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MerklePrefix {
return new MerklePrefix().fromJsonString(jsonString, options);
}
static equals(a: MerklePrefix | PlainMessage<MerklePrefix> | undefined, b: MerklePrefix | PlainMessage<MerklePrefix> | undefined): boolean {
return proto3.util.equals(MerklePrefix, a, b);
}
}
/**
* MerkleProof is a wrapper type over a chain of CommitmentProofs.
* It demonstrates membership or non-membership for an element or set of
* elements, verifiable in conjunction with a known commitment root. Proofs
* should be succinct.
* MerkleProofs are ordered from leaf-to-root
*
* @generated from message ibc.core.commitment.v1.MerkleProof
*/
export class MerkleProof extends Message<MerkleProof> {
/**
* @generated from field: repeated cosmos.ics23.v1.CommitmentProof proofs = 1;
*/
proofs: CommitmentProof[] = [];
constructor(data?: PartialMessage<MerkleProof>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.commitment.v1.MerkleProof";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "proofs", kind: "message", T: CommitmentProof, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MerkleProof {
return new MerkleProof().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MerkleProof {
return new MerkleProof().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MerkleProof {
return new MerkleProof().fromJsonString(jsonString, options);
}
static equals(a: MerkleProof | PlainMessage<MerkleProof> | undefined, b: MerkleProof | PlainMessage<MerkleProof> | undefined): boolean {
return proto3.util.equals(MerkleProof, a, b);
}
}

49
libs/es-client/src/protobufs/ibc/core/commitment/v2/commitment_pb.ts Normal file
View File

@ -0,0 +1,49 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/core/commitment/v2/commitment.proto (package ibc.core.commitment.v2, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
/**
* MerklePath is the path used to verify commitment proofs, which can be an
* arbitrary structured object (defined by a commitment type).
* MerklePath is represented from root-to-leaf
*
* @generated from message ibc.core.commitment.v2.MerklePath
*/
export class MerklePath extends Message<MerklePath> {
/**
* @generated from field: repeated bytes key_path = 1;
*/
keyPath: Uint8Array[] = [];
constructor(data?: PartialMessage<MerklePath>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.commitment.v2.MerklePath";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "key_path", kind: "scalar", T: 12 /* ScalarType.BYTES */, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MerklePath {
return new MerklePath().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MerklePath {
return new MerklePath().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MerklePath {
return new MerklePath().fromJsonString(jsonString, options);
}
static equals(a: MerklePath | PlainMessage<MerklePath> | undefined, b: MerklePath | PlainMessage<MerklePath> | undefined): boolean {
return proto3.util.equals(MerklePath, a, b);
}
}

457
libs/es-client/src/protobufs/ibc/core/connection/v1/connection_pb.ts Normal file
View File

@ -0,0 +1,457 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/core/connection/v1/connection.proto (package ibc.core.connection.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, protoInt64 } from "@bufbuild/protobuf";
import { MerklePrefix } from "../../commitment/v1/commitment_pb.js";
/**
* State defines if a connection is in one of the following states:
* INIT, TRYOPEN, OPEN or UNINITIALIZED.
*
* @generated from enum ibc.core.connection.v1.State
*/
export enum State {
/**
* Default State
*
* @generated from enum value: STATE_UNINITIALIZED_UNSPECIFIED = 0;
*/
UNINITIALIZED_UNSPECIFIED = 0,
/**
* A connection end has just started the opening handshake.
*
* @generated from enum value: STATE_INIT = 1;
*/
INIT = 1,
/**
* A connection end has acknowledged the handshake step on the counterparty
* chain.
*
* @generated from enum value: STATE_TRYOPEN = 2;
*/
TRYOPEN = 2,
/**
* A connection end has completed the handshake.
*
* @generated from enum value: STATE_OPEN = 3;
*/
OPEN = 3,
}
// Retrieve enum metadata with: proto3.getEnumType(State)
proto3.util.setEnumType(State, "ibc.core.connection.v1.State", [
{ no: 0, name: "STATE_UNINITIALIZED_UNSPECIFIED" },
{ no: 1, name: "STATE_INIT" },
{ no: 2, name: "STATE_TRYOPEN" },
{ no: 3, name: "STATE_OPEN" },
]);
/**
* ConnectionEnd defines a stateful object on a chain connected to another
* separate one.
* NOTE: there must only be 2 defined ConnectionEnds to establish
* a connection between two chains.
*
* @generated from message ibc.core.connection.v1.ConnectionEnd
*/
export class ConnectionEnd extends Message<ConnectionEnd> {
/**
* client associated with this connection.
*
* @generated from field: string client_id = 1;
*/
clientId = "";
/**
* IBC version which can be utilised to determine encodings or protocols for
* channels or packets utilising this connection.
*
* @generated from field: repeated ibc.core.connection.v1.Version versions = 2;
*/
versions: Version[] = [];
/**
* current state of the connection end.
*
* @generated from field: ibc.core.connection.v1.State state = 3;
*/
state = State.UNINITIALIZED_UNSPECIFIED;
/**
* counterparty chain associated with this connection.
*
* @generated from field: ibc.core.connection.v1.Counterparty counterparty = 4;
*/
counterparty?: Counterparty;
/**
* delay period that must pass before a consensus state can be used for
* packet-verification NOTE: delay period logic is only implemented by some
* clients.
*
* @generated from field: uint64 delay_period = 5;
*/
delayPeriod = protoInt64.zero;
constructor(data?: PartialMessage<ConnectionEnd>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.ConnectionEnd";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "versions", kind: "message", T: Version, repeated: true },
{ no: 3, name: "state", kind: "enum", T: proto3.getEnumType(State) },
{ no: 4, name: "counterparty", kind: "message", T: Counterparty },
{ no: 5, name: "delay_period", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConnectionEnd {
return new ConnectionEnd().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConnectionEnd {
return new ConnectionEnd().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConnectionEnd {
return new ConnectionEnd().fromJsonString(jsonString, options);
}
static equals(a: ConnectionEnd | PlainMessage<ConnectionEnd> | undefined, b: ConnectionEnd | PlainMessage<ConnectionEnd> | undefined): boolean {
return proto3.util.equals(ConnectionEnd, a, b);
}
}
/**
* IdentifiedConnection defines a connection with additional connection
* identifier field.
*
* @generated from message ibc.core.connection.v1.IdentifiedConnection
*/
export class IdentifiedConnection extends Message<IdentifiedConnection> {
/**
* connection identifier.
*
* @generated from field: string id = 1;
*/
id = "";
/**
* client associated with this connection.
*
* @generated from field: string client_id = 2;
*/
clientId = "";
/**
* IBC version which can be utilised to determine encodings or protocols for
* channels or packets utilising this connection
*
* @generated from field: repeated ibc.core.connection.v1.Version versions = 3;
*/
versions: Version[] = [];
/**
* current state of the connection end.
*
* @generated from field: ibc.core.connection.v1.State state = 4;
*/
state = State.UNINITIALIZED_UNSPECIFIED;
/**
* counterparty chain associated with this connection.
*
* @generated from field: ibc.core.connection.v1.Counterparty counterparty = 5;
*/
counterparty?: Counterparty;
/**
* delay period associated with this connection.
*
* @generated from field: uint64 delay_period = 6;
*/
delayPeriod = protoInt64.zero;
constructor(data?: PartialMessage<IdentifiedConnection>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.IdentifiedConnection";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "versions", kind: "message", T: Version, repeated: true },
{ no: 4, name: "state", kind: "enum", T: proto3.getEnumType(State) },
{ no: 5, name: "counterparty", kind: "message", T: Counterparty },
{ no: 6, name: "delay_period", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): IdentifiedConnection {
return new IdentifiedConnection().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): IdentifiedConnection {
return new IdentifiedConnection().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): IdentifiedConnection {
return new IdentifiedConnection().fromJsonString(jsonString, options);
}
static equals(a: IdentifiedConnection | PlainMessage<IdentifiedConnection> | undefined, b: IdentifiedConnection | PlainMessage<IdentifiedConnection> | undefined): boolean {
return proto3.util.equals(IdentifiedConnection, a, b);
}
}
/**
* Counterparty defines the counterparty chain associated with a connection end.
*
* @generated from message ibc.core.connection.v1.Counterparty
*/
export class Counterparty extends Message<Counterparty> {
/**
* identifies the client on the counterparty chain associated with a given
* connection.
*
* @generated from field: string client_id = 1;
*/
clientId = "";
/**
* identifies the connection end on the counterparty chain associated with a
* given connection.
*
* @generated from field: string connection_id = 2;
*/
connectionId = "";
/**
* commitment merkle prefix of the counterparty chain.
*
* @generated from field: ibc.core.commitment.v1.MerklePrefix prefix = 3;
*/
prefix?: MerklePrefix;
constructor(data?: PartialMessage<Counterparty>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.Counterparty";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "connection_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "prefix", kind: "message", T: MerklePrefix },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Counterparty {
return new Counterparty().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Counterparty {
return new Counterparty().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Counterparty {
return new Counterparty().fromJsonString(jsonString, options);
}
static equals(a: Counterparty | PlainMessage<Counterparty> | undefined, b: Counterparty | PlainMessage<Counterparty> | undefined): boolean {
return proto3.util.equals(Counterparty, a, b);
}
}
/**
* ClientPaths define all the connection paths for a client state.
*
* @generated from message ibc.core.connection.v1.ClientPaths
*/
export class ClientPaths extends Message<ClientPaths> {
/**
* list of connection paths
*
* @generated from field: repeated string paths = 1;
*/
paths: string[] = [];
constructor(data?: PartialMessage<ClientPaths>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.ClientPaths";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "paths", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ClientPaths {
return new ClientPaths().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ClientPaths {
return new ClientPaths().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ClientPaths {
return new ClientPaths().fromJsonString(jsonString, options);
}
static equals(a: ClientPaths | PlainMessage<ClientPaths> | undefined, b: ClientPaths | PlainMessage<ClientPaths> | undefined): boolean {
return proto3.util.equals(ClientPaths, a, b);
}
}
/**
* ConnectionPaths define all the connection paths for a given client state.
*
* @generated from message ibc.core.connection.v1.ConnectionPaths
*/
export class ConnectionPaths extends Message<ConnectionPaths> {
/**
* client state unique identifier
*
* @generated from field: string client_id = 1;
*/
clientId = "";
/**
* list of connection paths
*
* @generated from field: repeated string paths = 2;
*/
paths: string[] = [];
constructor(data?: PartialMessage<ConnectionPaths>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.ConnectionPaths";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "paths", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConnectionPaths {
return new ConnectionPaths().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConnectionPaths {
return new ConnectionPaths().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConnectionPaths {
return new ConnectionPaths().fromJsonString(jsonString, options);
}
static equals(a: ConnectionPaths | PlainMessage<ConnectionPaths> | undefined, b: ConnectionPaths | PlainMessage<ConnectionPaths> | undefined): boolean {
return proto3.util.equals(ConnectionPaths, a, b);
}
}
/**
* Version defines the versioning scheme used to negotiate the IBC version in
* the connection handshake.
*
* @generated from message ibc.core.connection.v1.Version
*/
export class Version extends Message<Version> {
/**
* unique version identifier
*
* @generated from field: string identifier = 1;
*/
identifier = "";
/**
* list of features compatible with the specified identifier
*
* @generated from field: repeated string features = 2;
*/
features: string[] = [];
constructor(data?: PartialMessage<Version>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.Version";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "identifier", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "features", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Version {
return new Version().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Version {
return new Version().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Version {
return new Version().fromJsonString(jsonString, options);
}
static equals(a: Version | PlainMessage<Version> | undefined, b: Version | PlainMessage<Version> | undefined): boolean {
return proto3.util.equals(Version, a, b);
}
}
/**
* Params defines the set of Connection parameters.
*
* @generated from message ibc.core.connection.v1.Params
*/
export class Params extends Message<Params> {
/**
* maximum expected time per block (in nanoseconds), used to enforce block delay. This parameter should reflect the
* largest amount of time that the chain might reasonably take to produce the next block under normal operating
* conditions. A safe choice is 3-5x the expected time per block.
*
* @generated from field: uint64 max_expected_time_per_block = 1;
*/
maxExpectedTimePerBlock = protoInt64.zero;
constructor(data?: PartialMessage<Params>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.Params";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "max_expected_time_per_block", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Params {
return new Params().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Params {
return new Params().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Params {
return new Params().fromJsonString(jsonString, options);
}
static equals(a: Params | PlainMessage<Params> | undefined, b: Params | PlainMessage<Params> | undefined): boolean {
return proto3.util.equals(Params, a, b);
}
}

68
libs/es-client/src/protobufs/ibc/core/connection/v1/genesis_pb.ts Normal file
View File

@ -0,0 +1,68 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/core/connection/v1/genesis.proto (package ibc.core.connection.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, protoInt64 } from "@bufbuild/protobuf";
import { ConnectionPaths, IdentifiedConnection, Params } from "./connection_pb.js";
/**
* GenesisState defines the ibc connection submodule's genesis state.
*
* @generated from message ibc.core.connection.v1.GenesisState
*/
export class GenesisState extends Message<GenesisState> {
/**
* @generated from field: repeated ibc.core.connection.v1.IdentifiedConnection connections = 1;
*/
connections: IdentifiedConnection[] = [];
/**
* @generated from field: repeated ibc.core.connection.v1.ConnectionPaths client_connection_paths = 2;
*/
clientConnectionPaths: ConnectionPaths[] = [];
/**
* the sequence for the next generated connection identifier
*
* @generated from field: uint64 next_connection_sequence = 3;
*/
nextConnectionSequence = protoInt64.zero;
/**
* @generated from field: ibc.core.connection.v1.Params params = 4;
*/
params?: Params;
constructor(data?: PartialMessage<GenesisState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.GenesisState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "connections", kind: "message", T: IdentifiedConnection, repeated: true },
{ no: 2, name: "client_connection_paths", kind: "message", T: ConnectionPaths, repeated: true },
{ no: 3, name: "next_connection_sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 4, name: "params", kind: "message", T: Params },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GenesisState {
return new GenesisState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJsonString(jsonString, options);
}
static equals(a: GenesisState | PlainMessage<GenesisState> | undefined, b: GenesisState | PlainMessage<GenesisState> | undefined): boolean {
return proto3.util.equals(GenesisState, a, b);
}
}

84
libs/es-client/src/protobufs/ibc/core/connection/v1/query_cosmes.ts Normal file
View File

@ -0,0 +1,84 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file ibc/core/connection/v1/query.proto (package ibc.core.connection.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { QueryClientConnectionsRequest, QueryClientConnectionsResponse, QueryConnectionClientStateRequest, QueryConnectionClientStateResponse, QueryConnectionConsensusStateRequest, QueryConnectionConsensusStateResponse, QueryConnectionParamsRequest, QueryConnectionParamsResponse, QueryConnectionRequest, QueryConnectionResponse, QueryConnectionsRequest, QueryConnectionsResponse } from "./query_pb.js";
const TYPE_NAME = "ibc.core.connection.v1.Query";
/**
* Connection queries an IBC connection end.
*
* @generated from rpc ibc.core.connection.v1.Query.Connection
*/
export const QueryConnectionService = {
typeName: TYPE_NAME,
method: "Connection",
Request: QueryConnectionRequest,
Response: QueryConnectionResponse,
} as const;
/**
* Connections queries all the IBC connections of a chain.
*
* @generated from rpc ibc.core.connection.v1.Query.Connections
*/
export const QueryConnectionsService = {
typeName: TYPE_NAME,
method: "Connections",
Request: QueryConnectionsRequest,
Response: QueryConnectionsResponse,
} as const;
/**
* ClientConnections queries the connection paths associated with a client
* state.
*
* @generated from rpc ibc.core.connection.v1.Query.ClientConnections
*/
export const QueryClientConnectionsService = {
typeName: TYPE_NAME,
method: "ClientConnections",
Request: QueryClientConnectionsRequest,
Response: QueryClientConnectionsResponse,
} as const;
/**
* ConnectionClientState queries the client state associated with the
* connection.
*
* @generated from rpc ibc.core.connection.v1.Query.ConnectionClientState
*/
export const QueryConnectionClientStateService = {
typeName: TYPE_NAME,
method: "ConnectionClientState",
Request: QueryConnectionClientStateRequest,
Response: QueryConnectionClientStateResponse,
} as const;
/**
* ConnectionConsensusState queries the consensus state associated with the
* connection.
*
* @generated from rpc ibc.core.connection.v1.Query.ConnectionConsensusState
*/
export const QueryConnectionConsensusStateService = {
typeName: TYPE_NAME,
method: "ConnectionConsensusState",
Request: QueryConnectionConsensusStateRequest,
Response: QueryConnectionConsensusStateResponse,
} as const;
/**
* ConnectionParams queries all parameters of the ibc connection submodule.
*
* @generated from rpc ibc.core.connection.v1.Query.ConnectionParams
*/
export const QueryConnectionParamsService = {
typeName: TYPE_NAME,
method: "ConnectionParams",
Request: QueryConnectionParamsRequest,
Response: QueryConnectionParamsResponse,
} as const;

604
libs/es-client/src/protobufs/ibc/core/connection/v1/query_pb.ts Normal file
View File

@ -0,0 +1,604 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/core/connection/v1/query.proto (package ibc.core.connection.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Any, Message, proto3, protoInt64 } from "@bufbuild/protobuf";
import { ConnectionEnd, IdentifiedConnection, Params } from "./connection_pb.js";
import { Height, IdentifiedClientState } from "../../client/v1/client_pb.js";
import { PageRequest, PageResponse } from "../../../../cosmos/base/query/v1beta1/pagination_pb.js";
/**
* QueryConnectionRequest is the request type for the Query/Connection RPC
* method
*
* @generated from message ibc.core.connection.v1.QueryConnectionRequest
*/
export class QueryConnectionRequest extends Message<QueryConnectionRequest> {
/**
* connection unique identifier
*
* @generated from field: string connection_id = 1;
*/
connectionId = "";
constructor(data?: PartialMessage<QueryConnectionRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.QueryConnectionRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "connection_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryConnectionRequest {
return new QueryConnectionRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryConnectionRequest {
return new QueryConnectionRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryConnectionRequest {
return new QueryConnectionRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryConnectionRequest | PlainMessage<QueryConnectionRequest> | undefined, b: QueryConnectionRequest | PlainMessage<QueryConnectionRequest> | undefined): boolean {
return proto3.util.equals(QueryConnectionRequest, a, b);
}
}
/**
* QueryConnectionResponse is the response type for the Query/Connection RPC
* method. Besides the connection end, it includes a proof and the height from
* which the proof was retrieved.
*
* @generated from message ibc.core.connection.v1.QueryConnectionResponse
*/
export class QueryConnectionResponse extends Message<QueryConnectionResponse> {
/**
* connection associated with the request identifier
*
* @generated from field: ibc.core.connection.v1.ConnectionEnd connection = 1;
*/
connection?: ConnectionEnd;
/**
* merkle proof of existence
*
* @generated from field: bytes proof = 2;
*/
proof = new Uint8Array(0);
/**
* height at which the proof was retrieved
*
* @generated from field: ibc.core.client.v1.Height proof_height = 3;
*/
proofHeight?: Height;
constructor(data?: PartialMessage<QueryConnectionResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.QueryConnectionResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "connection", kind: "message", T: ConnectionEnd },
{ no: 2, name: "proof", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 3, name: "proof_height", kind: "message", T: Height },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryConnectionResponse {
return new QueryConnectionResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryConnectionResponse {
return new QueryConnectionResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryConnectionResponse {
return new QueryConnectionResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryConnectionResponse | PlainMessage<QueryConnectionResponse> | undefined, b: QueryConnectionResponse | PlainMessage<QueryConnectionResponse> | undefined): boolean {
return proto3.util.equals(QueryConnectionResponse, a, b);
}
}
/**
* QueryConnectionsRequest is the request type for the Query/Connections RPC
* method
*
* @generated from message ibc.core.connection.v1.QueryConnectionsRequest
*/
export class QueryConnectionsRequest extends Message<QueryConnectionsRequest> {
/**
* @generated from field: cosmos.base.query.v1beta1.PageRequest pagination = 1;
*/
pagination?: PageRequest;
constructor(data?: PartialMessage<QueryConnectionsRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.QueryConnectionsRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "pagination", kind: "message", T: PageRequest },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryConnectionsRequest {
return new QueryConnectionsRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryConnectionsRequest {
return new QueryConnectionsRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryConnectionsRequest {
return new QueryConnectionsRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryConnectionsRequest | PlainMessage<QueryConnectionsRequest> | undefined, b: QueryConnectionsRequest | PlainMessage<QueryConnectionsRequest> | undefined): boolean {
return proto3.util.equals(QueryConnectionsRequest, a, b);
}
}
/**
* QueryConnectionsResponse is the response type for the Query/Connections RPC
* method.
*
* @generated from message ibc.core.connection.v1.QueryConnectionsResponse
*/
export class QueryConnectionsResponse extends Message<QueryConnectionsResponse> {
/**
* list of stored connections of the chain.
*
* @generated from field: repeated ibc.core.connection.v1.IdentifiedConnection connections = 1;
*/
connections: IdentifiedConnection[] = [];
/**
* pagination response
*
* @generated from field: cosmos.base.query.v1beta1.PageResponse pagination = 2;
*/
pagination?: PageResponse;
/**
* query block height
*
* @generated from field: ibc.core.client.v1.Height height = 3;
*/
height?: Height;
constructor(data?: PartialMessage<QueryConnectionsResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.QueryConnectionsResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "connections", kind: "message", T: IdentifiedConnection, repeated: true },
{ no: 2, name: "pagination", kind: "message", T: PageResponse },
{ no: 3, name: "height", kind: "message", T: Height },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryConnectionsResponse {
return new QueryConnectionsResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryConnectionsResponse {
return new QueryConnectionsResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryConnectionsResponse {
return new QueryConnectionsResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryConnectionsResponse | PlainMessage<QueryConnectionsResponse> | undefined, b: QueryConnectionsResponse | PlainMessage<QueryConnectionsResponse> | undefined): boolean {
return proto3.util.equals(QueryConnectionsResponse, a, b);
}
}
/**
* QueryClientConnectionsRequest is the request type for the
* Query/ClientConnections RPC method
*
* @generated from message ibc.core.connection.v1.QueryClientConnectionsRequest
*/
export class QueryClientConnectionsRequest extends Message<QueryClientConnectionsRequest> {
/**
* client identifier associated with a connection
*
* @generated from field: string client_id = 1;
*/
clientId = "";
constructor(data?: PartialMessage<QueryClientConnectionsRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.QueryClientConnectionsRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryClientConnectionsRequest {
return new QueryClientConnectionsRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryClientConnectionsRequest {
return new QueryClientConnectionsRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryClientConnectionsRequest {
return new QueryClientConnectionsRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryClientConnectionsRequest | PlainMessage<QueryClientConnectionsRequest> | undefined, b: QueryClientConnectionsRequest | PlainMessage<QueryClientConnectionsRequest> | undefined): boolean {
return proto3.util.equals(QueryClientConnectionsRequest, a, b);
}
}
/**
* QueryClientConnectionsResponse is the response type for the
* Query/ClientConnections RPC method
*
* @generated from message ibc.core.connection.v1.QueryClientConnectionsResponse
*/
export class QueryClientConnectionsResponse extends Message<QueryClientConnectionsResponse> {
/**
* slice of all the connection paths associated with a client.
*
* @generated from field: repeated string connection_paths = 1;
*/
connectionPaths: string[] = [];
/**
* merkle proof of existence
*
* @generated from field: bytes proof = 2;
*/
proof = new Uint8Array(0);
/**
* height at which the proof was generated
*
* @generated from field: ibc.core.client.v1.Height proof_height = 3;
*/
proofHeight?: Height;
constructor(data?: PartialMessage<QueryClientConnectionsResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.QueryClientConnectionsResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "connection_paths", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
{ no: 2, name: "proof", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 3, name: "proof_height", kind: "message", T: Height },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryClientConnectionsResponse {
return new QueryClientConnectionsResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryClientConnectionsResponse {
return new QueryClientConnectionsResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryClientConnectionsResponse {
return new QueryClientConnectionsResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryClientConnectionsResponse | PlainMessage<QueryClientConnectionsResponse> | undefined, b: QueryClientConnectionsResponse | PlainMessage<QueryClientConnectionsResponse> | undefined): boolean {
return proto3.util.equals(QueryClientConnectionsResponse, a, b);
}
}
/**
* QueryConnectionClientStateRequest is the request type for the
* Query/ConnectionClientState RPC method
*
* @generated from message ibc.core.connection.v1.QueryConnectionClientStateRequest
*/
export class QueryConnectionClientStateRequest extends Message<QueryConnectionClientStateRequest> {
/**
* connection identifier
*
* @generated from field: string connection_id = 1;
*/
connectionId = "";
constructor(data?: PartialMessage<QueryConnectionClientStateRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.QueryConnectionClientStateRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "connection_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryConnectionClientStateRequest {
return new QueryConnectionClientStateRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryConnectionClientStateRequest {
return new QueryConnectionClientStateRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryConnectionClientStateRequest {
return new QueryConnectionClientStateRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryConnectionClientStateRequest | PlainMessage<QueryConnectionClientStateRequest> | undefined, b: QueryConnectionClientStateRequest | PlainMessage<QueryConnectionClientStateRequest> | undefined): boolean {
return proto3.util.equals(QueryConnectionClientStateRequest, a, b);
}
}
/**
* QueryConnectionClientStateResponse is the response type for the
* Query/ConnectionClientState RPC method
*
* @generated from message ibc.core.connection.v1.QueryConnectionClientStateResponse
*/
export class QueryConnectionClientStateResponse extends Message<QueryConnectionClientStateResponse> {
/**
* client state associated with the channel
*
* @generated from field: ibc.core.client.v1.IdentifiedClientState identified_client_state = 1;
*/
identifiedClientState?: IdentifiedClientState;
/**
* merkle proof of existence
*
* @generated from field: bytes proof = 2;
*/
proof = new Uint8Array(0);
/**
* height at which the proof was retrieved
*
* @generated from field: ibc.core.client.v1.Height proof_height = 3;
*/
proofHeight?: Height;
constructor(data?: PartialMessage<QueryConnectionClientStateResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.QueryConnectionClientStateResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "identified_client_state", kind: "message", T: IdentifiedClientState },
{ no: 2, name: "proof", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 3, name: "proof_height", kind: "message", T: Height },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryConnectionClientStateResponse {
return new QueryConnectionClientStateResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryConnectionClientStateResponse {
return new QueryConnectionClientStateResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryConnectionClientStateResponse {
return new QueryConnectionClientStateResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryConnectionClientStateResponse | PlainMessage<QueryConnectionClientStateResponse> | undefined, b: QueryConnectionClientStateResponse | PlainMessage<QueryConnectionClientStateResponse> | undefined): boolean {
return proto3.util.equals(QueryConnectionClientStateResponse, a, b);
}
}
/**
* QueryConnectionConsensusStateRequest is the request type for the
* Query/ConnectionConsensusState RPC method
*
* @generated from message ibc.core.connection.v1.QueryConnectionConsensusStateRequest
*/
export class QueryConnectionConsensusStateRequest extends Message<QueryConnectionConsensusStateRequest> {
/**
* connection identifier
*
* @generated from field: string connection_id = 1;
*/
connectionId = "";
/**
* @generated from field: uint64 revision_number = 2;
*/
revisionNumber = protoInt64.zero;
/**
* @generated from field: uint64 revision_height = 3;
*/
revisionHeight = protoInt64.zero;
constructor(data?: PartialMessage<QueryConnectionConsensusStateRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.QueryConnectionConsensusStateRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "connection_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "revision_number", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 3, name: "revision_height", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryConnectionConsensusStateRequest {
return new QueryConnectionConsensusStateRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryConnectionConsensusStateRequest {
return new QueryConnectionConsensusStateRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryConnectionConsensusStateRequest {
return new QueryConnectionConsensusStateRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryConnectionConsensusStateRequest | PlainMessage<QueryConnectionConsensusStateRequest> | undefined, b: QueryConnectionConsensusStateRequest | PlainMessage<QueryConnectionConsensusStateRequest> | undefined): boolean {
return proto3.util.equals(QueryConnectionConsensusStateRequest, a, b);
}
}
/**
* QueryConnectionConsensusStateResponse is the response type for the
* Query/ConnectionConsensusState RPC method
*
* @generated from message ibc.core.connection.v1.QueryConnectionConsensusStateResponse
*/
export class QueryConnectionConsensusStateResponse extends Message<QueryConnectionConsensusStateResponse> {
/**
* consensus state associated with the channel
*
* @generated from field: google.protobuf.Any consensus_state = 1;
*/
consensusState?: Any;
/**
* client ID associated with the consensus state
*
* @generated from field: string client_id = 2;
*/
clientId = "";
/**
* merkle proof of existence
*
* @generated from field: bytes proof = 3;
*/
proof = new Uint8Array(0);
/**
* height at which the proof was retrieved
*
* @generated from field: ibc.core.client.v1.Height proof_height = 4;
*/
proofHeight?: Height;
constructor(data?: PartialMessage<QueryConnectionConsensusStateResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.QueryConnectionConsensusStateResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "consensus_state", kind: "message", T: Any },
{ no: 2, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "proof", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 4, name: "proof_height", kind: "message", T: Height },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryConnectionConsensusStateResponse {
return new QueryConnectionConsensusStateResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryConnectionConsensusStateResponse {
return new QueryConnectionConsensusStateResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryConnectionConsensusStateResponse {
return new QueryConnectionConsensusStateResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryConnectionConsensusStateResponse | PlainMessage<QueryConnectionConsensusStateResponse> | undefined, b: QueryConnectionConsensusStateResponse | PlainMessage<QueryConnectionConsensusStateResponse> | undefined): boolean {
return proto3.util.equals(QueryConnectionConsensusStateResponse, a, b);
}
}
/**
* QueryConnectionParamsRequest is the request type for the Query/ConnectionParams RPC method.
*
* @generated from message ibc.core.connection.v1.QueryConnectionParamsRequest
*/
export class QueryConnectionParamsRequest extends Message<QueryConnectionParamsRequest> {
constructor(data?: PartialMessage<QueryConnectionParamsRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.QueryConnectionParamsRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryConnectionParamsRequest {
return new QueryConnectionParamsRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryConnectionParamsRequest {
return new QueryConnectionParamsRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryConnectionParamsRequest {
return new QueryConnectionParamsRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryConnectionParamsRequest | PlainMessage<QueryConnectionParamsRequest> | undefined, b: QueryConnectionParamsRequest | PlainMessage<QueryConnectionParamsRequest> | undefined): boolean {
return proto3.util.equals(QueryConnectionParamsRequest, a, b);
}
}
/**
* QueryConnectionParamsResponse is the response type for the Query/ConnectionParams RPC method.
*
* @generated from message ibc.core.connection.v1.QueryConnectionParamsResponse
*/
export class QueryConnectionParamsResponse extends Message<QueryConnectionParamsResponse> {
/**
* params defines the parameters of the module.
*
* @generated from field: ibc.core.connection.v1.Params params = 1;
*/
params?: Params;
constructor(data?: PartialMessage<QueryConnectionParamsResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.QueryConnectionParamsResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "params", kind: "message", T: Params },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryConnectionParamsResponse {
return new QueryConnectionParamsResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryConnectionParamsResponse {
return new QueryConnectionParamsResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryConnectionParamsResponse {
return new QueryConnectionParamsResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryConnectionParamsResponse | PlainMessage<QueryConnectionParamsResponse> | undefined, b: QueryConnectionParamsResponse | PlainMessage<QueryConnectionParamsResponse> | undefined): boolean {
return proto3.util.equals(QueryConnectionParamsResponse, a, b);
}
}

71
libs/es-client/src/protobufs/ibc/core/connection/v1/tx_cosmes.ts Normal file
View File

@ -0,0 +1,71 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file ibc/core/connection/v1/tx.proto (package ibc.core.connection.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { MsgConnectionOpenAck, MsgConnectionOpenAckResponse, MsgConnectionOpenConfirm, MsgConnectionOpenConfirmResponse, MsgConnectionOpenInit, MsgConnectionOpenInitResponse, MsgConnectionOpenTry, MsgConnectionOpenTryResponse, MsgUpdateParams, MsgUpdateParamsResponse } from "./tx_pb.js";
const TYPE_NAME = "ibc.core.connection.v1.Msg";
/**
* ConnectionOpenInit defines a rpc handler method for MsgConnectionOpenInit.
*
* @generated from rpc ibc.core.connection.v1.Msg.ConnectionOpenInit
*/
export const MsgConnectionOpenInitService = {
typeName: TYPE_NAME,
method: "ConnectionOpenInit",
Request: MsgConnectionOpenInit,
Response: MsgConnectionOpenInitResponse,
} as const;
/**
* ConnectionOpenTry defines a rpc handler method for MsgConnectionOpenTry.
*
* @generated from rpc ibc.core.connection.v1.Msg.ConnectionOpenTry
*/
export const MsgConnectionOpenTryService = {
typeName: TYPE_NAME,
method: "ConnectionOpenTry",
Request: MsgConnectionOpenTry,
Response: MsgConnectionOpenTryResponse,
} as const;
/**
* ConnectionOpenAck defines a rpc handler method for MsgConnectionOpenAck.
*
* @generated from rpc ibc.core.connection.v1.Msg.ConnectionOpenAck
*/
export const MsgConnectionOpenAckService = {
typeName: TYPE_NAME,
method: "ConnectionOpenAck",
Request: MsgConnectionOpenAck,
Response: MsgConnectionOpenAckResponse,
} as const;
/**
* ConnectionOpenConfirm defines a rpc handler method for
* MsgConnectionOpenConfirm.
*
* @generated from rpc ibc.core.connection.v1.Msg.ConnectionOpenConfirm
*/
export const MsgConnectionOpenConfirmService = {
typeName: TYPE_NAME,
method: "ConnectionOpenConfirm",
Request: MsgConnectionOpenConfirm,
Response: MsgConnectionOpenConfirmResponse,
} as const;
/**
* UpdateConnectionParams defines a rpc handler method for
* MsgUpdateParams.
*
* @generated from rpc ibc.core.connection.v1.Msg.UpdateConnectionParams
*/
export const MsgUpdateConnectionParamsService = {
typeName: TYPE_NAME,
method: "UpdateConnectionParams",
Request: MsgUpdateParams,
Response: MsgUpdateParamsResponse,
} as const;

603
libs/es-client/src/protobufs/ibc/core/connection/v1/tx_pb.ts Normal file
View File

@ -0,0 +1,603 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/core/connection/v1/tx.proto (package ibc.core.connection.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Any, Message, proto3, protoInt64 } from "@bufbuild/protobuf";
import { Counterparty, Params, Version } from "./connection_pb.js";
import { Height } from "../../client/v1/client_pb.js";
/**
* MsgConnectionOpenInit defines the msg sent by an account on Chain A to
* initialize a connection with Chain B.
*
* @generated from message ibc.core.connection.v1.MsgConnectionOpenInit
*/
export class MsgConnectionOpenInit extends Message<MsgConnectionOpenInit> {
/**
* @generated from field: string client_id = 1;
*/
clientId = "";
/**
* @generated from field: ibc.core.connection.v1.Counterparty counterparty = 2;
*/
counterparty?: Counterparty;
/**
* @generated from field: ibc.core.connection.v1.Version version = 3;
*/
version?: Version;
/**
* @generated from field: uint64 delay_period = 4;
*/
delayPeriod = protoInt64.zero;
/**
* @generated from field: string signer = 5;
*/
signer = "";
constructor(data?: PartialMessage<MsgConnectionOpenInit>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.MsgConnectionOpenInit";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "counterparty", kind: "message", T: Counterparty },
{ no: 3, name: "version", kind: "message", T: Version },
{ no: 4, name: "delay_period", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 5, name: "signer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgConnectionOpenInit {
return new MsgConnectionOpenInit().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgConnectionOpenInit {
return new MsgConnectionOpenInit().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgConnectionOpenInit {
return new MsgConnectionOpenInit().fromJsonString(jsonString, options);
}
static equals(a: MsgConnectionOpenInit | PlainMessage<MsgConnectionOpenInit> | undefined, b: MsgConnectionOpenInit | PlainMessage<MsgConnectionOpenInit> | undefined): boolean {
return proto3.util.equals(MsgConnectionOpenInit, a, b);
}
}
/**
* MsgConnectionOpenInitResponse defines the Msg/ConnectionOpenInit response
* type.
*
* @generated from message ibc.core.connection.v1.MsgConnectionOpenInitResponse
*/
export class MsgConnectionOpenInitResponse extends Message<MsgConnectionOpenInitResponse> {
constructor(data?: PartialMessage<MsgConnectionOpenInitResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.MsgConnectionOpenInitResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgConnectionOpenInitResponse {
return new MsgConnectionOpenInitResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgConnectionOpenInitResponse {
return new MsgConnectionOpenInitResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgConnectionOpenInitResponse {
return new MsgConnectionOpenInitResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgConnectionOpenInitResponse | PlainMessage<MsgConnectionOpenInitResponse> | undefined, b: MsgConnectionOpenInitResponse | PlainMessage<MsgConnectionOpenInitResponse> | undefined): boolean {
return proto3.util.equals(MsgConnectionOpenInitResponse, a, b);
}
}
/**
* MsgConnectionOpenTry defines a msg sent by a Relayer to try to open a
* connection on Chain B.
*
* @generated from message ibc.core.connection.v1.MsgConnectionOpenTry
*/
export class MsgConnectionOpenTry extends Message<MsgConnectionOpenTry> {
/**
* @generated from field: string client_id = 1;
*/
clientId = "";
/**
* Deprecated: this field is unused. Crossing hellos are no longer supported in core IBC.
*
* @generated from field: string previous_connection_id = 2 [deprecated = true];
* @deprecated
*/
previousConnectionId = "";
/**
* Deprecated: this field is unused.
*
* @generated from field: google.protobuf.Any client_state = 3 [deprecated = true];
* @deprecated
*/
clientState?: Any;
/**
* @generated from field: ibc.core.connection.v1.Counterparty counterparty = 4;
*/
counterparty?: Counterparty;
/**
* @generated from field: uint64 delay_period = 5;
*/
delayPeriod = protoInt64.zero;
/**
* @generated from field: repeated ibc.core.connection.v1.Version counterparty_versions = 6;
*/
counterpartyVersions: Version[] = [];
/**
* @generated from field: ibc.core.client.v1.Height proof_height = 7;
*/
proofHeight?: Height;
/**
* proof of the initialization the connection on Chain A: `UNINITIALIZED ->
* INIT`
*
* @generated from field: bytes proof_init = 8;
*/
proofInit = new Uint8Array(0);
/**
* Deprecated: this field is unused.
*
* @generated from field: bytes proof_client = 9 [deprecated = true];
* @deprecated
*/
proofClient = new Uint8Array(0);
/**
* Deprecated: this field is unused.
*
* @generated from field: bytes proof_consensus = 10 [deprecated = true];
* @deprecated
*/
proofConsensus = new Uint8Array(0);
/**
* Deprecated: this field is unused.
*
* @generated from field: ibc.core.client.v1.Height consensus_height = 11 [deprecated = true];
* @deprecated
*/
consensusHeight?: Height;
/**
* @generated from field: string signer = 12;
*/
signer = "";
/**
* Deprecated: this field is unused.
*
* @generated from field: bytes host_consensus_state_proof = 13 [deprecated = true];
* @deprecated
*/
hostConsensusStateProof = new Uint8Array(0);
constructor(data?: PartialMessage<MsgConnectionOpenTry>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.MsgConnectionOpenTry";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "previous_connection_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "client_state", kind: "message", T: Any },
{ no: 4, name: "counterparty", kind: "message", T: Counterparty },
{ no: 5, name: "delay_period", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 6, name: "counterparty_versions", kind: "message", T: Version, repeated: true },
{ no: 7, name: "proof_height", kind: "message", T: Height },
{ no: 8, name: "proof_init", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 9, name: "proof_client", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 10, name: "proof_consensus", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 11, name: "consensus_height", kind: "message", T: Height },
{ no: 12, name: "signer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 13, name: "host_consensus_state_proof", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgConnectionOpenTry {
return new MsgConnectionOpenTry().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgConnectionOpenTry {
return new MsgConnectionOpenTry().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgConnectionOpenTry {
return new MsgConnectionOpenTry().fromJsonString(jsonString, options);
}
static equals(a: MsgConnectionOpenTry | PlainMessage<MsgConnectionOpenTry> | undefined, b: MsgConnectionOpenTry | PlainMessage<MsgConnectionOpenTry> | undefined): boolean {
return proto3.util.equals(MsgConnectionOpenTry, a, b);
}
}
/**
* MsgConnectionOpenTryResponse defines the Msg/ConnectionOpenTry response type.
*
* @generated from message ibc.core.connection.v1.MsgConnectionOpenTryResponse
*/
export class MsgConnectionOpenTryResponse extends Message<MsgConnectionOpenTryResponse> {
constructor(data?: PartialMessage<MsgConnectionOpenTryResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.MsgConnectionOpenTryResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgConnectionOpenTryResponse {
return new MsgConnectionOpenTryResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgConnectionOpenTryResponse {
return new MsgConnectionOpenTryResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgConnectionOpenTryResponse {
return new MsgConnectionOpenTryResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgConnectionOpenTryResponse | PlainMessage<MsgConnectionOpenTryResponse> | undefined, b: MsgConnectionOpenTryResponse | PlainMessage<MsgConnectionOpenTryResponse> | undefined): boolean {
return proto3.util.equals(MsgConnectionOpenTryResponse, a, b);
}
}
/**
* MsgConnectionOpenAck defines a msg sent by a Relayer to Chain A to
* acknowledge the change of connection state to TRYOPEN on Chain B.
*
* @generated from message ibc.core.connection.v1.MsgConnectionOpenAck
*/
export class MsgConnectionOpenAck extends Message<MsgConnectionOpenAck> {
/**
* @generated from field: string connection_id = 1;
*/
connectionId = "";
/**
* @generated from field: string counterparty_connection_id = 2;
*/
counterpartyConnectionId = "";
/**
* @generated from field: ibc.core.connection.v1.Version version = 3;
*/
version?: Version;
/**
* Deprecated: this field is unused.
*
* @generated from field: google.protobuf.Any client_state = 4 [deprecated = true];
* @deprecated
*/
clientState?: Any;
/**
* @generated from field: ibc.core.client.v1.Height proof_height = 5;
*/
proofHeight?: Height;
/**
* proof of the initialization the connection on Chain B: `UNINITIALIZED ->
* TRYOPEN`
*
* @generated from field: bytes proof_try = 6;
*/
proofTry = new Uint8Array(0);
/**
* Deprecated: this field is unused.
*
* @generated from field: bytes proof_client = 7 [deprecated = true];
* @deprecated
*/
proofClient = new Uint8Array(0);
/**
* Deprecated: this field is unused.
*
* @generated from field: bytes proof_consensus = 8 [deprecated = true];
* @deprecated
*/
proofConsensus = new Uint8Array(0);
/**
* Deprecated: this field is unused.
*
* @generated from field: ibc.core.client.v1.Height consensus_height = 9 [deprecated = true];
* @deprecated
*/
consensusHeight?: Height;
/**
* @generated from field: string signer = 10;
*/
signer = "";
/**
* Deprecated: this field is unused.
*
* @generated from field: bytes host_consensus_state_proof = 11 [deprecated = true];
* @deprecated
*/
hostConsensusStateProof = new Uint8Array(0);
constructor(data?: PartialMessage<MsgConnectionOpenAck>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.MsgConnectionOpenAck";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "connection_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "counterparty_connection_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "version", kind: "message", T: Version },
{ no: 4, name: "client_state", kind: "message", T: Any },
{ no: 5, name: "proof_height", kind: "message", T: Height },
{ no: 6, name: "proof_try", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 7, name: "proof_client", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 8, name: "proof_consensus", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 9, name: "consensus_height", kind: "message", T: Height },
{ no: 10, name: "signer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 11, name: "host_consensus_state_proof", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgConnectionOpenAck {
return new MsgConnectionOpenAck().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgConnectionOpenAck {
return new MsgConnectionOpenAck().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgConnectionOpenAck {
return new MsgConnectionOpenAck().fromJsonString(jsonString, options);
}
static equals(a: MsgConnectionOpenAck | PlainMessage<MsgConnectionOpenAck> | undefined, b: MsgConnectionOpenAck | PlainMessage<MsgConnectionOpenAck> | undefined): boolean {
return proto3.util.equals(MsgConnectionOpenAck, a, b);
}
}
/**
* MsgConnectionOpenAckResponse defines the Msg/ConnectionOpenAck response type.
*
* @generated from message ibc.core.connection.v1.MsgConnectionOpenAckResponse
*/
export class MsgConnectionOpenAckResponse extends Message<MsgConnectionOpenAckResponse> {
constructor(data?: PartialMessage<MsgConnectionOpenAckResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.MsgConnectionOpenAckResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgConnectionOpenAckResponse {
return new MsgConnectionOpenAckResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgConnectionOpenAckResponse {
return new MsgConnectionOpenAckResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgConnectionOpenAckResponse {
return new MsgConnectionOpenAckResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgConnectionOpenAckResponse | PlainMessage<MsgConnectionOpenAckResponse> | undefined, b: MsgConnectionOpenAckResponse | PlainMessage<MsgConnectionOpenAckResponse> | undefined): boolean {
return proto3.util.equals(MsgConnectionOpenAckResponse, a, b);
}
}
/**
* MsgConnectionOpenConfirm defines a msg sent by a Relayer to Chain B to
* acknowledge the change of connection state to OPEN on Chain A.
*
* @generated from message ibc.core.connection.v1.MsgConnectionOpenConfirm
*/
export class MsgConnectionOpenConfirm extends Message<MsgConnectionOpenConfirm> {
/**
* @generated from field: string connection_id = 1;
*/
connectionId = "";
/**
* proof for the change of the connection state on Chain A: `INIT -> OPEN`
*
* @generated from field: bytes proof_ack = 2;
*/
proofAck = new Uint8Array(0);
/**
* @generated from field: ibc.core.client.v1.Height proof_height = 3;
*/
proofHeight?: Height;
/**
* @generated from field: string signer = 4;
*/
signer = "";
constructor(data?: PartialMessage<MsgConnectionOpenConfirm>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.MsgConnectionOpenConfirm";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "connection_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "proof_ack", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 3, name: "proof_height", kind: "message", T: Height },
{ no: 4, name: "signer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgConnectionOpenConfirm {
return new MsgConnectionOpenConfirm().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgConnectionOpenConfirm {
return new MsgConnectionOpenConfirm().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgConnectionOpenConfirm {
return new MsgConnectionOpenConfirm().fromJsonString(jsonString, options);
}
static equals(a: MsgConnectionOpenConfirm | PlainMessage<MsgConnectionOpenConfirm> | undefined, b: MsgConnectionOpenConfirm | PlainMessage<MsgConnectionOpenConfirm> | undefined): boolean {
return proto3.util.equals(MsgConnectionOpenConfirm, a, b);
}
}
/**
* MsgConnectionOpenConfirmResponse defines the Msg/ConnectionOpenConfirm
* response type.
*
* @generated from message ibc.core.connection.v1.MsgConnectionOpenConfirmResponse
*/
export class MsgConnectionOpenConfirmResponse extends Message<MsgConnectionOpenConfirmResponse> {
constructor(data?: PartialMessage<MsgConnectionOpenConfirmResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.MsgConnectionOpenConfirmResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgConnectionOpenConfirmResponse {
return new MsgConnectionOpenConfirmResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgConnectionOpenConfirmResponse {
return new MsgConnectionOpenConfirmResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgConnectionOpenConfirmResponse {
return new MsgConnectionOpenConfirmResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgConnectionOpenConfirmResponse | PlainMessage<MsgConnectionOpenConfirmResponse> | undefined, b: MsgConnectionOpenConfirmResponse | PlainMessage<MsgConnectionOpenConfirmResponse> | undefined): boolean {
return proto3.util.equals(MsgConnectionOpenConfirmResponse, a, b);
}
}
/**
* MsgUpdateParams defines the sdk.Msg type to update the connection parameters.
*
* @generated from message ibc.core.connection.v1.MsgUpdateParams
*/
export class MsgUpdateParams extends Message<MsgUpdateParams> {
/**
* signer address
*
* @generated from field: string signer = 1;
*/
signer = "";
/**
* params defines the connection parameters to update.
*
* NOTE: All parameters must be supplied.
*
* @generated from field: ibc.core.connection.v1.Params params = 2;
*/
params?: Params;
constructor(data?: PartialMessage<MsgUpdateParams>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.MsgUpdateParams";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "signer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "params", kind: "message", T: Params },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgUpdateParams {
return new MsgUpdateParams().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgUpdateParams {
return new MsgUpdateParams().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgUpdateParams {
return new MsgUpdateParams().fromJsonString(jsonString, options);
}
static equals(a: MsgUpdateParams | PlainMessage<MsgUpdateParams> | undefined, b: MsgUpdateParams | PlainMessage<MsgUpdateParams> | undefined): boolean {
return proto3.util.equals(MsgUpdateParams, a, b);
}
}
/**
* MsgUpdateParamsResponse defines the MsgUpdateParams response type.
*
* @generated from message ibc.core.connection.v1.MsgUpdateParamsResponse
*/
export class MsgUpdateParamsResponse extends Message<MsgUpdateParamsResponse> {
constructor(data?: PartialMessage<MsgUpdateParamsResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.connection.v1.MsgUpdateParamsResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgUpdateParamsResponse {
return new MsgUpdateParamsResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgUpdateParamsResponse {
return new MsgUpdateParamsResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgUpdateParamsResponse {
return new MsgUpdateParamsResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgUpdateParamsResponse | PlainMessage<MsgUpdateParamsResponse> | undefined, b: MsgUpdateParamsResponse | PlainMessage<MsgUpdateParamsResponse> | undefined): boolean {
return proto3.util.equals(MsgUpdateParamsResponse, a, b);
}
}

68
libs/es-client/src/protobufs/ibc/core/types/v1/genesis_pb.ts Normal file
View File

@ -0,0 +1,68 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/core/types/v1/genesis.proto (package ibc.core.types.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { GenesisState as GenesisState$1 } from "../../client/v1/genesis_pb.js";
import { GenesisState as GenesisState$2 } from "../../connection/v1/genesis_pb.js";
import { GenesisState as GenesisState$3 } from "../../channel/v1/genesis_pb.js";
/**
* GenesisState defines the ibc module's genesis state.
*
* @generated from message ibc.core.types.v1.GenesisState
*/
export class GenesisState extends Message<GenesisState> {
/**
* ICS002 - Clients genesis state
*
* @generated from field: ibc.core.client.v1.GenesisState client_genesis = 1;
*/
clientGenesis?: GenesisState$1;
/**
* ICS003 - Connections genesis state
*
* @generated from field: ibc.core.connection.v1.GenesisState connection_genesis = 2;
*/
connectionGenesis?: GenesisState$2;
/**
* ICS004 - Channel genesis state
*
* @generated from field: ibc.core.channel.v1.GenesisState channel_genesis = 3;
*/
channelGenesis?: GenesisState$3;
constructor(data?: PartialMessage<GenesisState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.core.types.v1.GenesisState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_genesis", kind: "message", T: GenesisState$1 },
{ no: 2, name: "connection_genesis", kind: "message", T: GenesisState$2 },
{ no: 3, name: "channel_genesis", kind: "message", T: GenesisState$3 },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GenesisState {
return new GenesisState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJsonString(jsonString, options);
}
static equals(a: GenesisState | PlainMessage<GenesisState> | undefined, b: GenesisState | PlainMessage<GenesisState> | undefined): boolean {
return proto3.util.equals(GenesisState, a, b);
}
}

929
libs/es-client/src/protobufs/ibc/lightclients/solomachine/v2/solomachine_pb.ts Normal file
View File

@ -0,0 +1,929 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/lightclients/solomachine/v2/solomachine.proto (package ibc.lightclients.solomachine.v2, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Any, Message, proto3, protoInt64 } from "@bufbuild/protobuf";
import { ConnectionEnd } from "../../../core/connection/v1/connection_pb.js";
import { Channel } from "../../../core/channel/v1/channel_pb.js";
/**
* DataType defines the type of solo machine proof being created. This is done
* to preserve uniqueness of different data sign byte encodings.
*
* @generated from enum ibc.lightclients.solomachine.v2.DataType
*/
export enum DataType {
/**
* Default State
*
* @generated from enum value: DATA_TYPE_UNINITIALIZED_UNSPECIFIED = 0;
*/
UNINITIALIZED_UNSPECIFIED = 0,
/**
* Data type for client state verification
*
* @generated from enum value: DATA_TYPE_CLIENT_STATE = 1;
*/
CLIENT_STATE = 1,
/**
* Data type for consensus state verification
*
* @generated from enum value: DATA_TYPE_CONSENSUS_STATE = 2;
*/
CONSENSUS_STATE = 2,
/**
* Data type for connection state verification
*
* @generated from enum value: DATA_TYPE_CONNECTION_STATE = 3;
*/
CONNECTION_STATE = 3,
/**
* Data type for channel state verification
*
* @generated from enum value: DATA_TYPE_CHANNEL_STATE = 4;
*/
CHANNEL_STATE = 4,
/**
* Data type for packet commitment verification
*
* @generated from enum value: DATA_TYPE_PACKET_COMMITMENT = 5;
*/
PACKET_COMMITMENT = 5,
/**
* Data type for packet acknowledgement verification
*
* @generated from enum value: DATA_TYPE_PACKET_ACKNOWLEDGEMENT = 6;
*/
PACKET_ACKNOWLEDGEMENT = 6,
/**
* Data type for packet receipt absence verification
*
* @generated from enum value: DATA_TYPE_PACKET_RECEIPT_ABSENCE = 7;
*/
PACKET_RECEIPT_ABSENCE = 7,
/**
* Data type for next sequence recv verification
*
* @generated from enum value: DATA_TYPE_NEXT_SEQUENCE_RECV = 8;
*/
NEXT_SEQUENCE_RECV = 8,
/**
* Data type for header verification
*
* @generated from enum value: DATA_TYPE_HEADER = 9;
*/
HEADER = 9,
}
// Retrieve enum metadata with: proto3.getEnumType(DataType)
proto3.util.setEnumType(DataType, "ibc.lightclients.solomachine.v2.DataType", [
{ no: 0, name: "DATA_TYPE_UNINITIALIZED_UNSPECIFIED" },
{ no: 1, name: "DATA_TYPE_CLIENT_STATE" },
{ no: 2, name: "DATA_TYPE_CONSENSUS_STATE" },
{ no: 3, name: "DATA_TYPE_CONNECTION_STATE" },
{ no: 4, name: "DATA_TYPE_CHANNEL_STATE" },
{ no: 5, name: "DATA_TYPE_PACKET_COMMITMENT" },
{ no: 6, name: "DATA_TYPE_PACKET_ACKNOWLEDGEMENT" },
{ no: 7, name: "DATA_TYPE_PACKET_RECEIPT_ABSENCE" },
{ no: 8, name: "DATA_TYPE_NEXT_SEQUENCE_RECV" },
{ no: 9, name: "DATA_TYPE_HEADER" },
]);
/**
* ClientState defines a solo machine client that tracks the current consensus
* state and if the client is frozen.
*
* @generated from message ibc.lightclients.solomachine.v2.ClientState
*/
export class ClientState extends Message<ClientState> {
/**
* latest sequence of the client state
*
* @generated from field: uint64 sequence = 1;
*/
sequence = protoInt64.zero;
/**
* frozen sequence of the solo machine
*
* @generated from field: bool is_frozen = 2;
*/
isFrozen = false;
/**
* @generated from field: ibc.lightclients.solomachine.v2.ConsensusState consensus_state = 3;
*/
consensusState?: ConsensusState;
/**
* when set to true, will allow governance to update a solo machine client.
* The client will be unfrozen if it is frozen.
*
* @generated from field: bool allow_update_after_proposal = 4;
*/
allowUpdateAfterProposal = false;
constructor(data?: PartialMessage<ClientState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v2.ClientState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 2, name: "is_frozen", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
{ no: 3, name: "consensus_state", kind: "message", T: ConsensusState },
{ no: 4, name: "allow_update_after_proposal", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ClientState {
return new ClientState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ClientState {
return new ClientState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ClientState {
return new ClientState().fromJsonString(jsonString, options);
}
static equals(a: ClientState | PlainMessage<ClientState> | undefined, b: ClientState | PlainMessage<ClientState> | undefined): boolean {
return proto3.util.equals(ClientState, a, b);
}
}
/**
* ConsensusState defines a solo machine consensus state. The sequence of a
* consensus state is contained in the "height" key used in storing the
* consensus state.
*
* @generated from message ibc.lightclients.solomachine.v2.ConsensusState
*/
export class ConsensusState extends Message<ConsensusState> {
/**
* public key of the solo machine
*
* @generated from field: google.protobuf.Any public_key = 1;
*/
publicKey?: Any;
/**
* diversifier allows the same public key to be re-used across different solo
* machine clients (potentially on different chains) without being considered
* misbehaviour.
*
* @generated from field: string diversifier = 2;
*/
diversifier = "";
/**
* @generated from field: uint64 timestamp = 3;
*/
timestamp = protoInt64.zero;
constructor(data?: PartialMessage<ConsensusState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v2.ConsensusState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "public_key", kind: "message", T: Any },
{ no: 2, name: "diversifier", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConsensusState {
return new ConsensusState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConsensusState {
return new ConsensusState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConsensusState {
return new ConsensusState().fromJsonString(jsonString, options);
}
static equals(a: ConsensusState | PlainMessage<ConsensusState> | undefined, b: ConsensusState | PlainMessage<ConsensusState> | undefined): boolean {
return proto3.util.equals(ConsensusState, a, b);
}
}
/**
* Header defines a solo machine consensus header
*
* @generated from message ibc.lightclients.solomachine.v2.Header
*/
export class Header extends Message<Header> {
/**
* sequence to update solo machine public key at
*
* @generated from field: uint64 sequence = 1;
*/
sequence = protoInt64.zero;
/**
* @generated from field: uint64 timestamp = 2;
*/
timestamp = protoInt64.zero;
/**
* @generated from field: bytes signature = 3;
*/
signature = new Uint8Array(0);
/**
* @generated from field: google.protobuf.Any new_public_key = 4;
*/
newPublicKey?: Any;
/**
* @generated from field: string new_diversifier = 5;
*/
newDiversifier = "";
constructor(data?: PartialMessage<Header>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v2.Header";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 2, name: "timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 3, name: "signature", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 4, name: "new_public_key", kind: "message", T: Any },
{ no: 5, name: "new_diversifier", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Header {
return new Header().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Header {
return new Header().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Header {
return new Header().fromJsonString(jsonString, options);
}
static equals(a: Header | PlainMessage<Header> | undefined, b: Header | PlainMessage<Header> | undefined): boolean {
return proto3.util.equals(Header, a, b);
}
}
/**
* Misbehaviour defines misbehaviour for a solo machine which consists
* of a sequence and two signatures over different messages at that sequence.
*
* @generated from message ibc.lightclients.solomachine.v2.Misbehaviour
*/
export class Misbehaviour extends Message<Misbehaviour> {
/**
* @generated from field: string client_id = 1;
*/
clientId = "";
/**
* @generated from field: uint64 sequence = 2;
*/
sequence = protoInt64.zero;
/**
* @generated from field: ibc.lightclients.solomachine.v2.SignatureAndData signature_one = 3;
*/
signatureOne?: SignatureAndData;
/**
* @generated from field: ibc.lightclients.solomachine.v2.SignatureAndData signature_two = 4;
*/
signatureTwo?: SignatureAndData;
constructor(data?: PartialMessage<Misbehaviour>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v2.Misbehaviour";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 3, name: "signature_one", kind: "message", T: SignatureAndData },
{ no: 4, name: "signature_two", kind: "message", T: SignatureAndData },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Misbehaviour {
return new Misbehaviour().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Misbehaviour {
return new Misbehaviour().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Misbehaviour {
return new Misbehaviour().fromJsonString(jsonString, options);
}
static equals(a: Misbehaviour | PlainMessage<Misbehaviour> | undefined, b: Misbehaviour | PlainMessage<Misbehaviour> | undefined): boolean {
return proto3.util.equals(Misbehaviour, a, b);
}
}
/**
* SignatureAndData contains a signature and the data signed over to create that
* signature.
*
* @generated from message ibc.lightclients.solomachine.v2.SignatureAndData
*/
export class SignatureAndData extends Message<SignatureAndData> {
/**
* @generated from field: bytes signature = 1;
*/
signature = new Uint8Array(0);
/**
* @generated from field: ibc.lightclients.solomachine.v2.DataType data_type = 2;
*/
dataType = DataType.UNINITIALIZED_UNSPECIFIED;
/**
* @generated from field: bytes data = 3;
*/
data = new Uint8Array(0);
/**
* @generated from field: uint64 timestamp = 4;
*/
timestamp = protoInt64.zero;
constructor(data?: PartialMessage<SignatureAndData>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v2.SignatureAndData";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "signature", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "data_type", kind: "enum", T: proto3.getEnumType(DataType) },
{ no: 3, name: "data", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 4, name: "timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SignatureAndData {
return new SignatureAndData().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SignatureAndData {
return new SignatureAndData().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SignatureAndData {
return new SignatureAndData().fromJsonString(jsonString, options);
}
static equals(a: SignatureAndData | PlainMessage<SignatureAndData> | undefined, b: SignatureAndData | PlainMessage<SignatureAndData> | undefined): boolean {
return proto3.util.equals(SignatureAndData, a, b);
}
}
/**
* TimestampedSignatureData contains the signature data and the timestamp of the
* signature.
*
* @generated from message ibc.lightclients.solomachine.v2.TimestampedSignatureData
*/
export class TimestampedSignatureData extends Message<TimestampedSignatureData> {
/**
* @generated from field: bytes signature_data = 1;
*/
signatureData = new Uint8Array(0);
/**
* @generated from field: uint64 timestamp = 2;
*/
timestamp = protoInt64.zero;
constructor(data?: PartialMessage<TimestampedSignatureData>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v2.TimestampedSignatureData";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "signature_data", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TimestampedSignatureData {
return new TimestampedSignatureData().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TimestampedSignatureData {
return new TimestampedSignatureData().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TimestampedSignatureData {
return new TimestampedSignatureData().fromJsonString(jsonString, options);
}
static equals(a: TimestampedSignatureData | PlainMessage<TimestampedSignatureData> | undefined, b: TimestampedSignatureData | PlainMessage<TimestampedSignatureData> | undefined): boolean {
return proto3.util.equals(TimestampedSignatureData, a, b);
}
}
/**
* SignBytes defines the signed bytes used for signature verification.
*
* @generated from message ibc.lightclients.solomachine.v2.SignBytes
*/
export class SignBytes extends Message<SignBytes> {
/**
* @generated from field: uint64 sequence = 1;
*/
sequence = protoInt64.zero;
/**
* @generated from field: uint64 timestamp = 2;
*/
timestamp = protoInt64.zero;
/**
* @generated from field: string diversifier = 3;
*/
diversifier = "";
/**
* type of the data used
*
* @generated from field: ibc.lightclients.solomachine.v2.DataType data_type = 4;
*/
dataType = DataType.UNINITIALIZED_UNSPECIFIED;
/**
* marshaled data
*
* @generated from field: bytes data = 5;
*/
data = new Uint8Array(0);
constructor(data?: PartialMessage<SignBytes>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v2.SignBytes";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 2, name: "timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 3, name: "diversifier", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "data_type", kind: "enum", T: proto3.getEnumType(DataType) },
{ no: 5, name: "data", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SignBytes {
return new SignBytes().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SignBytes {
return new SignBytes().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SignBytes {
return new SignBytes().fromJsonString(jsonString, options);
}
static equals(a: SignBytes | PlainMessage<SignBytes> | undefined, b: SignBytes | PlainMessage<SignBytes> | undefined): boolean {
return proto3.util.equals(SignBytes, a, b);
}
}
/**
* HeaderData returns the SignBytes data for update verification.
*
* @generated from message ibc.lightclients.solomachine.v2.HeaderData
*/
export class HeaderData extends Message<HeaderData> {
/**
* header public key
*
* @generated from field: google.protobuf.Any new_pub_key = 1;
*/
newPubKey?: Any;
/**
* header diversifier
*
* @generated from field: string new_diversifier = 2;
*/
newDiversifier = "";
constructor(data?: PartialMessage<HeaderData>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v2.HeaderData";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "new_pub_key", kind: "message", T: Any },
{ no: 2, name: "new_diversifier", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HeaderData {
return new HeaderData().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HeaderData {
return new HeaderData().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HeaderData {
return new HeaderData().fromJsonString(jsonString, options);
}
static equals(a: HeaderData | PlainMessage<HeaderData> | undefined, b: HeaderData | PlainMessage<HeaderData> | undefined): boolean {
return proto3.util.equals(HeaderData, a, b);
}
}
/**
* ClientStateData returns the SignBytes data for client state verification.
*
* @generated from message ibc.lightclients.solomachine.v2.ClientStateData
*/
export class ClientStateData extends Message<ClientStateData> {
/**
* @generated from field: bytes path = 1;
*/
path = new Uint8Array(0);
/**
* @generated from field: google.protobuf.Any client_state = 2;
*/
clientState?: Any;
constructor(data?: PartialMessage<ClientStateData>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v2.ClientStateData";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "path", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "client_state", kind: "message", T: Any },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ClientStateData {
return new ClientStateData().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ClientStateData {
return new ClientStateData().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ClientStateData {
return new ClientStateData().fromJsonString(jsonString, options);
}
static equals(a: ClientStateData | PlainMessage<ClientStateData> | undefined, b: ClientStateData | PlainMessage<ClientStateData> | undefined): boolean {
return proto3.util.equals(ClientStateData, a, b);
}
}
/**
* ConsensusStateData returns the SignBytes data for consensus state
* verification.
*
* @generated from message ibc.lightclients.solomachine.v2.ConsensusStateData
*/
export class ConsensusStateData extends Message<ConsensusStateData> {
/**
* @generated from field: bytes path = 1;
*/
path = new Uint8Array(0);
/**
* @generated from field: google.protobuf.Any consensus_state = 2;
*/
consensusState?: Any;
constructor(data?: PartialMessage<ConsensusStateData>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v2.ConsensusStateData";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "path", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "consensus_state", kind: "message", T: Any },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConsensusStateData {
return new ConsensusStateData().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConsensusStateData {
return new ConsensusStateData().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConsensusStateData {
return new ConsensusStateData().fromJsonString(jsonString, options);
}
static equals(a: ConsensusStateData | PlainMessage<ConsensusStateData> | undefined, b: ConsensusStateData | PlainMessage<ConsensusStateData> | undefined): boolean {
return proto3.util.equals(ConsensusStateData, a, b);
}
}
/**
* ConnectionStateData returns the SignBytes data for connection state
* verification.
*
* @generated from message ibc.lightclients.solomachine.v2.ConnectionStateData
*/
export class ConnectionStateData extends Message<ConnectionStateData> {
/**
* @generated from field: bytes path = 1;
*/
path = new Uint8Array(0);
/**
* @generated from field: ibc.core.connection.v1.ConnectionEnd connection = 2;
*/
connection?: ConnectionEnd;
constructor(data?: PartialMessage<ConnectionStateData>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v2.ConnectionStateData";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "path", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "connection", kind: "message", T: ConnectionEnd },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConnectionStateData {
return new ConnectionStateData().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConnectionStateData {
return new ConnectionStateData().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConnectionStateData {
return new ConnectionStateData().fromJsonString(jsonString, options);
}
static equals(a: ConnectionStateData | PlainMessage<ConnectionStateData> | undefined, b: ConnectionStateData | PlainMessage<ConnectionStateData> | undefined): boolean {
return proto3.util.equals(ConnectionStateData, a, b);
}
}
/**
* ChannelStateData returns the SignBytes data for channel state
* verification.
*
* @generated from message ibc.lightclients.solomachine.v2.ChannelStateData
*/
export class ChannelStateData extends Message<ChannelStateData> {
/**
* @generated from field: bytes path = 1;
*/
path = new Uint8Array(0);
/**
* @generated from field: ibc.core.channel.v1.Channel channel = 2;
*/
channel?: Channel;
constructor(data?: PartialMessage<ChannelStateData>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v2.ChannelStateData";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "path", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "channel", kind: "message", T: Channel },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ChannelStateData {
return new ChannelStateData().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ChannelStateData {
return new ChannelStateData().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ChannelStateData {
return new ChannelStateData().fromJsonString(jsonString, options);
}
static equals(a: ChannelStateData | PlainMessage<ChannelStateData> | undefined, b: ChannelStateData | PlainMessage<ChannelStateData> | undefined): boolean {
return proto3.util.equals(ChannelStateData, a, b);
}
}
/**
* PacketCommitmentData returns the SignBytes data for packet commitment
* verification.
*
* @generated from message ibc.lightclients.solomachine.v2.PacketCommitmentData
*/
export class PacketCommitmentData extends Message<PacketCommitmentData> {
/**
* @generated from field: bytes path = 1;
*/
path = new Uint8Array(0);
/**
* @generated from field: bytes commitment = 2;
*/
commitment = new Uint8Array(0);
constructor(data?: PartialMessage<PacketCommitmentData>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v2.PacketCommitmentData";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "path", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "commitment", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PacketCommitmentData {
return new PacketCommitmentData().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PacketCommitmentData {
return new PacketCommitmentData().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PacketCommitmentData {
return new PacketCommitmentData().fromJsonString(jsonString, options);
}
static equals(a: PacketCommitmentData | PlainMessage<PacketCommitmentData> | undefined, b: PacketCommitmentData | PlainMessage<PacketCommitmentData> | undefined): boolean {
return proto3.util.equals(PacketCommitmentData, a, b);
}
}
/**
* PacketAcknowledgementData returns the SignBytes data for acknowledgement
* verification.
*
* @generated from message ibc.lightclients.solomachine.v2.PacketAcknowledgementData
*/
export class PacketAcknowledgementData extends Message<PacketAcknowledgementData> {
/**
* @generated from field: bytes path = 1;
*/
path = new Uint8Array(0);
/**
* @generated from field: bytes acknowledgement = 2;
*/
acknowledgement = new Uint8Array(0);
constructor(data?: PartialMessage<PacketAcknowledgementData>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v2.PacketAcknowledgementData";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "path", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "acknowledgement", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PacketAcknowledgementData {
return new PacketAcknowledgementData().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PacketAcknowledgementData {
return new PacketAcknowledgementData().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PacketAcknowledgementData {
return new PacketAcknowledgementData().fromJsonString(jsonString, options);
}
static equals(a: PacketAcknowledgementData | PlainMessage<PacketAcknowledgementData> | undefined, b: PacketAcknowledgementData | PlainMessage<PacketAcknowledgementData> | undefined): boolean {
return proto3.util.equals(PacketAcknowledgementData, a, b);
}
}
/**
* PacketReceiptAbsenceData returns the SignBytes data for
* packet receipt absence verification.
*
* @generated from message ibc.lightclients.solomachine.v2.PacketReceiptAbsenceData
*/
export class PacketReceiptAbsenceData extends Message<PacketReceiptAbsenceData> {
/**
* @generated from field: bytes path = 1;
*/
path = new Uint8Array(0);
constructor(data?: PartialMessage<PacketReceiptAbsenceData>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v2.PacketReceiptAbsenceData";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "path", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PacketReceiptAbsenceData {
return new PacketReceiptAbsenceData().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PacketReceiptAbsenceData {
return new PacketReceiptAbsenceData().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PacketReceiptAbsenceData {
return new PacketReceiptAbsenceData().fromJsonString(jsonString, options);
}
static equals(a: PacketReceiptAbsenceData | PlainMessage<PacketReceiptAbsenceData> | undefined, b: PacketReceiptAbsenceData | PlainMessage<PacketReceiptAbsenceData> | undefined): boolean {
return proto3.util.equals(PacketReceiptAbsenceData, a, b);
}
}
/**
* NextSequenceRecvData returns the SignBytes data for verification of the next
* sequence to be received.
*
* @generated from message ibc.lightclients.solomachine.v2.NextSequenceRecvData
*/
export class NextSequenceRecvData extends Message<NextSequenceRecvData> {
/**
* @generated from field: bytes path = 1;
*/
path = new Uint8Array(0);
/**
* @generated from field: uint64 next_seq_recv = 2;
*/
nextSeqRecv = protoInt64.zero;
constructor(data?: PartialMessage<NextSequenceRecvData>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v2.NextSequenceRecvData";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "path", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "next_seq_recv", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): NextSequenceRecvData {
return new NextSequenceRecvData().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): NextSequenceRecvData {
return new NextSequenceRecvData().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): NextSequenceRecvData {
return new NextSequenceRecvData().fromJsonString(jsonString, options);
}
static equals(a: NextSequenceRecvData | PlainMessage<NextSequenceRecvData> | undefined, b: NextSequenceRecvData | PlainMessage<NextSequenceRecvData> | undefined): boolean {
return proto3.util.equals(NextSequenceRecvData, a, b);
}
}

458
libs/es-client/src/protobufs/ibc/lightclients/solomachine/v3/solomachine_pb.ts Normal file
View File

@ -0,0 +1,458 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/lightclients/solomachine/v3/solomachine.proto (package ibc.lightclients.solomachine.v3, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Any, Message, proto3, protoInt64 } from "@bufbuild/protobuf";
/**
* ClientState defines a solo machine client that tracks the current consensus
* state and if the client is frozen.
*
* @generated from message ibc.lightclients.solomachine.v3.ClientState
*/
export class ClientState extends Message<ClientState> {
/**
* latest sequence of the client state
*
* @generated from field: uint64 sequence = 1;
*/
sequence = protoInt64.zero;
/**
* frozen sequence of the solo machine
*
* @generated from field: bool is_frozen = 2;
*/
isFrozen = false;
/**
* @generated from field: ibc.lightclients.solomachine.v3.ConsensusState consensus_state = 3;
*/
consensusState?: ConsensusState;
constructor(data?: PartialMessage<ClientState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v3.ClientState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 2, name: "is_frozen", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
{ no: 3, name: "consensus_state", kind: "message", T: ConsensusState },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ClientState {
return new ClientState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ClientState {
return new ClientState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ClientState {
return new ClientState().fromJsonString(jsonString, options);
}
static equals(a: ClientState | PlainMessage<ClientState> | undefined, b: ClientState | PlainMessage<ClientState> | undefined): boolean {
return proto3.util.equals(ClientState, a, b);
}
}
/**
* ConsensusState defines a solo machine consensus state. The sequence of a
* consensus state is contained in the "height" key used in storing the
* consensus state.
*
* @generated from message ibc.lightclients.solomachine.v3.ConsensusState
*/
export class ConsensusState extends Message<ConsensusState> {
/**
* public key of the solo machine
*
* @generated from field: google.protobuf.Any public_key = 1;
*/
publicKey?: Any;
/**
* diversifier allows the same public key to be re-used across different solo
* machine clients (potentially on different chains) without being considered
* misbehaviour.
*
* @generated from field: string diversifier = 2;
*/
diversifier = "";
/**
* @generated from field: uint64 timestamp = 3;
*/
timestamp = protoInt64.zero;
constructor(data?: PartialMessage<ConsensusState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v3.ConsensusState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "public_key", kind: "message", T: Any },
{ no: 2, name: "diversifier", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConsensusState {
return new ConsensusState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConsensusState {
return new ConsensusState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConsensusState {
return new ConsensusState().fromJsonString(jsonString, options);
}
static equals(a: ConsensusState | PlainMessage<ConsensusState> | undefined, b: ConsensusState | PlainMessage<ConsensusState> | undefined): boolean {
return proto3.util.equals(ConsensusState, a, b);
}
}
/**
* Header defines a solo machine consensus header
*
* @generated from message ibc.lightclients.solomachine.v3.Header
*/
export class Header extends Message<Header> {
/**
* @generated from field: uint64 timestamp = 1;
*/
timestamp = protoInt64.zero;
/**
* @generated from field: bytes signature = 2;
*/
signature = new Uint8Array(0);
/**
* @generated from field: google.protobuf.Any new_public_key = 3;
*/
newPublicKey?: Any;
/**
* @generated from field: string new_diversifier = 4;
*/
newDiversifier = "";
constructor(data?: PartialMessage<Header>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v3.Header";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 2, name: "signature", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 3, name: "new_public_key", kind: "message", T: Any },
{ no: 4, name: "new_diversifier", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Header {
return new Header().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Header {
return new Header().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Header {
return new Header().fromJsonString(jsonString, options);
}
static equals(a: Header | PlainMessage<Header> | undefined, b: Header | PlainMessage<Header> | undefined): boolean {
return proto3.util.equals(Header, a, b);
}
}
/**
* Misbehaviour defines misbehaviour for a solo machine which consists
* of a sequence and two signatures over different messages at that sequence.
*
* @generated from message ibc.lightclients.solomachine.v3.Misbehaviour
*/
export class Misbehaviour extends Message<Misbehaviour> {
/**
* @generated from field: uint64 sequence = 1;
*/
sequence = protoInt64.zero;
/**
* @generated from field: ibc.lightclients.solomachine.v3.SignatureAndData signature_one = 2;
*/
signatureOne?: SignatureAndData;
/**
* @generated from field: ibc.lightclients.solomachine.v3.SignatureAndData signature_two = 3;
*/
signatureTwo?: SignatureAndData;
constructor(data?: PartialMessage<Misbehaviour>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v3.Misbehaviour";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 2, name: "signature_one", kind: "message", T: SignatureAndData },
{ no: 3, name: "signature_two", kind: "message", T: SignatureAndData },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Misbehaviour {
return new Misbehaviour().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Misbehaviour {
return new Misbehaviour().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Misbehaviour {
return new Misbehaviour().fromJsonString(jsonString, options);
}
static equals(a: Misbehaviour | PlainMessage<Misbehaviour> | undefined, b: Misbehaviour | PlainMessage<Misbehaviour> | undefined): boolean {
return proto3.util.equals(Misbehaviour, a, b);
}
}
/**
* SignatureAndData contains a signature and the data signed over to create that
* signature.
*
* @generated from message ibc.lightclients.solomachine.v3.SignatureAndData
*/
export class SignatureAndData extends Message<SignatureAndData> {
/**
* @generated from field: bytes signature = 1;
*/
signature = new Uint8Array(0);
/**
* @generated from field: bytes path = 2;
*/
path = new Uint8Array(0);
/**
* @generated from field: bytes data = 3;
*/
data = new Uint8Array(0);
/**
* @generated from field: uint64 timestamp = 4;
*/
timestamp = protoInt64.zero;
constructor(data?: PartialMessage<SignatureAndData>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v3.SignatureAndData";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "signature", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "path", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 3, name: "data", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 4, name: "timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SignatureAndData {
return new SignatureAndData().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SignatureAndData {
return new SignatureAndData().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SignatureAndData {
return new SignatureAndData().fromJsonString(jsonString, options);
}
static equals(a: SignatureAndData | PlainMessage<SignatureAndData> | undefined, b: SignatureAndData | PlainMessage<SignatureAndData> | undefined): boolean {
return proto3.util.equals(SignatureAndData, a, b);
}
}
/**
* TimestampedSignatureData contains the signature data and the timestamp of the
* signature.
*
* @generated from message ibc.lightclients.solomachine.v3.TimestampedSignatureData
*/
export class TimestampedSignatureData extends Message<TimestampedSignatureData> {
/**
* @generated from field: bytes signature_data = 1;
*/
signatureData = new Uint8Array(0);
/**
* @generated from field: uint64 timestamp = 2;
*/
timestamp = protoInt64.zero;
constructor(data?: PartialMessage<TimestampedSignatureData>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v3.TimestampedSignatureData";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "signature_data", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TimestampedSignatureData {
return new TimestampedSignatureData().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TimestampedSignatureData {
return new TimestampedSignatureData().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TimestampedSignatureData {
return new TimestampedSignatureData().fromJsonString(jsonString, options);
}
static equals(a: TimestampedSignatureData | PlainMessage<TimestampedSignatureData> | undefined, b: TimestampedSignatureData | PlainMessage<TimestampedSignatureData> | undefined): boolean {
return proto3.util.equals(TimestampedSignatureData, a, b);
}
}
/**
* SignBytes defines the signed bytes used for signature verification.
*
* @generated from message ibc.lightclients.solomachine.v3.SignBytes
*/
export class SignBytes extends Message<SignBytes> {
/**
* the sequence number
*
* @generated from field: uint64 sequence = 1;
*/
sequence = protoInt64.zero;
/**
* the proof timestamp
*
* @generated from field: uint64 timestamp = 2;
*/
timestamp = protoInt64.zero;
/**
* the public key diversifier
*
* @generated from field: string diversifier = 3;
*/
diversifier = "";
/**
* the standardised path bytes
*
* @generated from field: bytes path = 4;
*/
path = new Uint8Array(0);
/**
* the marshaled data bytes
*
* @generated from field: bytes data = 5;
*/
data = new Uint8Array(0);
constructor(data?: PartialMessage<SignBytes>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v3.SignBytes";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "sequence", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 2, name: "timestamp", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 3, name: "diversifier", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "path", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 5, name: "data", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SignBytes {
return new SignBytes().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SignBytes {
return new SignBytes().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SignBytes {
return new SignBytes().fromJsonString(jsonString, options);
}
static equals(a: SignBytes | PlainMessage<SignBytes> | undefined, b: SignBytes | PlainMessage<SignBytes> | undefined): boolean {
return proto3.util.equals(SignBytes, a, b);
}
}
/**
* HeaderData returns the SignBytes data for update verification.
*
* @generated from message ibc.lightclients.solomachine.v3.HeaderData
*/
export class HeaderData extends Message<HeaderData> {
/**
* header public key
*
* @generated from field: google.protobuf.Any new_pub_key = 1;
*/
newPubKey?: Any;
/**
* header diversifier
*
* @generated from field: string new_diversifier = 2;
*/
newDiversifier = "";
constructor(data?: PartialMessage<HeaderData>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.solomachine.v3.HeaderData";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "new_pub_key", kind: "message", T: Any },
{ no: 2, name: "new_diversifier", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HeaderData {
return new HeaderData().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HeaderData {
return new HeaderData().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HeaderData {
return new HeaderData().fromJsonString(jsonString, options);
}
static equals(a: HeaderData | PlainMessage<HeaderData> | undefined, b: HeaderData | PlainMessage<HeaderData> | undefined): boolean {
return proto3.util.equals(HeaderData, a, b);
}
}

365
libs/es-client/src/protobufs/ibc/lightclients/tendermint/v1/tendermint_pb.ts Normal file
View File

@ -0,0 +1,365 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/lightclients/tendermint/v1/tendermint.proto (package ibc.lightclients.tendermint.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Duration, Message, proto3, protoInt64, Timestamp } from "@bufbuild/protobuf";
import { Height } from "../../../core/client/v1/client_pb.js";
import { ProofSpec } from "../../../../cosmos/ics23/v1/proofs_pb.js";
import { MerkleRoot } from "../../../core/commitment/v1/commitment_pb.js";
import { SignedHeader } from "../../../../cometbft/types/v1/types_pb.js";
import { ValidatorSet } from "../../../../cometbft/types/v1/validator_pb.js";
/**
* ClientState from Tendermint tracks the current validator set, latest height,
* and a possible frozen height.
*
* @generated from message ibc.lightclients.tendermint.v1.ClientState
*/
export class ClientState extends Message<ClientState> {
/**
* @generated from field: string chain_id = 1;
*/
chainId = "";
/**
* @generated from field: ibc.lightclients.tendermint.v1.Fraction trust_level = 2;
*/
trustLevel?: Fraction;
/**
* duration of the period since the LatestTimestamp during which the
* submitted headers are valid for upgrade
*
* @generated from field: google.protobuf.Duration trusting_period = 3;
*/
trustingPeriod?: Duration;
/**
* duration of the staking unbonding period
*
* @generated from field: google.protobuf.Duration unbonding_period = 4;
*/
unbondingPeriod?: Duration;
/**
* defines how much new (untrusted) header's Time can drift into the future.
*
* @generated from field: google.protobuf.Duration max_clock_drift = 5;
*/
maxClockDrift?: Duration;
/**
* Block height when the client was frozen due to a misbehaviour
*
* @generated from field: ibc.core.client.v1.Height frozen_height = 6;
*/
frozenHeight?: Height;
/**
* Latest height the client was updated to
*
* @generated from field: ibc.core.client.v1.Height latest_height = 7;
*/
latestHeight?: Height;
/**
* Proof specifications used in verifying counterparty state
*
* @generated from field: repeated cosmos.ics23.v1.ProofSpec proof_specs = 8;
*/
proofSpecs: ProofSpec[] = [];
/**
* Path at which next upgraded client will be committed.
* Each element corresponds to the key for a single CommitmentProof in the
* chained proof. NOTE: ClientState must stored under
* `{upgradePath}/{upgradeHeight}/clientState` ConsensusState must be stored
* under `{upgradepath}/{upgradeHeight}/consensusState` For SDK chains using
* the default upgrade module, upgrade_path should be []string{"upgrade",
* "upgradedIBCState"}`
*
* @generated from field: repeated string upgrade_path = 9;
*/
upgradePath: string[] = [];
/**
* allow_update_after_expiry is deprecated
*
* @generated from field: bool allow_update_after_expiry = 10 [deprecated = true];
* @deprecated
*/
allowUpdateAfterExpiry = false;
/**
* allow_update_after_misbehaviour is deprecated
*
* @generated from field: bool allow_update_after_misbehaviour = 11 [deprecated = true];
* @deprecated
*/
allowUpdateAfterMisbehaviour = false;
constructor(data?: PartialMessage<ClientState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.tendermint.v1.ClientState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "chain_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "trust_level", kind: "message", T: Fraction },
{ no: 3, name: "trusting_period", kind: "message", T: Duration },
{ no: 4, name: "unbonding_period", kind: "message", T: Duration },
{ no: 5, name: "max_clock_drift", kind: "message", T: Duration },
{ no: 6, name: "frozen_height", kind: "message", T: Height },
{ no: 7, name: "latest_height", kind: "message", T: Height },
{ no: 8, name: "proof_specs", kind: "message", T: ProofSpec, repeated: true },
{ no: 9, name: "upgrade_path", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
{ no: 10, name: "allow_update_after_expiry", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
{ no: 11, name: "allow_update_after_misbehaviour", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ClientState {
return new ClientState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ClientState {
return new ClientState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ClientState {
return new ClientState().fromJsonString(jsonString, options);
}
static equals(a: ClientState | PlainMessage<ClientState> | undefined, b: ClientState | PlainMessage<ClientState> | undefined): boolean {
return proto3.util.equals(ClientState, a, b);
}
}
/**
* ConsensusState defines the consensus state from Tendermint.
*
* @generated from message ibc.lightclients.tendermint.v1.ConsensusState
*/
export class ConsensusState extends Message<ConsensusState> {
/**
* timestamp that corresponds to the block height in which the ConsensusState
* was stored.
*
* @generated from field: google.protobuf.Timestamp timestamp = 1;
*/
timestamp?: Timestamp;
/**
* commitment root (i.e app hash)
*
* @generated from field: ibc.core.commitment.v1.MerkleRoot root = 2;
*/
root?: MerkleRoot;
/**
* @generated from field: bytes next_validators_hash = 3;
*/
nextValidatorsHash = new Uint8Array(0);
constructor(data?: PartialMessage<ConsensusState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.tendermint.v1.ConsensusState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "timestamp", kind: "message", T: Timestamp },
{ no: 2, name: "root", kind: "message", T: MerkleRoot },
{ no: 3, name: "next_validators_hash", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConsensusState {
return new ConsensusState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConsensusState {
return new ConsensusState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConsensusState {
return new ConsensusState().fromJsonString(jsonString, options);
}
static equals(a: ConsensusState | PlainMessage<ConsensusState> | undefined, b: ConsensusState | PlainMessage<ConsensusState> | undefined): boolean {
return proto3.util.equals(ConsensusState, a, b);
}
}
/**
* Misbehaviour is a wrapper over two conflicting Headers
* that implements Misbehaviour interface expected by ICS-02
*
* @generated from message ibc.lightclients.tendermint.v1.Misbehaviour
*/
export class Misbehaviour extends Message<Misbehaviour> {
/**
* ClientID is deprecated
*
* @generated from field: string client_id = 1 [deprecated = true];
* @deprecated
*/
clientId = "";
/**
* @generated from field: ibc.lightclients.tendermint.v1.Header header_1 = 2;
*/
header1?: Header;
/**
* @generated from field: ibc.lightclients.tendermint.v1.Header header_2 = 3;
*/
header2?: Header;
constructor(data?: PartialMessage<Misbehaviour>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.tendermint.v1.Misbehaviour";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "header_1", kind: "message", T: Header },
{ no: 3, name: "header_2", kind: "message", T: Header },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Misbehaviour {
return new Misbehaviour().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Misbehaviour {
return new Misbehaviour().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Misbehaviour {
return new Misbehaviour().fromJsonString(jsonString, options);
}
static equals(a: Misbehaviour | PlainMessage<Misbehaviour> | undefined, b: Misbehaviour | PlainMessage<Misbehaviour> | undefined): boolean {
return proto3.util.equals(Misbehaviour, a, b);
}
}
/**
* Header defines the Tendermint client consensus Header.
* It encapsulates all the information necessary to update from a trusted
* Tendermint ConsensusState. The inclusion of TrustedHeight and
* TrustedValidators allows this update to process correctly, so long as the
* ConsensusState for the TrustedHeight exists, this removes race conditions
* among relayers The SignedHeader and ValidatorSet are the new untrusted update
* fields for the client. The TrustedHeight is the height of a stored
* ConsensusState on the client that will be used to verify the new untrusted
* header. The Trusted ConsensusState must be within the unbonding period of
* current time in order to correctly verify, and the TrustedValidators must
* hash to TrustedConsensusState.NextValidatorsHash since that is the last
* trusted validator set at the TrustedHeight.
*
* @generated from message ibc.lightclients.tendermint.v1.Header
*/
export class Header extends Message<Header> {
/**
* @generated from field: cometbft.types.v1.SignedHeader signed_header = 1;
*/
signedHeader?: SignedHeader;
/**
* @generated from field: cometbft.types.v1.ValidatorSet validator_set = 2;
*/
validatorSet?: ValidatorSet;
/**
* @generated from field: ibc.core.client.v1.Height trusted_height = 3;
*/
trustedHeight?: Height;
/**
* @generated from field: cometbft.types.v1.ValidatorSet trusted_validators = 4;
*/
trustedValidators?: ValidatorSet;
constructor(data?: PartialMessage<Header>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.tendermint.v1.Header";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "signed_header", kind: "message", T: SignedHeader },
{ no: 2, name: "validator_set", kind: "message", T: ValidatorSet },
{ no: 3, name: "trusted_height", kind: "message", T: Height },
{ no: 4, name: "trusted_validators", kind: "message", T: ValidatorSet },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Header {
return new Header().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Header {
return new Header().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Header {
return new Header().fromJsonString(jsonString, options);
}
static equals(a: Header | PlainMessage<Header> | undefined, b: Header | PlainMessage<Header> | undefined): boolean {
return proto3.util.equals(Header, a, b);
}
}
/**
* Fraction defines the protobuf message type for tmmath.Fraction that only
* supports positive values.
*
* @generated from message ibc.lightclients.tendermint.v1.Fraction
*/
export class Fraction extends Message<Fraction> {
/**
* @generated from field: uint64 numerator = 1;
*/
numerator = protoInt64.zero;
/**
* @generated from field: uint64 denominator = 2;
*/
denominator = protoInt64.zero;
constructor(data?: PartialMessage<Fraction>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.tendermint.v1.Fraction";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "numerator", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
{ no: 2, name: "denominator", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Fraction {
return new Fraction().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Fraction {
return new Fraction().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Fraction {
return new Fraction().fromJsonString(jsonString, options);
}
static equals(a: Fraction | PlainMessage<Fraction> | undefined, b: Fraction | PlainMessage<Fraction> | undefined): boolean {
return proto3.util.equals(Fraction, a, b);
}
}

90
libs/es-client/src/protobufs/ibc/lightclients/wasm/v1/genesis_pb.ts Normal file
View File

@ -0,0 +1,90 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/lightclients/wasm/v1/genesis.proto (package ibc.lightclients.wasm.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
/**
* GenesisState defines 08-wasm's keeper genesis state
*
* @generated from message ibc.lightclients.wasm.v1.GenesisState
*/
export class GenesisState extends Message<GenesisState> {
/**
* uploaded light client wasm contracts
*
* @generated from field: repeated ibc.lightclients.wasm.v1.Contract contracts = 1;
*/
contracts: Contract[] = [];
constructor(data?: PartialMessage<GenesisState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.wasm.v1.GenesisState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "contracts", kind: "message", T: Contract, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GenesisState {
return new GenesisState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJsonString(jsonString, options);
}
static equals(a: GenesisState | PlainMessage<GenesisState> | undefined, b: GenesisState | PlainMessage<GenesisState> | undefined): boolean {
return proto3.util.equals(GenesisState, a, b);
}
}
/**
* Contract stores contract code
*
* @generated from message ibc.lightclients.wasm.v1.Contract
*/
export class Contract extends Message<Contract> {
/**
* contract byte code
*
* @generated from field: bytes code_bytes = 1;
*/
codeBytes = new Uint8Array(0);
constructor(data?: PartialMessage<Contract>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.wasm.v1.Contract";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "code_bytes", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Contract {
return new Contract().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Contract {
return new Contract().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Contract {
return new Contract().fromJsonString(jsonString, options);
}
static equals(a: Contract | PlainMessage<Contract> | undefined, b: Contract | PlainMessage<Contract> | undefined): boolean {
return proto3.util.equals(Contract, a, b);
}
}

33
libs/es-client/src/protobufs/ibc/lightclients/wasm/v1/query_cosmes.ts Normal file
View File

@ -0,0 +1,33 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file ibc/lightclients/wasm/v1/query.proto (package ibc.lightclients.wasm.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { QueryChecksumsRequest, QueryChecksumsResponse, QueryCodeRequest, QueryCodeResponse } from "./query_pb.js";
const TYPE_NAME = "ibc.lightclients.wasm.v1.Query";
/**
* Get all Wasm checksums
*
* @generated from rpc ibc.lightclients.wasm.v1.Query.Checksums
*/
export const QueryChecksumsService = {
typeName: TYPE_NAME,
method: "Checksums",
Request: QueryChecksumsRequest,
Response: QueryChecksumsResponse,
} as const;
/**
* Get Wasm code for given checksum
*
* @generated from rpc ibc.lightclients.wasm.v1.Query.Code
*/
export const QueryCodeService = {
typeName: TYPE_NAME,
method: "Code",
Request: QueryCodeRequest,
Response: QueryCodeResponse,
} as const;

179
libs/es-client/src/protobufs/ibc/lightclients/wasm/v1/query_pb.ts Normal file
View File

@ -0,0 +1,179 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/lightclients/wasm/v1/query.proto (package ibc.lightclients.wasm.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { PageRequest, PageResponse } from "../../../../cosmos/base/query/v1beta1/pagination_pb.js";
/**
* QueryChecksumsRequest is the request type for the Query/Checksums RPC method.
*
* @generated from message ibc.lightclients.wasm.v1.QueryChecksumsRequest
*/
export class QueryChecksumsRequest extends Message<QueryChecksumsRequest> {
/**
* pagination defines an optional pagination for the request.
*
* @generated from field: cosmos.base.query.v1beta1.PageRequest pagination = 1;
*/
pagination?: PageRequest;
constructor(data?: PartialMessage<QueryChecksumsRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.wasm.v1.QueryChecksumsRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "pagination", kind: "message", T: PageRequest },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryChecksumsRequest {
return new QueryChecksumsRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryChecksumsRequest {
return new QueryChecksumsRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryChecksumsRequest {
return new QueryChecksumsRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryChecksumsRequest | PlainMessage<QueryChecksumsRequest> | undefined, b: QueryChecksumsRequest | PlainMessage<QueryChecksumsRequest> | undefined): boolean {
return proto3.util.equals(QueryChecksumsRequest, a, b);
}
}
/**
* QueryChecksumsResponse is the response type for the Query/Checksums RPC method.
*
* @generated from message ibc.lightclients.wasm.v1.QueryChecksumsResponse
*/
export class QueryChecksumsResponse extends Message<QueryChecksumsResponse> {
/**
* checksums is a list of the hex encoded checksums of all wasm codes stored.
*
* @generated from field: repeated string checksums = 1;
*/
checksums: string[] = [];
/**
* pagination defines the pagination in the response.
*
* @generated from field: cosmos.base.query.v1beta1.PageResponse pagination = 2;
*/
pagination?: PageResponse;
constructor(data?: PartialMessage<QueryChecksumsResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.wasm.v1.QueryChecksumsResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "checksums", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
{ no: 2, name: "pagination", kind: "message", T: PageResponse },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryChecksumsResponse {
return new QueryChecksumsResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryChecksumsResponse {
return new QueryChecksumsResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryChecksumsResponse {
return new QueryChecksumsResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryChecksumsResponse | PlainMessage<QueryChecksumsResponse> | undefined, b: QueryChecksumsResponse | PlainMessage<QueryChecksumsResponse> | undefined): boolean {
return proto3.util.equals(QueryChecksumsResponse, a, b);
}
}
/**
* QueryCodeRequest is the request type for the Query/Code RPC method.
*
* @generated from message ibc.lightclients.wasm.v1.QueryCodeRequest
*/
export class QueryCodeRequest extends Message<QueryCodeRequest> {
/**
* checksum is a hex encoded string of the code stored.
*
* @generated from field: string checksum = 1;
*/
checksum = "";
constructor(data?: PartialMessage<QueryCodeRequest>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.wasm.v1.QueryCodeRequest";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "checksum", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryCodeRequest {
return new QueryCodeRequest().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryCodeRequest {
return new QueryCodeRequest().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryCodeRequest {
return new QueryCodeRequest().fromJsonString(jsonString, options);
}
static equals(a: QueryCodeRequest | PlainMessage<QueryCodeRequest> | undefined, b: QueryCodeRequest | PlainMessage<QueryCodeRequest> | undefined): boolean {
return proto3.util.equals(QueryCodeRequest, a, b);
}
}
/**
* QueryCodeResponse is the response type for the Query/Code RPC method.
*
* @generated from message ibc.lightclients.wasm.v1.QueryCodeResponse
*/
export class QueryCodeResponse extends Message<QueryCodeResponse> {
/**
* @generated from field: bytes data = 1;
*/
data = new Uint8Array(0);
constructor(data?: PartialMessage<QueryCodeResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.wasm.v1.QueryCodeResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "data", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryCodeResponse {
return new QueryCodeResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryCodeResponse {
return new QueryCodeResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryCodeResponse {
return new QueryCodeResponse().fromJsonString(jsonString, options);
}
static equals(a: QueryCodeResponse | PlainMessage<QueryCodeResponse> | undefined, b: QueryCodeResponse | PlainMessage<QueryCodeResponse> | undefined): boolean {
return proto3.util.equals(QueryCodeResponse, a, b);
}
}

45
libs/es-client/src/protobufs/ibc/lightclients/wasm/v1/tx_cosmes.ts Normal file
View File

@ -0,0 +1,45 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file ibc/lightclients/wasm/v1/tx.proto (package ibc.lightclients.wasm.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { MsgMigrateContract, MsgMigrateContractResponse, MsgRemoveChecksum, MsgRemoveChecksumResponse, MsgStoreCode, MsgStoreCodeResponse } from "./tx_pb.js";
const TYPE_NAME = "ibc.lightclients.wasm.v1.Msg";
/**
* StoreCode defines a rpc handler method for MsgStoreCode.
*
* @generated from rpc ibc.lightclients.wasm.v1.Msg.StoreCode
*/
export const MsgStoreCodeService = {
typeName: TYPE_NAME,
method: "StoreCode",
Request: MsgStoreCode,
Response: MsgStoreCodeResponse,
} as const;
/**
* RemoveChecksum defines a rpc handler method for MsgRemoveChecksum.
*
* @generated from rpc ibc.lightclients.wasm.v1.Msg.RemoveChecksum
*/
export const MsgRemoveChecksumService = {
typeName: TYPE_NAME,
method: "RemoveChecksum",
Request: MsgRemoveChecksum,
Response: MsgRemoveChecksumResponse,
} as const;
/**
* MigrateContract defines a rpc handler method for MsgMigrateContract.
*
* @generated from rpc ibc.lightclients.wasm.v1.Msg.MigrateContract
*/
export const MsgMigrateContractService = {
typeName: TYPE_NAME,
method: "MigrateContract",
Request: MsgMigrateContract,
Response: MsgMigrateContractResponse,
} as const;

278
libs/es-client/src/protobufs/ibc/lightclients/wasm/v1/tx_pb.ts Normal file
View File

@ -0,0 +1,278 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/lightclients/wasm/v1/tx.proto (package ibc.lightclients.wasm.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
/**
* MsgStoreCode defines the request type for the StoreCode rpc.
*
* @generated from message ibc.lightclients.wasm.v1.MsgStoreCode
*/
export class MsgStoreCode extends Message<MsgStoreCode> {
/**
* signer address
*
* @generated from field: string signer = 1;
*/
signer = "";
/**
* wasm byte code of light client contract. It can be raw or gzip compressed
*
* @generated from field: bytes wasm_byte_code = 2;
*/
wasmByteCode = new Uint8Array(0);
constructor(data?: PartialMessage<MsgStoreCode>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.wasm.v1.MsgStoreCode";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "signer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "wasm_byte_code", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgStoreCode {
return new MsgStoreCode().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgStoreCode {
return new MsgStoreCode().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgStoreCode {
return new MsgStoreCode().fromJsonString(jsonString, options);
}
static equals(a: MsgStoreCode | PlainMessage<MsgStoreCode> | undefined, b: MsgStoreCode | PlainMessage<MsgStoreCode> | undefined): boolean {
return proto3.util.equals(MsgStoreCode, a, b);
}
}
/**
* MsgStoreCodeResponse defines the response type for the StoreCode rpc
*
* @generated from message ibc.lightclients.wasm.v1.MsgStoreCodeResponse
*/
export class MsgStoreCodeResponse extends Message<MsgStoreCodeResponse> {
/**
* checksum is the sha256 hash of the stored code
*
* @generated from field: bytes checksum = 1;
*/
checksum = new Uint8Array(0);
constructor(data?: PartialMessage<MsgStoreCodeResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.wasm.v1.MsgStoreCodeResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "checksum", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgStoreCodeResponse {
return new MsgStoreCodeResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgStoreCodeResponse {
return new MsgStoreCodeResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgStoreCodeResponse {
return new MsgStoreCodeResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgStoreCodeResponse | PlainMessage<MsgStoreCodeResponse> | undefined, b: MsgStoreCodeResponse | PlainMessage<MsgStoreCodeResponse> | undefined): boolean {
return proto3.util.equals(MsgStoreCodeResponse, a, b);
}
}
/**
* MsgRemoveChecksum defines the request type for the MsgRemoveChecksum rpc.
*
* @generated from message ibc.lightclients.wasm.v1.MsgRemoveChecksum
*/
export class MsgRemoveChecksum extends Message<MsgRemoveChecksum> {
/**
* signer address
*
* @generated from field: string signer = 1;
*/
signer = "";
/**
* checksum is the sha256 hash to be removed from the store
*
* @generated from field: bytes checksum = 2;
*/
checksum = new Uint8Array(0);
constructor(data?: PartialMessage<MsgRemoveChecksum>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.wasm.v1.MsgRemoveChecksum";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "signer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "checksum", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgRemoveChecksum {
return new MsgRemoveChecksum().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgRemoveChecksum {
return new MsgRemoveChecksum().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgRemoveChecksum {
return new MsgRemoveChecksum().fromJsonString(jsonString, options);
}
static equals(a: MsgRemoveChecksum | PlainMessage<MsgRemoveChecksum> | undefined, b: MsgRemoveChecksum | PlainMessage<MsgRemoveChecksum> | undefined): boolean {
return proto3.util.equals(MsgRemoveChecksum, a, b);
}
}
/**
* MsgStoreChecksumResponse defines the response type for the StoreCode rpc
*
* @generated from message ibc.lightclients.wasm.v1.MsgRemoveChecksumResponse
*/
export class MsgRemoveChecksumResponse extends Message<MsgRemoveChecksumResponse> {
constructor(data?: PartialMessage<MsgRemoveChecksumResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.wasm.v1.MsgRemoveChecksumResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgRemoveChecksumResponse {
return new MsgRemoveChecksumResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgRemoveChecksumResponse {
return new MsgRemoveChecksumResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgRemoveChecksumResponse {
return new MsgRemoveChecksumResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgRemoveChecksumResponse | PlainMessage<MsgRemoveChecksumResponse> | undefined, b: MsgRemoveChecksumResponse | PlainMessage<MsgRemoveChecksumResponse> | undefined): boolean {
return proto3.util.equals(MsgRemoveChecksumResponse, a, b);
}
}
/**
* MsgMigrateContract defines the request type for the MigrateContract rpc.
*
* @generated from message ibc.lightclients.wasm.v1.MsgMigrateContract
*/
export class MsgMigrateContract extends Message<MsgMigrateContract> {
/**
* signer address
*
* @generated from field: string signer = 1;
*/
signer = "";
/**
* the client id of the contract
*
* @generated from field: string client_id = 2;
*/
clientId = "";
/**
* checksum is the sha256 hash of the new wasm byte code for the contract
*
* @generated from field: bytes checksum = 3;
*/
checksum = new Uint8Array(0);
/**
* the json encoded message to be passed to the contract on migration
*
* @generated from field: bytes msg = 4;
*/
msg = new Uint8Array(0);
constructor(data?: PartialMessage<MsgMigrateContract>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.wasm.v1.MsgMigrateContract";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "signer", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "checksum", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 4, name: "msg", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgMigrateContract {
return new MsgMigrateContract().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgMigrateContract {
return new MsgMigrateContract().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgMigrateContract {
return new MsgMigrateContract().fromJsonString(jsonString, options);
}
static equals(a: MsgMigrateContract | PlainMessage<MsgMigrateContract> | undefined, b: MsgMigrateContract | PlainMessage<MsgMigrateContract> | undefined): boolean {
return proto3.util.equals(MsgMigrateContract, a, b);
}
}
/**
* MsgMigrateContractResponse defines the response type for the MigrateContract rpc
*
* @generated from message ibc.lightclients.wasm.v1.MsgMigrateContractResponse
*/
export class MsgMigrateContractResponse extends Message<MsgMigrateContractResponse> {
constructor(data?: PartialMessage<MsgMigrateContractResponse>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.wasm.v1.MsgMigrateContractResponse";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MsgMigrateContractResponse {
return new MsgMigrateContractResponse().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MsgMigrateContractResponse {
return new MsgMigrateContractResponse().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MsgMigrateContractResponse {
return new MsgMigrateContractResponse().fromJsonString(jsonString, options);
}
static equals(a: MsgMigrateContractResponse | PlainMessage<MsgMigrateContractResponse> | undefined, b: MsgMigrateContractResponse | PlainMessage<MsgMigrateContractResponse> | undefined): boolean {
return proto3.util.equals(MsgMigrateContractResponse, a, b);
}
}

187
libs/es-client/src/protobufs/ibc/lightclients/wasm/v1/wasm_pb.ts Normal file
View File

@ -0,0 +1,187 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file ibc/lightclients/wasm/v1/wasm.proto (package ibc.lightclients.wasm.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { Height } from "../../../core/client/v1/client_pb.js";
/**
* Wasm light client's Client state
*
* @generated from message ibc.lightclients.wasm.v1.ClientState
*/
export class ClientState extends Message<ClientState> {
/**
* bytes encoding the client state of the underlying light client
* implemented as a Wasm contract.
*
* @generated from field: bytes data = 1;
*/
data = new Uint8Array(0);
/**
* @generated from field: bytes checksum = 2;
*/
checksum = new Uint8Array(0);
/**
* @generated from field: ibc.core.client.v1.Height latest_height = 3;
*/
latestHeight?: Height;
constructor(data?: PartialMessage<ClientState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.wasm.v1.ClientState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "data", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 2, name: "checksum", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
{ no: 3, name: "latest_height", kind: "message", T: Height },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ClientState {
return new ClientState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ClientState {
return new ClientState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ClientState {
return new ClientState().fromJsonString(jsonString, options);
}
static equals(a: ClientState | PlainMessage<ClientState> | undefined, b: ClientState | PlainMessage<ClientState> | undefined): boolean {
return proto3.util.equals(ClientState, a, b);
}
}
/**
* Wasm light client's ConsensusState
*
* @generated from message ibc.lightclients.wasm.v1.ConsensusState
*/
export class ConsensusState extends Message<ConsensusState> {
/**
* bytes encoding the consensus state of the underlying light client
* implemented as a Wasm contract.
*
* @generated from field: bytes data = 1;
*/
data = new Uint8Array(0);
constructor(data?: PartialMessage<ConsensusState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.wasm.v1.ConsensusState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "data", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConsensusState {
return new ConsensusState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConsensusState {
return new ConsensusState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConsensusState {
return new ConsensusState().fromJsonString(jsonString, options);
}
static equals(a: ConsensusState | PlainMessage<ConsensusState> | undefined, b: ConsensusState | PlainMessage<ConsensusState> | undefined): boolean {
return proto3.util.equals(ConsensusState, a, b);
}
}
/**
* Wasm light client message (either header(s) or misbehaviour)
*
* @generated from message ibc.lightclients.wasm.v1.ClientMessage
*/
export class ClientMessage extends Message<ClientMessage> {
/**
* @generated from field: bytes data = 1;
*/
data = new Uint8Array(0);
constructor(data?: PartialMessage<ClientMessage>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.wasm.v1.ClientMessage";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "data", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ClientMessage {
return new ClientMessage().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ClientMessage {
return new ClientMessage().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ClientMessage {
return new ClientMessage().fromJsonString(jsonString, options);
}
static equals(a: ClientMessage | PlainMessage<ClientMessage> | undefined, b: ClientMessage | PlainMessage<ClientMessage> | undefined): boolean {
return proto3.util.equals(ClientMessage, a, b);
}
}
/**
* Checksums defines a list of all checksums that are stored
*
* Deprecated: This message is deprecated in favor of storing the checksums
* using a Collections.KeySet.
*
* @generated from message ibc.lightclients.wasm.v1.Checksums
* @deprecated
*/
export class Checksums extends Message<Checksums> {
/**
* @generated from field: repeated bytes checksums = 1;
*/
checksums: Uint8Array[] = [];
constructor(data?: PartialMessage<Checksums>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "ibc.lightclients.wasm.v1.Checksums";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "checksums", kind: "scalar", T: 12 /* ScalarType.BYTES */, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Checksums {
return new Checksums().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Checksums {
return new Checksums().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Checksums {
return new Checksums().fromJsonString(jsonString, options);
}
static equals(a: Checksums | PlainMessage<Checksums> | undefined, b: Checksums | PlainMessage<Checksums> | undefined): boolean {
return proto3.util.equals(Checksums, a, b);
}
}

1288
libs/es-client/src/protobufs/index.ts
View File

File diff suppressed because it is too large Load Diff

42
libs/es-client/src/protobufs/svc/module/v1/module_pb.ts Normal file
View File

@ -0,0 +1,42 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file svc/module/v1/module.proto (package svc.module.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
/**
* Module is the app config object of the module.
* Learn more: https://docs.cosmos.network/main/building-modules/depinject
*
* @generated from message svc.module.v1.Module
*/
export class Module extends Message<Module> {
constructor(data?: PartialMessage<Module>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "svc.module.v1.Module";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Module {
return new Module().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Module {
return new Module().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Module {
return new Module().fromJsonString(jsonString, options);
}
static equals(a: Module | PlainMessage<Module> | undefined, b: Module | PlainMessage<Module> | undefined): boolean {
return proto3.util.equals(Module, a, b);
}
}

316
libs/es-client/src/protobufs/svc/v1/genesis_pb.ts Normal file
View File

@ -0,0 +1,316 @@
// @generated by protoc-gen-es v1.2.0 with parameter "target=ts"
// @generated from file svc/v1/genesis.proto (package svc.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, protoInt64 } from "@bufbuild/protobuf";
/**
* GenesisState defines the module genesis state
*
* @generated from message svc.v1.GenesisState
*/
export class GenesisState extends Message<GenesisState> {
/**
* Params defines all the parameters of the module.
*
* @generated from field: svc.v1.Params params = 1;
*/
params?: Params;
constructor(data?: PartialMessage<GenesisState>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "svc.v1.GenesisState";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "params", kind: "message", T: Params },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GenesisState {
return new GenesisState().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GenesisState {
return new GenesisState().fromJsonString(jsonString, options);
}
static equals(a: GenesisState | PlainMessage<GenesisState> | undefined, b: GenesisState | PlainMessage<GenesisState> | undefined): boolean {
return proto3.util.equals(GenesisState, a, b);
}
}
/**
* Params defines the set of module parameters.
*
* @generated from message svc.v1.Params
*/
export class Params extends Message<Params> {
/**
* @generated from field: repeated svc.v1.Attenuation attenuations = 1;
*/
attenuations: Attenuation[] = [];
constructor(data?: PartialMessage<Params>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "svc.v1.Params";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "attenuations", kind: "message", T: Attenuation, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Params {
return new Params().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Params {
return new Params().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Params {
return new Params().fromJsonString(jsonString, options);
}
static equals(a: Params | PlainMessage<Params> | undefined, b: Params | PlainMessage<Params> | undefined): boolean {
return proto3.util.equals(Params, a, b);
}
}
/**
* Attenuation defines the attenuation of a resource
*
* @generated from message svc.v1.Attenuation
*/
export class Attenuation extends Message<Attenuation> {
/**
* @generated from field: svc.v1.Resource resource = 1;
*/
resource?: Resource;
/**
* @generated from field: repeated svc.v1.Capability capabilities = 2;
*/
capabilities: Capability[] = [];
constructor(data?: PartialMessage<Attenuation>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "svc.v1.Attenuation";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "resource", kind: "message", T: Resource },
{ no: 2, name: "capabilities", kind: "message", T: Capability, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Attenuation {
return new Attenuation().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Attenuation {
return new Attenuation().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Attenuation {
return new Attenuation().fromJsonString(jsonString, options);
}
static equals(a: Attenuation | PlainMessage<Attenuation> | undefined, b: Attenuation | PlainMessage<Attenuation> | undefined): boolean {
return proto3.util.equals(Attenuation, a, b);
}
}
/**
* Capability reprensents the available capabilities of a decentralized web node
*
* @generated from message svc.v1.Capability
*/
export class Capability extends Message<Capability> {
/**
* @generated from field: string name = 1;
*/
name = "";
/**
* @generated from field: string parent = 2;
*/
parent = "";
/**
* @generated from field: string description = 3;
*/
description = "";
/**
* @generated from field: repeated string resources = 4;
*/
resources: string[] = [];
constructor(data?: PartialMessage<Capability>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "svc.v1.Capability";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "parent", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "description", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 4, name: "resources", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Capability {
return new Capability().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Capability {
return new Capability().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Capability {
return new Capability().fromJsonString(jsonString, options);
}
static equals(a: Capability | PlainMessage<Capability> | undefined, b: Capability | PlainMessage<Capability> | undefined): boolean {
return proto3.util.equals(Capability, a, b);
}
}
/**
* Resource reprensents the available resources of a decentralized web node
*
* @generated from message svc.v1.Resource
*/
export class Resource extends Message<Resource> {
/**
* @generated from field: string kind = 1;
*/
kind = "";
/**
* @generated from field: string template = 2;
*/
template = "";
constructor(data?: PartialMessage<Resource>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "svc.v1.Resource";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "kind", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "template", kind: "scalar", T: 9 /* ScalarType.STRING */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Resource {
return new Resource().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Resource {
return new Resource().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Resource {
return new Resource().fromJsonString(jsonString, options);
}
static equals(a: Resource | PlainMessage<Resource> | undefined, b: Resource | PlainMessage<Resource> | undefined): boolean {
return proto3.util.equals(Resource, a, b);
}
}
/**
* Service defines a Decentralized Service on the Sonr Blockchain
*
* @generated from message svc.v1.Service
*/
export class Service extends Message<Service> {
/**
* @generated from field: string id = 1;
*/
id = "";
/**
* @generated from field: string authority = 2;
*/
authority = "";
/**
* @generated from field: repeated string origins = 3;
*/
origins: string[] = [];
/**
* @generated from field: string name = 4;
*/
name = "";
/**
* @generated from field: string description = 5;
*/
description = "";
/**
* @generated from field: repeated svc.v1.Attenuation attenuations = 6;
*/
attenuations: Attenuation[] = [];
/**
* @generated from field: repeated string tags = 7;
*/
tags: string[] = [];
/**
* @generated from field: int64 expiry_height = 8;
*/
expiryHeight = protoInt64.zero;
constructor(data?: PartialMessage<Service>) {
super();
proto3.util.initPartial(data, this);
}
static readonly runtime: typeof proto3 = proto3;
static readonly typeName = "svc.v1.Service";
static readonly fields: FieldList = proto3.util.newFieldList(() => [
{ no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 2, name: "authority", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 3, name: "origins", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
{ no: 4, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 5, name: "description", kind: "scalar", T: 9 /* ScalarType.STRING */ },
{ no: 6, name: "attenuations", kind: "message", T: Attenuation, repeated: true },
{ no: 7, name: "tags", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
{ no: 8, name: "expiry_height", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
]);
static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Service {
return new Service().fromBinary(bytes, options);
}
static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Service {
return new Service().fromJson(jsonValue, options);
}
static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Service {
return new Service().fromJsonString(jsonString, options);
}
static equals(a: Service | PlainMessage<Service> | undefined, b: Service | PlainMessage<Service> | undefined): boolean {
return proto3.util.equals(Service, a, b);
}
}

45
libs/es-client/src/protobufs/svc/v1/query_cosmes.ts Normal file
View File

@ -0,0 +1,45 @@
// @generated by protoc-gen-cosmes v0.0.1 with parameter "target=ts"
// @generated from file svc/v1/query.proto (package svc.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck
import { QueryOriginExistsRequest, QueryOriginExistsResponse, QueryParamsRequest, QueryParamsResponse, QueryResolveOriginRequest, QueryResolveOriginResponse } from "./query_pb.js";
const TYPE_NAME = "svc.v1.Query";
/**
* Params queries all parameters of the module.
*
* @generated from rpc svc.v1.Query.Params
*/
export const QueryParamsService = {
typeName: TYPE_NAME,
method: "Params",
Request: QueryParamsRequest,
Response: QueryParamsResponse,
} as const;
/**
* OriginExists queries if a given origin exists.
*
* @generated from rpc svc.v1.Query.OriginExists
*/
export const QueryOriginExistsService = {
typeName: TYPE_NAME,
method: "OriginExists",
Request: QueryOriginExistsRequest,
Response: QueryOriginExistsResponse,
} as const;
/**
* ResolveOrigin queries the domain of a given service and returns its record with capabilities.
*
* @generated from rpc svc.v1.Query.ResolveOrigin
*/
export const QueryResolveOriginService = {
typeName: TYPE_NAME,
method: "ResolveOrigin",
Request: QueryResolveOriginRequest,
Response: QueryResolveOriginResponse,
} as const;

Some files were not shown because too many files have changed in this diff Show More