coreum-js 2.16.1 → 2.16.3

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

@@ -10,20 +10,8 @@ export declare const PublicKey: {
     decode(input: _m0.Reader | Uint8Array, length?: number): PublicKey;
     fromJSON(object: any): PublicKey;
     toJSON(message: PublicKey): unknown;
-    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;
+    create<I extends Exact<DeepPartial<PublicKey>, I>>(base?: I): PublicKey;
+    fromPartial<I extends Exact<DeepPartial<PublicKey>, I>>(object: I): 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,182 +36,40 @@ export declare const Proof: {
     decode(input: _m0.Reader | Uint8Array, length?: number): Proof;
     fromJSON(object: any): Proof;
     toJSON(message: Proof): unknown;
-    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;
+    create<I extends Exact<DeepPartial<Proof>, I>>(base?: I): Proof;
+    fromPartial<I extends Exact<DeepPartial<Proof>, I>>(object: I): 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 {
-        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;
+    create<I extends Exact<DeepPartial<ValueOp>, I>>(base?: I): ValueOp;
+    fromPartial<I extends Exact<DeepPartial<ValueOp>, I>>(object: I): 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 {
-        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;
+    create<I extends Exact<DeepPartial<DominoOp>, I>>(base?: I): DominoOp;
+    fromPartial<I extends Exact<DeepPartial<DominoOp>, I>>(object: I): 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 {
-        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;
+    create<I extends Exact<DeepPartial<ProofOp>, I>>(base?: I): ProofOp;
+    fromPartial<I extends Exact<DeepPartial<ProofOp>, I>>(object: I): 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 {
-        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;
+    create<I extends Exact<DeepPartial<ProofOps>, I>>(base?: I): ProofOps;
+    fromPartial<I extends Exact<DeepPartial<ProofOps>, I>>(object: I): 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,232 +73,48 @@ export declare const ConsensusParams: {
     decode(input: _m0.Reader | Uint8Array, length?: number): ConsensusParams;
     fromJSON(object: any): ConsensusParams;
     toJSON(message: ConsensusParams): unknown;
-    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;
+    create<I extends Exact<DeepPartial<ConsensusParams>, I>>(base?: I): ConsensusParams;
+    fromPartial<I extends Exact<DeepPartial<ConsensusParams>, I>>(object: I): 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 {
-        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;
+    create<I extends Exact<DeepPartial<BlockParams>, I>>(base?: I): BlockParams;
+    fromPartial<I extends Exact<DeepPartial<BlockParams>, I>>(object: I): 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 {
-        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;
+    create<I extends Exact<DeepPartial<EvidenceParams>, I>>(base?: I): EvidenceParams;
+    fromPartial<I extends Exact<DeepPartial<EvidenceParams>, I>>(object: I): 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 {
-        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;
+    create<I extends Exact<DeepPartial<ValidatorParams>, I>>(base?: I): ValidatorParams;
+    fromPartial<I extends Exact<DeepPartial<ValidatorParams>, I>>(object: I): 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 {
-        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;
+    create<I extends Exact<DeepPartial<VersionParams>, I>>(base?: I): VersionParams;
+    fromPartial<I extends Exact<DeepPartial<VersionParams>, I>>(object: I): 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 {
-        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;
+    create<I extends Exact<DeepPartial<HashedParams>, I>>(base?: I): HashedParams;
+    fromPartial<I extends Exact<DeepPartial<HashedParams>, I>>(object: I): 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 {} ? {