coreum-js 2.16.3 → 2.17.0

package/dist/module/tendermint/crypto/keys.d.ts

@@ -10,8 +10,20 @@ export declare const PublicKey: {
     decode(input: _m0.Reader | Uint8Array, length?: number): PublicKey;
     fromJSON(object: any): PublicKey;
     toJSON(message: PublicKey): unknown;
-    create<I extends Exact<DeepPartial<PublicKey>, I>>(base?: I): PublicKey;
-    fromPartial<I extends Exact<DeepPartial<PublicKey>, I>>(object: I): PublicKey;
+    create<I extends {
+        ed25519?: Uint8Array | undefined;
+        secp256k1?: Uint8Array | undefined;
+    } & {
+        ed25519?: Uint8Array | undefined;
+        secp256k1?: Uint8Array | undefined;
+    } & { [K in Exclude<keyof I, keyof PublicKey>]: never; }>(base?: I): PublicKey;
+    fromPartial<I_1 extends {
+        ed25519?: Uint8Array | undefined;
+        secp256k1?: Uint8Array | undefined;
+    } & {
+        ed25519?: Uint8Array | undefined;
+        secp256k1?: Uint8Array | undefined;
+    } & { [K_1 in Exclude<keyof I_1, keyof PublicKey>]: never; }>(object: I_1): PublicKey;
 };
 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/crypto/proof.d.ts

@@ -36,40 +36,182 @@ export declare const Proof: {
     decode(input: _m0.Reader | Uint8Array, length?: number): Proof;
     fromJSON(object: any): Proof;
     toJSON(message: Proof): unknown;
-    create<I extends Exact<DeepPartial<Proof>, I>>(base?: I): Proof;
-    fromPartial<I extends Exact<DeepPartial<Proof>, I>>(object: I): Proof;
+    create<I extends {
+        total?: number;
+        index?: number;
+        leafHash?: Uint8Array;
+        aunts?: Uint8Array[];
+    } & {
+        total?: number;
+        index?: number;
+        leafHash?: Uint8Array;
+        aunts?: Uint8Array[] & Uint8Array[] & { [K in Exclude<keyof I["aunts"], keyof Uint8Array[]>]: never; };
+    } & { [K_1 in Exclude<keyof I, keyof Proof>]: never; }>(base?: I): Proof;
+    fromPartial<I_1 extends {
+        total?: number;
+        index?: number;
+        leafHash?: Uint8Array;
+        aunts?: Uint8Array[];
+    } & {
+        total?: number;
+        index?: number;
+        leafHash?: Uint8Array;
+        aunts?: Uint8Array[] & Uint8Array[] & { [K_2 in Exclude<keyof I_1["aunts"], keyof Uint8Array[]>]: never; };
+    } & { [K_3 in Exclude<keyof I_1, keyof Proof>]: never; }>(object: I_1): Proof;
 };
 export declare const ValueOp: {
     encode(message: ValueOp, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): ValueOp;
     fromJSON(object: any): ValueOp;
     toJSON(message: ValueOp): unknown;
-    create<I extends Exact<DeepPartial<ValueOp>, I>>(base?: I): ValueOp;
-    fromPartial<I extends Exact<DeepPartial<ValueOp>, I>>(object: I): ValueOp;
+    create<I extends {
+        key?: Uint8Array;
+        proof?: {
+            total?: number;
+            index?: number;
+            leafHash?: Uint8Array;
+            aunts?: Uint8Array[];
+        };
+    } & {
+        key?: Uint8Array;
+        proof?: {
+            total?: number;
+            index?: number;
+            leafHash?: Uint8Array;
+            aunts?: Uint8Array[];
+        } & {
+            total?: number;
+            index?: number;
+            leafHash?: Uint8Array;
+            aunts?: Uint8Array[] & Uint8Array[] & { [K in Exclude<keyof I["proof"]["aunts"], keyof Uint8Array[]>]: never; };
+        } & { [K_1 in Exclude<keyof I["proof"], keyof Proof>]: never; };
+    } & { [K_2 in Exclude<keyof I, keyof ValueOp>]: never; }>(base?: I): ValueOp;
+    fromPartial<I_1 extends {
+        key?: Uint8Array;
+        proof?: {
+            total?: number;
+            index?: number;
+            leafHash?: Uint8Array;
+            aunts?: Uint8Array[];
+        };
+    } & {
+        key?: Uint8Array;
+        proof?: {
+            total?: number;
+            index?: number;
+            leafHash?: Uint8Array;
+            aunts?: Uint8Array[];
+        } & {
+            total?: number;
+            index?: number;
+            leafHash?: Uint8Array;
+            aunts?: Uint8Array[] & Uint8Array[] & { [K_3 in Exclude<keyof I_1["proof"]["aunts"], keyof Uint8Array[]>]: never; };
+        } & { [K_4 in Exclude<keyof I_1["proof"], keyof Proof>]: never; };
+    } & { [K_5 in Exclude<keyof I_1, keyof ValueOp>]: never; }>(object: I_1): ValueOp;
 };
 export declare const DominoOp: {
     encode(message: DominoOp, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): DominoOp;
     fromJSON(object: any): DominoOp;
     toJSON(message: DominoOp): unknown;
-    create<I extends Exact<DeepPartial<DominoOp>, I>>(base?: I): DominoOp;
-    fromPartial<I extends Exact<DeepPartial<DominoOp>, I>>(object: I): DominoOp;
+    create<I extends {
+        key?: string;
+        input?: string;
+        output?: string;
+    } & {
+        key?: string;
+        input?: string;
+        output?: string;
+    } & { [K in Exclude<keyof I, keyof DominoOp>]: never; }>(base?: I): DominoOp;
+    fromPartial<I_1 extends {
+        key?: string;
+        input?: string;
+        output?: string;
+    } & {
+        key?: string;
+        input?: string;
+        output?: string;
+    } & { [K_1 in Exclude<keyof I_1, keyof DominoOp>]: never; }>(object: I_1): DominoOp;
 };
 export declare const ProofOp: {
     encode(message: ProofOp, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): ProofOp;
     fromJSON(object: any): ProofOp;
     toJSON(message: ProofOp): unknown;
-    create<I extends Exact<DeepPartial<ProofOp>, I>>(base?: I): ProofOp;
-    fromPartial<I extends Exact<DeepPartial<ProofOp>, I>>(object: I): ProofOp;
+    create<I extends {
+        type?: string;
+        key?: Uint8Array;
+        data?: Uint8Array;
+    } & {
+        type?: string;
+        key?: Uint8Array;
+        data?: Uint8Array;
+    } & { [K in Exclude<keyof I, keyof ProofOp>]: never; }>(base?: I): ProofOp;
+    fromPartial<I_1 extends {
+        type?: string;
+        key?: Uint8Array;
+        data?: Uint8Array;
+    } & {
+        type?: string;
+        key?: Uint8Array;
+        data?: Uint8Array;
+    } & { [K_1 in Exclude<keyof I_1, keyof ProofOp>]: never; }>(object: I_1): ProofOp;
 };
 export declare const ProofOps: {
     encode(message: ProofOps, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): ProofOps;
     fromJSON(object: any): ProofOps;
     toJSON(message: ProofOps): unknown;
-    create<I extends Exact<DeepPartial<ProofOps>, I>>(base?: I): ProofOps;
-    fromPartial<I extends Exact<DeepPartial<ProofOps>, I>>(object: I): ProofOps;
+    create<I extends {
+        ops?: {
+            type?: string;
+            key?: Uint8Array;
+            data?: Uint8Array;
+        }[];
+    } & {
+        ops?: {
+            type?: string;
+            key?: Uint8Array;
+            data?: Uint8Array;
+        }[] & ({
+            type?: string;
+            key?: Uint8Array;
+            data?: Uint8Array;
+        } & {
+            type?: string;
+            key?: Uint8Array;
+            data?: Uint8Array;
+        } & { [K in Exclude<keyof I["ops"][number], keyof ProofOp>]: never; })[] & { [K_1 in Exclude<keyof I["ops"], keyof {
+            type?: string;
+            key?: Uint8Array;
+            data?: Uint8Array;
+        }[]>]: never; };
+    } & { [K_2 in Exclude<keyof I, "ops">]: never; }>(base?: I): ProofOps;
+    fromPartial<I_1 extends {
+        ops?: {
+            type?: string;
+            key?: Uint8Array;
+            data?: Uint8Array;
+        }[];
+    } & {
+        ops?: {
+            type?: string;
+            key?: Uint8Array;
+            data?: Uint8Array;
+        }[] & ({
+            type?: string;
+            key?: Uint8Array;
+            data?: Uint8Array;
+        } & {
+            type?: string;
+            key?: Uint8Array;
+            data?: Uint8Array;
+        } & { [K_3 in Exclude<keyof I_1["ops"][number], keyof ProofOp>]: never; })[] & { [K_4 in Exclude<keyof I_1["ops"], keyof {
+            type?: string;
+            key?: Uint8Array;
+            data?: Uint8Array;
+        }[]>]: never; };
+    } & { [K_5 in Exclude<keyof I_1, "ops">]: never; }>(object: I_1): ProofOps;
 };
 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/types/params.d.ts

@@ -73,48 +73,232 @@ export declare const ConsensusParams: {
     decode(input: _m0.Reader | Uint8Array, length?: number): ConsensusParams;
     fromJSON(object: any): ConsensusParams;
     toJSON(message: ConsensusParams): unknown;
-    create<I extends Exact<DeepPartial<ConsensusParams>, I>>(base?: I): ConsensusParams;
-    fromPartial<I extends Exact<DeepPartial<ConsensusParams>, I>>(object: I): ConsensusParams;
+    create<I extends {
+        block?: {
+            maxBytes?: number;
+            maxGas?: number;
+        };
+        evidence?: {
+            maxAgeNumBlocks?: number;
+            maxAgeDuration?: {
+                seconds?: number;
+                nanos?: number;
+            };
+            maxBytes?: number;
+        };
+        validator?: {
+            pubKeyTypes?: string[];
+        };
+        version?: {
+            app?: number;
+        };
+    } & {
+        block?: {
+            maxBytes?: number;
+            maxGas?: number;
+        } & {
+            maxBytes?: number;
+            maxGas?: number;
+        } & { [K in Exclude<keyof I["block"], keyof BlockParams>]: never; };
+        evidence?: {
+            maxAgeNumBlocks?: number;
+            maxAgeDuration?: {
+                seconds?: number;
+                nanos?: number;
+            };
+            maxBytes?: number;
+        } & {
+            maxAgeNumBlocks?: number;
+            maxAgeDuration?: {
+                seconds?: number;
+                nanos?: number;
+            } & {
+                seconds?: number;
+                nanos?: number;
+            } & { [K_1 in Exclude<keyof I["evidence"]["maxAgeDuration"], keyof Duration>]: never; };
+            maxBytes?: number;
+        } & { [K_2 in Exclude<keyof I["evidence"], keyof EvidenceParams>]: never; };
+        validator?: {
+            pubKeyTypes?: string[];
+        } & {
+            pubKeyTypes?: string[] & string[] & { [K_3 in Exclude<keyof I["validator"]["pubKeyTypes"], keyof string[]>]: never; };
+        } & { [K_4 in Exclude<keyof I["validator"], "pubKeyTypes">]: never; };
+        version?: {
+            app?: number;
+        } & {
+            app?: number;
+        } & { [K_5 in Exclude<keyof I["version"], "app">]: never; };
+    } & { [K_6 in Exclude<keyof I, keyof ConsensusParams>]: never; }>(base?: I): ConsensusParams;
+    fromPartial<I_1 extends {
+        block?: {
+            maxBytes?: number;
+            maxGas?: number;
+        };
+        evidence?: {
+            maxAgeNumBlocks?: number;
+            maxAgeDuration?: {
+                seconds?: number;
+                nanos?: number;
+            };
+            maxBytes?: number;
+        };
+        validator?: {
+            pubKeyTypes?: string[];
+        };
+        version?: {
+            app?: number;
+        };
+    } & {
+        block?: {
+            maxBytes?: number;
+            maxGas?: number;
+        } & {
+            maxBytes?: number;
+            maxGas?: number;
+        } & { [K_7 in Exclude<keyof I_1["block"], keyof BlockParams>]: never; };
+        evidence?: {
+            maxAgeNumBlocks?: number;
+            maxAgeDuration?: {
+                seconds?: number;
+                nanos?: number;
+            };
+            maxBytes?: number;
+        } & {
+            maxAgeNumBlocks?: number;
+            maxAgeDuration?: {
+                seconds?: number;
+                nanos?: number;
+            } & {
+                seconds?: number;
+                nanos?: number;
+            } & { [K_8 in Exclude<keyof I_1["evidence"]["maxAgeDuration"], keyof Duration>]: never; };
+            maxBytes?: number;
+        } & { [K_9 in Exclude<keyof I_1["evidence"], keyof EvidenceParams>]: never; };
+        validator?: {
+            pubKeyTypes?: string[];
+        } & {
+            pubKeyTypes?: string[] & string[] & { [K_10 in Exclude<keyof I_1["validator"]["pubKeyTypes"], keyof string[]>]: never; };
+        } & { [K_11 in Exclude<keyof I_1["validator"], "pubKeyTypes">]: never; };
+        version?: {
+            app?: number;
+        } & {
+            app?: number;
+        } & { [K_12 in Exclude<keyof I_1["version"], "app">]: never; };
+    } & { [K_13 in Exclude<keyof I_1, keyof ConsensusParams>]: never; }>(object: I_1): ConsensusParams;
 };
 export declare const BlockParams: {
     encode(message: BlockParams, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): BlockParams;
     fromJSON(object: any): BlockParams;
     toJSON(message: BlockParams): unknown;
-    create<I extends Exact<DeepPartial<BlockParams>, I>>(base?: I): BlockParams;
-    fromPartial<I extends Exact<DeepPartial<BlockParams>, I>>(object: I): BlockParams;
+    create<I extends {
+        maxBytes?: number;
+        maxGas?: number;
+    } & {
+        maxBytes?: number;
+        maxGas?: number;
+    } & { [K in Exclude<keyof I, keyof BlockParams>]: never; }>(base?: I): BlockParams;
+    fromPartial<I_1 extends {
+        maxBytes?: number;
+        maxGas?: number;
+    } & {
+        maxBytes?: number;
+        maxGas?: number;
+    } & { [K_1 in Exclude<keyof I_1, keyof BlockParams>]: never; }>(object: I_1): BlockParams;
 };
 export declare const EvidenceParams: {
     encode(message: EvidenceParams, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): EvidenceParams;
     fromJSON(object: any): EvidenceParams;
     toJSON(message: EvidenceParams): unknown;
-    create<I extends Exact<DeepPartial<EvidenceParams>, I>>(base?: I): EvidenceParams;
-    fromPartial<I extends Exact<DeepPartial<EvidenceParams>, I>>(object: I): EvidenceParams;
+    create<I extends {
+        maxAgeNumBlocks?: number;
+        maxAgeDuration?: {
+            seconds?: number;
+            nanos?: number;
+        };
+        maxBytes?: number;
+    } & {
+        maxAgeNumBlocks?: number;
+        maxAgeDuration?: {
+            seconds?: number;
+            nanos?: number;
+        } & {
+            seconds?: number;
+            nanos?: number;
+        } & { [K in Exclude<keyof I["maxAgeDuration"], keyof Duration>]: never; };
+        maxBytes?: number;
+    } & { [K_1 in Exclude<keyof I, keyof EvidenceParams>]: never; }>(base?: I): EvidenceParams;
+    fromPartial<I_1 extends {
+        maxAgeNumBlocks?: number;
+        maxAgeDuration?: {
+            seconds?: number;
+            nanos?: number;
+        };
+        maxBytes?: number;
+    } & {
+        maxAgeNumBlocks?: number;
+        maxAgeDuration?: {
+            seconds?: number;
+            nanos?: number;
+        } & {
+            seconds?: number;
+            nanos?: number;
+        } & { [K_2 in Exclude<keyof I_1["maxAgeDuration"], keyof Duration>]: never; };
+        maxBytes?: number;
+    } & { [K_3 in Exclude<keyof I_1, keyof EvidenceParams>]: never; }>(object: I_1): EvidenceParams;
 };
 export declare const ValidatorParams: {
     encode(message: ValidatorParams, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): ValidatorParams;
     fromJSON(object: any): ValidatorParams;
     toJSON(message: ValidatorParams): unknown;
-    create<I extends Exact<DeepPartial<ValidatorParams>, I>>(base?: I): ValidatorParams;
-    fromPartial<I extends Exact<DeepPartial<ValidatorParams>, I>>(object: I): ValidatorParams;
+    create<I extends {
+        pubKeyTypes?: string[];
+    } & {
+        pubKeyTypes?: string[] & string[] & { [K in Exclude<keyof I["pubKeyTypes"], keyof string[]>]: never; };
+    } & { [K_1 in Exclude<keyof I, "pubKeyTypes">]: never; }>(base?: I): ValidatorParams;
+    fromPartial<I_1 extends {
+        pubKeyTypes?: string[];
+    } & {
+        pubKeyTypes?: string[] & string[] & { [K_2 in Exclude<keyof I_1["pubKeyTypes"], keyof string[]>]: never; };
+    } & { [K_3 in Exclude<keyof I_1, "pubKeyTypes">]: never; }>(object: I_1): ValidatorParams;
 };
 export declare const VersionParams: {
     encode(message: VersionParams, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): VersionParams;
     fromJSON(object: any): VersionParams;
     toJSON(message: VersionParams): unknown;
-    create<I extends Exact<DeepPartial<VersionParams>, I>>(base?: I): VersionParams;
-    fromPartial<I extends Exact<DeepPartial<VersionParams>, I>>(object: I): VersionParams;
+    create<I extends {
+        app?: number;
+    } & {
+        app?: number;
+    } & { [K in Exclude<keyof I, "app">]: never; }>(base?: I): VersionParams;
+    fromPartial<I_1 extends {
+        app?: number;
+    } & {
+        app?: number;
+    } & { [K_1 in Exclude<keyof I_1, "app">]: never; }>(object: I_1): VersionParams;
 };
 export declare const HashedParams: {
     encode(message: HashedParams, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): HashedParams;
     fromJSON(object: any): HashedParams;
     toJSON(message: HashedParams): unknown;
-    create<I extends Exact<DeepPartial<HashedParams>, I>>(base?: I): HashedParams;
-    fromPartial<I extends Exact<DeepPartial<HashedParams>, I>>(object: I): HashedParams;
+    create<I extends {
+        blockMaxBytes?: number;
+        blockMaxGas?: number;
+    } & {
+        blockMaxBytes?: number;
+        blockMaxGas?: number;
+    } & { [K in Exclude<keyof I, keyof HashedParams>]: never; }>(base?: I): HashedParams;
+    fromPartial<I_1 extends {
+        blockMaxBytes?: number;
+        blockMaxGas?: number;
+    } & {
+        blockMaxBytes?: number;
+        blockMaxGas?: number;
+    } & { [K_1 in Exclude<keyof I_1, keyof HashedParams>]: never; }>(object: I_1): HashedParams;
 };
 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 {} ? {