coreum-js 2.16.3 → 2.17.0

package/dist/module/tendermint/types/validator.d.ts

@@ -21,24 +21,248 @@ export declare const ValidatorSet: {
     decode(input: _m0.Reader | Uint8Array, length?: number): ValidatorSet;
     fromJSON(object: any): ValidatorSet;
     toJSON(message: ValidatorSet): unknown;
-    create<I extends Exact<DeepPartial<ValidatorSet>, I>>(base?: I): ValidatorSet;
-    fromPartial<I extends Exact<DeepPartial<ValidatorSet>, I>>(object: I): ValidatorSet;
+    create<I extends {
+        validators?: {
+            address?: Uint8Array;
+            pubKey?: {
+                ed25519?: Uint8Array;
+                secp256k1?: Uint8Array;
+            };
+            votingPower?: number;
+            proposerPriority?: number;
+        }[];
+        proposer?: {
+            address?: Uint8Array;
+            pubKey?: {
+                ed25519?: Uint8Array;
+                secp256k1?: Uint8Array;
+            };
+            votingPower?: number;
+            proposerPriority?: number;
+        };
+        totalVotingPower?: number;
+    } & {
+        validators?: {
+            address?: Uint8Array;
+            pubKey?: {
+                ed25519?: Uint8Array;
+                secp256k1?: Uint8Array;
+            };
+            votingPower?: number;
+            proposerPriority?: number;
+        }[] & ({
+            address?: Uint8Array;
+            pubKey?: {
+                ed25519?: Uint8Array;
+                secp256k1?: Uint8Array;
+            };
+            votingPower?: number;
+            proposerPriority?: number;
+        } & {
+            address?: Uint8Array;
+            pubKey?: {
+                ed25519?: Uint8Array;
+                secp256k1?: Uint8Array;
+            } & {
+                ed25519?: Uint8Array;
+                secp256k1?: Uint8Array;
+            } & { [K in Exclude<keyof I["validators"][number]["pubKey"], keyof PublicKey>]: never; };
+            votingPower?: number;
+            proposerPriority?: number;
+        } & { [K_1 in Exclude<keyof I["validators"][number], keyof Validator>]: never; })[] & { [K_2 in Exclude<keyof I["validators"], keyof {
+            address?: Uint8Array;
+            pubKey?: {
+                ed25519?: Uint8Array;
+                secp256k1?: Uint8Array;
+            };
+            votingPower?: number;
+            proposerPriority?: number;
+        }[]>]: never; };
+        proposer?: {
+            address?: Uint8Array;
+            pubKey?: {
+                ed25519?: Uint8Array;
+                secp256k1?: Uint8Array;
+            };
+            votingPower?: number;
+            proposerPriority?: number;
+        } & {
+            address?: Uint8Array;
+            pubKey?: {
+                ed25519?: Uint8Array;
+                secp256k1?: Uint8Array;
+            } & {
+                ed25519?: Uint8Array;
+                secp256k1?: Uint8Array;
+            } & { [K_3 in Exclude<keyof I["proposer"]["pubKey"], keyof PublicKey>]: never; };
+            votingPower?: number;
+            proposerPriority?: number;
+        } & { [K_4 in Exclude<keyof I["proposer"], keyof Validator>]: never; };
+        totalVotingPower?: number;
+    } & { [K_5 in Exclude<keyof I, keyof ValidatorSet>]: never; }>(base?: I): ValidatorSet;
+    fromPartial<I_1 extends {
+        validators?: {
+            address?: Uint8Array;
+            pubKey?: {
+                ed25519?: Uint8Array;
+                secp256k1?: Uint8Array;
+            };
+            votingPower?: number;
+            proposerPriority?: number;
+        }[];
+        proposer?: {
+            address?: Uint8Array;
+            pubKey?: {
+                ed25519?: Uint8Array;
+                secp256k1?: Uint8Array;
+            };
+            votingPower?: number;
+            proposerPriority?: number;
+        };
+        totalVotingPower?: number;
+    } & {
+        validators?: {
+            address?: Uint8Array;
+            pubKey?: {
+                ed25519?: Uint8Array;
+                secp256k1?: Uint8Array;
+            };
+            votingPower?: number;
+            proposerPriority?: number;
+        }[] & ({
+            address?: Uint8Array;
+            pubKey?: {
+                ed25519?: Uint8Array;
+                secp256k1?: Uint8Array;
+            };
+            votingPower?: number;
+            proposerPriority?: number;
+        } & {
+            address?: Uint8Array;
+            pubKey?: {
+                ed25519?: Uint8Array;
+                secp256k1?: Uint8Array;
+            } & {
+                ed25519?: Uint8Array;
+                secp256k1?: Uint8Array;
+            } & { [K_6 in Exclude<keyof I_1["validators"][number]["pubKey"], keyof PublicKey>]: never; };
+            votingPower?: number;
+            proposerPriority?: number;
+        } & { [K_7 in Exclude<keyof I_1["validators"][number], keyof Validator>]: never; })[] & { [K_8 in Exclude<keyof I_1["validators"], keyof {
+            address?: Uint8Array;
+            pubKey?: {
+                ed25519?: Uint8Array;
+                secp256k1?: Uint8Array;
+            };
+            votingPower?: number;
+            proposerPriority?: number;
+        }[]>]: never; };
+        proposer?: {
+            address?: Uint8Array;
+            pubKey?: {
+                ed25519?: Uint8Array;
+                secp256k1?: Uint8Array;
+            };
+            votingPower?: number;
+            proposerPriority?: number;
+        } & {
+            address?: Uint8Array;
+            pubKey?: {
+                ed25519?: Uint8Array;
+                secp256k1?: Uint8Array;
+            } & {
+                ed25519?: Uint8Array;
+                secp256k1?: Uint8Array;
+            } & { [K_9 in Exclude<keyof I_1["proposer"]["pubKey"], keyof PublicKey>]: never; };
+            votingPower?: number;
+            proposerPriority?: number;
+        } & { [K_10 in Exclude<keyof I_1["proposer"], keyof Validator>]: never; };
+        totalVotingPower?: number;
+    } & { [K_11 in Exclude<keyof I_1, keyof ValidatorSet>]: never; }>(object: I_1): ValidatorSet;
 };
 export declare const Validator: {
     encode(message: Validator, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): Validator;
     fromJSON(object: any): Validator;
     toJSON(message: Validator): unknown;
-    create<I extends Exact<DeepPartial<Validator>, I>>(base?: I): Validator;
-    fromPartial<I extends Exact<DeepPartial<Validator>, I>>(object: I): Validator;
+    create<I extends {
+        address?: Uint8Array;
+        pubKey?: {
+            ed25519?: Uint8Array;
+            secp256k1?: Uint8Array;
+        };
+        votingPower?: number;
+        proposerPriority?: number;
+    } & {
+        address?: Uint8Array;
+        pubKey?: {
+            ed25519?: Uint8Array;
+            secp256k1?: Uint8Array;
+        } & {
+            ed25519?: Uint8Array;
+            secp256k1?: Uint8Array;
+        } & { [K in Exclude<keyof I["pubKey"], keyof PublicKey>]: never; };
+        votingPower?: number;
+        proposerPriority?: number;
+    } & { [K_1 in Exclude<keyof I, keyof Validator>]: never; }>(base?: I): Validator;
+    fromPartial<I_1 extends {
+        address?: Uint8Array;
+        pubKey?: {
+            ed25519?: Uint8Array;
+            secp256k1?: Uint8Array;
+        };
+        votingPower?: number;
+        proposerPriority?: number;
+    } & {
+        address?: Uint8Array;
+        pubKey?: {
+            ed25519?: Uint8Array;
+            secp256k1?: Uint8Array;
+        } & {
+            ed25519?: Uint8Array;
+            secp256k1?: Uint8Array;
+        } & { [K_2 in Exclude<keyof I_1["pubKey"], keyof PublicKey>]: never; };
+        votingPower?: number;
+        proposerPriority?: number;
+    } & { [K_3 in Exclude<keyof I_1, keyof Validator>]: never; }>(object: I_1): Validator;
 };
 export declare const SimpleValidator: {
     encode(message: SimpleValidator, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): SimpleValidator;
     fromJSON(object: any): SimpleValidator;
     toJSON(message: SimpleValidator): unknown;
-    create<I extends Exact<DeepPartial<SimpleValidator>, I>>(base?: I): SimpleValidator;
-    fromPartial<I extends Exact<DeepPartial<SimpleValidator>, I>>(object: I): SimpleValidator;
+    create<I extends {
+        pubKey?: {
+            ed25519?: Uint8Array;
+            secp256k1?: Uint8Array;
+        };
+        votingPower?: number;
+    } & {
+        pubKey?: {
+            ed25519?: Uint8Array;
+            secp256k1?: Uint8Array;
+        } & {
+            ed25519?: Uint8Array;
+            secp256k1?: Uint8Array;
+        } & { [K in Exclude<keyof I["pubKey"], keyof PublicKey>]: never; };
+        votingPower?: number;
+    } & { [K_1 in Exclude<keyof I, keyof SimpleValidator>]: never; }>(base?: I): SimpleValidator;
+    fromPartial<I_1 extends {
+        pubKey?: {
+            ed25519?: Uint8Array;
+            secp256k1?: Uint8Array;
+        };
+        votingPower?: number;
+    } & {
+        pubKey?: {
+            ed25519?: Uint8Array;
+            secp256k1?: Uint8Array;
+        } & {
+            ed25519?: Uint8Array;
+            secp256k1?: Uint8Array;
+        } & { [K_2 in Exclude<keyof I_1["pubKey"], keyof PublicKey>]: never; };
+        votingPower?: number;
+    } & { [K_3 in Exclude<keyof I_1, keyof SimpleValidator>]: never; }>(object: I_1): SimpleValidator;
 };
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {

package/dist/module/tendermint/version/types.d.ts

@@ -23,16 +23,40 @@ export declare const App: {
     decode(input: _m0.Reader | Uint8Array, length?: number): App;
     fromJSON(object: any): App;
     toJSON(message: App): unknown;
-    create<I extends Exact<DeepPartial<App>, I>>(base?: I): App;
-    fromPartial<I extends Exact<DeepPartial<App>, I>>(object: I): App;
+    create<I extends {
+        protocol?: number;
+        software?: string;
+    } & {
+        protocol?: number;
+        software?: string;
+    } & { [K in Exclude<keyof I, keyof App>]: never; }>(base?: I): App;
+    fromPartial<I_1 extends {
+        protocol?: number;
+        software?: string;
+    } & {
+        protocol?: number;
+        software?: string;
+    } & { [K_1 in Exclude<keyof I_1, keyof App>]: never; }>(object: I_1): App;
 };
 export declare const Consensus: {
     encode(message: Consensus, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): Consensus;
     fromJSON(object: any): Consensus;
     toJSON(message: Consensus): unknown;
-    create<I extends Exact<DeepPartial<Consensus>, I>>(base?: I): Consensus;
-    fromPartial<I extends Exact<DeepPartial<Consensus>, I>>(object: I): Consensus;
+    create<I extends {
+        block?: number;
+        app?: number;
+    } & {
+        block?: number;
+        app?: number;
+    } & { [K in Exclude<keyof I, keyof Consensus>]: never; }>(base?: I): Consensus;
+    fromPartial<I_1 extends {
+        block?: number;
+        app?: number;
+    } & {
+        block?: number;
+        app?: number;
+    } & { [K_1 in Exclude<keyof I_1, keyof Consensus>]: never; }>(object: I_1): Consensus;
 };
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {

package/dist/module/types/core.d.ts

@@ -9,7 +9,8 @@ import { setupBankExtension, setupGovExtension, setupDistributionExtension } fro
 export declare enum CoreumTypeUrl {
     NFT = "/coreum.asset.nft.v1.",
     FT = "/coreum.asset.ft.v1.",
-    NFTBeta = "/cosmos.nft.v1beta1."
+    NFTBeta = "/cosmos.nft.v1beta1.",
+    DEX = "/coreum.dex.v1"
 }
 export interface ClientQueryClient extends QueryClient {
     ft: ReturnType<typeof setupFTExtension>["ft"];

package/dist/module/types/core.js

@@ -1,12 +1,14 @@
 import { protobufPackage as assetNFT } from "../coreum/asset/nft/v1/tx";
 import { protobufPackage as assetFT } from "../coreum/asset/ft/v1/tx";
 import { protobufPackage as nftV1beta } from "../coreum/nft/v1beta1/tx";
+import { protobufPackage as dex } from "../coreum/dex/v1/tx";
 /** @internal */
 export var CoreumTypeUrl;
 (function (CoreumTypeUrl) {
     CoreumTypeUrl["NFT"] = "/coreum.asset.nft.v1.";
     CoreumTypeUrl["FT"] = "/coreum.asset.ft.v1.";
     CoreumTypeUrl["NFTBeta"] = "/cosmos.nft.v1beta1.";
+    CoreumTypeUrl["DEX"] = "/coreum.dex.v1";
 })(CoreumTypeUrl || (CoreumTypeUrl = {}));
 // setupMintExtension,
 // setupFeegrantExtension,

package/dist/module/utils/convertStringToAny.d.ts

@@ -1,2 +1 @@
-import { Any } from 'google-protobuf/google/protobuf/any_pb';
 export declare const convertStringToAny: (message: string) => Any;

package/dist/module/wasm/v1/authz.d.ts

@@ -1,6 +1,6 @@
-import _m0 from "protobufjs/minimal";
+import { BinaryReader, BinaryWriter } from "cosmjs-types/binary";
 import { Coin } from "cosmjs-types/cosmos/base/v1beta1/coin";
-import { Any } from "../../google/protobuf/any";
+import { Any } from "cosmjs-types/google/protobuf/any";
 export declare const protobufPackage = "cosmwasm.wasm.v1";
 /**
  * ContractExecutionAuthorization defines authorization for wasm execute.
@@ -89,80 +89,17 @@ export interface AcceptedMessagesFilter {
     /** Messages is the list of raw contract messages */
     messages: Uint8Array[];
 }
-export declare const ContractExecutionAuthorization: {
-    encode(message: ContractExecutionAuthorization, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): ContractExecutionAuthorization;
-    fromJSON(object: any): ContractExecutionAuthorization;
-    toJSON(message: ContractExecutionAuthorization): unknown;
-    create<I extends Exact<DeepPartial<ContractExecutionAuthorization>, I>>(base?: I): ContractExecutionAuthorization;
-    fromPartial<I extends Exact<DeepPartial<ContractExecutionAuthorization>, I>>(object: I): ContractExecutionAuthorization;
-};
-export declare const ContractMigrationAuthorization: {
-    encode(message: ContractMigrationAuthorization, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): ContractMigrationAuthorization;
-    fromJSON(object: any): ContractMigrationAuthorization;
-    toJSON(message: ContractMigrationAuthorization): unknown;
-    create<I extends Exact<DeepPartial<ContractMigrationAuthorization>, I>>(base?: I): ContractMigrationAuthorization;
-    fromPartial<I extends Exact<DeepPartial<ContractMigrationAuthorization>, I>>(object: I): ContractMigrationAuthorization;
-};
-export declare const ContractGrant: {
-    encode(message: ContractGrant, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): ContractGrant;
-    fromJSON(object: any): ContractGrant;
-    toJSON(message: ContractGrant): unknown;
-    create<I extends Exact<DeepPartial<ContractGrant>, I>>(base?: I): ContractGrant;
-    fromPartial<I extends Exact<DeepPartial<ContractGrant>, I>>(object: I): ContractGrant;
-};
-export declare const MaxCallsLimit: {
-    encode(message: MaxCallsLimit, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): MaxCallsLimit;
-    fromJSON(object: any): MaxCallsLimit;
-    toJSON(message: MaxCallsLimit): unknown;
-    create<I extends Exact<DeepPartial<MaxCallsLimit>, I>>(base?: I): MaxCallsLimit;
-    fromPartial<I extends Exact<DeepPartial<MaxCallsLimit>, I>>(object: I): MaxCallsLimit;
-};
-export declare const MaxFundsLimit: {
-    encode(message: MaxFundsLimit, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): MaxFundsLimit;
-    fromJSON(object: any): MaxFundsLimit;
-    toJSON(message: MaxFundsLimit): unknown;
-    create<I extends Exact<DeepPartial<MaxFundsLimit>, I>>(base?: I): MaxFundsLimit;
-    fromPartial<I extends Exact<DeepPartial<MaxFundsLimit>, I>>(object: I): MaxFundsLimit;
-};
-export declare const CombinedLimit: {
-    encode(message: CombinedLimit, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): CombinedLimit;
-    fromJSON(object: any): CombinedLimit;
-    toJSON(message: CombinedLimit): unknown;
-    create<I extends Exact<DeepPartial<CombinedLimit>, I>>(base?: I): CombinedLimit;
-    fromPartial<I extends Exact<DeepPartial<CombinedLimit>, I>>(object: I): CombinedLimit;
-};
-export declare const AllowAllMessagesFilter: {
-    encode(_: AllowAllMessagesFilter, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): AllowAllMessagesFilter;
-    fromJSON(_: any): AllowAllMessagesFilter;
-    toJSON(_: AllowAllMessagesFilter): unknown;
-    create<I extends Exact<DeepPartial<AllowAllMessagesFilter>, I>>(base?: I): AllowAllMessagesFilter;
-    fromPartial<I extends Exact<DeepPartial<AllowAllMessagesFilter>, I>>(_: I): AllowAllMessagesFilter;
-};
-export declare const AcceptedMessageKeysFilter: {
-    encode(message: AcceptedMessageKeysFilter, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): AcceptedMessageKeysFilter;
-    fromJSON(object: any): AcceptedMessageKeysFilter;
-    toJSON(message: AcceptedMessageKeysFilter): unknown;
-    create<I extends Exact<DeepPartial<AcceptedMessageKeysFilter>, I>>(base?: I): AcceptedMessageKeysFilter;
-    fromPartial<I extends Exact<DeepPartial<AcceptedMessageKeysFilter>, I>>(object: I): AcceptedMessageKeysFilter;
-};
-export declare const AcceptedMessagesFilter: {
-    encode(message: AcceptedMessagesFilter, writer?: _m0.Writer): _m0.Writer;
-    decode(input: _m0.Reader | Uint8Array, length?: number): AcceptedMessagesFilter;
-    fromJSON(object: any): AcceptedMessagesFilter;
-    toJSON(message: AcceptedMessagesFilter): unknown;
-    create<I extends Exact<DeepPartial<AcceptedMessagesFilter>, I>>(base?: I): AcceptedMessagesFilter;
-    fromPartial<I extends Exact<DeepPartial<AcceptedMessagesFilter>, I>>(object: I): AcceptedMessagesFilter;
-};
+export declare const ContractExecutionAuthorization: MessageFns<ContractExecutionAuthorization>;
+export declare const ContractMigrationAuthorization: MessageFns<ContractMigrationAuthorization>;
+export declare const ContractGrant: MessageFns<ContractGrant>;
+export declare const MaxCallsLimit: MessageFns<MaxCallsLimit>;
+export declare const MaxFundsLimit: MessageFns<MaxFundsLimit>;
+export declare const CombinedLimit: MessageFns<CombinedLimit>;
+export declare const AllowAllMessagesFilter: MessageFns<AllowAllMessagesFilter>;
+export declare const AcceptedMessageKeysFilter: MessageFns<AcceptedMessageKeysFilter>;
+export declare const AcceptedMessagesFilter: MessageFns<AcceptedMessagesFilter>;
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
-export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
     [K in keyof T]?: DeepPartial<T[K]>;
 } : Partial<T>;
 type KeysOfUnion<T> = T extends T ? keyof T : never;
@@ -171,4 +108,12 @@ export type Exact<P, I extends P> = P extends Builtin ? P : P & {
 } & {
     [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
 };
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
 export {};