coreum-js 2.5.10 → 2.5.12

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

@@ -0,0 +1,38 @@
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "tendermint.crypto";
+/** PublicKey defines the keys available for use with Validators */
+export interface PublicKey {
+    ed25519?: Uint8Array | undefined;
+    secp256k1?: Uint8Array | undefined;
+}
+export declare const PublicKey: {
+    encode(message: PublicKey, writer?: _m0.Writer): _m0.Writer;
+    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;
+};
+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 {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export {};

package/dist/main/tendermint/crypto/keys.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublicKey = exports.protobufPackage = void 0;
+/* eslint-disable */
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+exports.protobufPackage = "tendermint.crypto";
+function createBasePublicKey() {
+    return { ed25519: undefined, secp256k1: undefined };
+}
+exports.PublicKey = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.ed25519 !== undefined) {
+            writer.uint32(10).bytes(message.ed25519);
+        }
+        if (message.secp256k1 !== undefined) {
+            writer.uint32(18).bytes(message.secp256k1);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePublicKey();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.ed25519 = reader.bytes();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.secp256k1 = reader.bytes();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            ed25519: isSet(object.ed25519) ? bytesFromBase64(object.ed25519) : undefined,
+            secp256k1: isSet(object.secp256k1) ? bytesFromBase64(object.secp256k1) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.ed25519 !== undefined &&
+            (obj.ed25519 = message.ed25519 !== undefined ? base64FromBytes(message.ed25519) : undefined);
+        message.secp256k1 !== undefined &&
+            (obj.secp256k1 = message.secp256k1 !== undefined ? base64FromBytes(message.secp256k1) : undefined);
+        return obj;
+    },
+    create(base) {
+        return exports.PublicKey.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = createBasePublicKey();
+        message.ed25519 = (_a = object.ed25519) !== null && _a !== void 0 ? _a : undefined;
+        message.secp256k1 = (_b = object.secp256k1) !== null && _b !== void 0 ? _b : undefined;
+        return message;
+    },
+};
+var tsProtoGlobalThis = (() => {
+    if (typeof globalThis !== "undefined") {
+        return globalThis;
+    }
+    if (typeof self !== "undefined") {
+        return self;
+    }
+    if (typeof window !== "undefined") {
+        return window;
+    }
+    if (typeof global !== "undefined") {
+        return global;
+    }
+    throw "Unable to locate global object";
+})();
+function bytesFromBase64(b64) {
+    if (tsProtoGlobalThis.Buffer) {
+        return Uint8Array.from(tsProtoGlobalThis.Buffer.from(b64, "base64"));
+    }
+    else {
+        const bin = tsProtoGlobalThis.atob(b64);
+        const arr = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; ++i) {
+            arr[i] = bin.charCodeAt(i);
+        }
+        return arr;
+    }
+}
+function base64FromBytes(arr) {
+    if (tsProtoGlobalThis.Buffer) {
+        return tsProtoGlobalThis.Buffer.from(arr).toString("base64");
+    }
+    else {
+        const bin = [];
+        arr.forEach((byte) => {
+            bin.push(String.fromCharCode(byte));
+        });
+        return tsProtoGlobalThis.btoa(bin.join(""));
+    }
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/main/tendermint/crypto/proof.d.ts

@@ -0,0 +1,226 @@
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "tendermint.crypto";
+export interface Proof {
+    total: number;
+    index: number;
+    leafHash: Uint8Array;
+    aunts: Uint8Array[];
+}
+export interface ValueOp {
+    /** Encoded in ProofOp.Key. */
+    key: Uint8Array;
+    /** To encode in ProofOp.Data */
+    proof: Proof | undefined;
+}
+export interface DominoOp {
+    key: string;
+    input: string;
+    output: string;
+}
+/**
+ * ProofOp defines an operation used for calculating Merkle root
+ * The data could be arbitrary format, providing nessecary data
+ * for example neighbouring node hash
+ */
+export interface ProofOp {
+    type: string;
+    key: Uint8Array;
+    data: Uint8Array;
+}
+/** ProofOps is Merkle proof defined by the list of ProofOps */
+export interface ProofOps {
+    ops: ProofOp[];
+}
+export declare const Proof: {
+    encode(message: Proof, writer?: _m0.Writer): _m0.Writer;
+    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;
+};
+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;
+};
+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;
+};
+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;
+};
+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;
+};
+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 {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export {};