jcc_wallet 4.0.0 → 4.0.2

package/lib/minify-eosjs/PrivateKey.d.ts

@@ -0,0 +1,27 @@
+/**
+ * forked from https://github.com/EOSIO/eosjs/blob/master/src/eosjs-key-conversions.ts
+ *
+ * rewrite curves
+ */
+import BN from "bn.js";
+import { Key, KeyType } from "./eosjs-numeric";
+import { ProjPointType, CurveFn } from "@noble/curves/abstract/weierstrass";
+import { PublicKey, Signature } from "./eosjs-key-conversions";
+/** Represents/stores a private key and provides easy conversion for use with `elliptic` lib */
+export declare class PrivateKey {
+    private key;
+    private ec;
+    constructor(key: Key, ec: CurveFn);
+    /** Instantiate private key from an EOSIO-format private key */
+    static fromString(keyString: string, ec?: CurveFn): PrivateKey;
+    /** Export private key as `elliptic`-format private key */
+    toPoint(): ProjPointType<bigint>;
+    /** Get key type from key */
+    getType(): KeyType;
+    /** Retrieve the public key from a private key */
+    getPublicKey(): PublicKey;
+    /** Sign a message or hashed message digest with private key */
+    sign(data: BN, shouldHash?: boolean, encoding?: BufferEncoding): Signature;
+    /** Validate a private key */
+    isValid(): boolean;
+}

package/lib/minify-eosjs/PrivateKey.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * forked from https://github.com/EOSIO/eosjs/blob/master/src/eosjs-key-conversions.ts
+ *
+ * rewrite curves
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivateKey = void 0;
+const eosjs_numeric_1 = require("./eosjs-numeric");
+const eosjs_key_conversions_1 = require("./eosjs-key-conversions");
+/** Represents/stores a private key and provides easy conversion for use with `elliptic` lib */
+class PrivateKey {
+    constructor(key, ec) {
+        this.key = key;
+        this.ec = ec;
+    }
+    /** Instantiate private key from an EOSIO-format private key */
+    static fromString(keyString, ec) {
+        const privateKey = (0, eosjs_numeric_1.stringToPrivateKey)(keyString);
+        if (!ec) {
+            ec = (0, eosjs_key_conversions_1.constructElliptic)(privateKey.type);
+        }
+        return new PrivateKey(privateKey, ec);
+    }
+    /** Export private key as `elliptic`-format private key */
+    toPoint() {
+        return this.ec.ProjectivePoint.fromPrivateKey(this.key.data);
+    }
+    /** Get key type from key */
+    getType() {
+        return this.key.type;
+    }
+    /** Retrieve the public key from a private key */
+    getPublicKey() {
+        const ellipticPrivateKey = this.toPoint();
+        return eosjs_key_conversions_1.PublicKey.fromPoint(ellipticPrivateKey, this.getType(), this.ec);
+    }
+    /** Sign a message or hashed message digest with private key */
+    sign(data, shouldHash = true, encoding = "utf8") {
+        if (shouldHash) {
+            if (typeof data === "string") {
+                data = Buffer.from(data, encoding);
+            }
+            data = this.ec.CURVE.hash(data);
+        }
+        let tries = 0;
+        let signature;
+        const isCanonical = (sigData) => !(sigData[1] & 0x80) &&
+            !(sigData[1] === 0 && !(sigData[2] & 0x80)) &&
+            !(sigData[33] & 0x80) &&
+            !(sigData[33] === 0 && !(sigData[34] & 0x80));
+        const constructSignature = (options) => {
+            const ellipticSignature = this.ec.sign(data, this.key.data, options);
+            return eosjs_key_conversions_1.Signature.fromSignature(ellipticSignature, this.getType(), this.ec);
+        };
+        if (this.key.type === eosjs_numeric_1.KeyType.k1) {
+            do {
+                signature = constructSignature({ lowS: true, extraEntropy: Buffer.from([++tries]) });
+            } while (!isCanonical(signature.toBinary()));
+        }
+        else {
+            signature = constructSignature({ lowS: true });
+        }
+        return signature;
+    }
+    /** Validate a private key */
+    isValid() {
+        try {
+            this.toPoint();
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+}
+exports.PrivateKey = PrivateKey;

package/lib/minify-eosjs/PublicKey.d.ts

@@ -0,0 +1,25 @@
+/**
+ * forked from https://github.com/EOSIO/eosjs/blob/master/src/eosjs-key-conversions.ts
+ *
+ * rewrite curves
+ */
+import { Key, KeyType } from "./eosjs-numeric";
+import { ProjPointType, CurveFn } from "@noble/curves/abstract/weierstrass";
+/** Represents/stores a public key and provides easy conversion for use with `elliptic` lib */
+export declare class PublicKey {
+    private key;
+    private ec;
+    constructor(key: Key, ec: CurveFn);
+    /** Instantiate public key from an EOSIO-format public key */
+    static fromString(publicKeyStr: string, ec?: CurveFn): PublicKey;
+    /** Instantiate public key from an `elliptic`-format public key */
+    static fromPoint(publicKey: ProjPointType<bigint>, keyType: KeyType, ec?: CurveFn): PublicKey;
+    /** Export public key as Legacy EOSIO-format public key */
+    toLegacyString(): string;
+    /** Export public key as `elliptic`-format public key */
+    toPoint(): ProjPointType<bigint>;
+    /** Get key type from key */
+    getType(): KeyType;
+    /** Validate a public key */
+    isValid(): boolean;
+}

package/lib/minify-eosjs/PublicKey.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * forked from https://github.com/EOSIO/eosjs/blob/master/src/eosjs-key-conversions.ts
+ *
+ * rewrite curves
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublicKey = void 0;
+const eosjs_numeric_1 = require("./eosjs-numeric");
+const eosjs_key_conversions_1 = require("./eosjs-key-conversions");
+const bn_utils_1 = require("./bn-utils");
+/** Represents/stores a public key and provides easy conversion for use with `elliptic` lib */
+class PublicKey {
+    constructor(key, ec) {
+        this.key = key;
+        this.ec = ec;
+    }
+    /** Instantiate public key from an EOSIO-format public key */
+    static fromString(publicKeyStr, ec) {
+        const key = (0, eosjs_numeric_1.stringToPublicKey)(publicKeyStr);
+        if (!ec) {
+            ec = (0, eosjs_key_conversions_1.constructElliptic)(key.type);
+        }
+        return new PublicKey(key, ec);
+    }
+    /** Instantiate public key from an `elliptic`-format public key */
+    static fromPoint(publicKey, keyType, ec) {
+        const x = (0, bn_utils_1.toBEArray)(publicKey.x, 32);
+        const y = (0, bn_utils_1.toBEArray)(publicKey.y, 32);
+        if (!ec) {
+            ec = (0, eosjs_key_conversions_1.constructElliptic)(keyType);
+        }
+        return new PublicKey({
+            type: keyType,
+            data: new Uint8Array([y[31] & 1 ? 3 : 2].concat(x))
+        }, ec);
+    }
+    /** Export public key as Legacy EOSIO-format public key */
+    toLegacyString() {
+        return (0, eosjs_numeric_1.publicKeyToLegacyString)(this.key);
+    }
+    /** Export public key as `elliptic`-format public key */
+    toPoint() {
+        return this.ec.ProjectivePoint.fromHex(this.key.data);
+    }
+    /** Get key type from key */
+    getType() {
+        return this.key.type;
+    }
+    /** Validate a public key */
+    isValid() {
+        try {
+            this.toPoint();
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+}
+exports.PublicKey = PublicKey;

package/lib/minify-eosjs/Signature.d.ts

@@ -0,0 +1,34 @@
+/**
+ * forked from https://github.com/EOSIO/eosjs/blob/master/src/eosjs-key-conversions.ts
+ *
+ * rewrite curves
+ */
+import { Key, KeyType } from "./eosjs-numeric";
+import { PublicKey } from "./eosjs-key-conversions";
+import { BN } from "bn.js";
+import { CurveFn, SignatureType, RecoveredSignatureType } from "@noble/curves/abstract/weierstrass";
+/** Represents/stores a Signature and provides easy conversion for use with `elliptic` lib */
+export declare class Signature {
+    private signature;
+    private ec;
+    constructor(signature: Key, ec: CurveFn);
+    /** Instantiate Signature from an EOSIO-format Signature */
+    static fromString(sig: string, ec?: CurveFn): Signature;
+    /** Instantiate Signature from an `elliptic`-format Signature */
+    static fromSignature(ellipticSig: SignatureType, keyType: KeyType, ec?: CurveFn): Signature;
+    /** Export Signature as `elliptic`-format Signature
+     * NOTE: This isn't an actual elliptic-format Signature, as ec.Signature is not exported by the library.
+     * That's also why the return type is `any`.  We're *actually* returning an object with the 3 params
+     * not an ec.Signature.
+     * Further NOTE: @types/elliptic shows ec.Signature as exported; it is *not*.  Hence the `any`.
+     */
+    toRecoveredSignature(): RecoveredSignatureType;
+    /** Export Signature as EOSIO-format Signature */
+    toString(): string;
+    /** Export Signature in binary format */
+    toBinary(): Uint8Array;
+    /** Get key type from signature */
+    getType(): KeyType;
+    /** Recover a public key from a message or hashed message digest and signature */
+    recover(data: BN, shouldHash?: boolean, encoding?: BufferEncoding): PublicKey;
+}

package/lib/minify-eosjs/Signature.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * forked from https://github.com/EOSIO/eosjs/blob/master/src/eosjs-key-conversions.ts
+ *
+ * rewrite curves
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Signature = void 0;
+const eosjs_numeric_1 = require("./eosjs-numeric");
+const eosjs_key_conversions_1 = require("./eosjs-key-conversions");
+const bn_utils_1 = require("./bn-utils");
+/** Represents/stores a Signature and provides easy conversion for use with `elliptic` lib */
+class Signature {
+    constructor(signature, ec) {
+        this.signature = signature;
+        this.ec = ec;
+    }
+    /** Instantiate Signature from an EOSIO-format Signature */
+    static fromString(sig, ec) {
+        const signature = (0, eosjs_numeric_1.stringToSignature)(sig);
+        if (!ec) {
+            ec = (0, eosjs_key_conversions_1.constructElliptic)(signature.type);
+        }
+        return new Signature(signature, ec);
+    }
+    /** Instantiate Signature from an `elliptic`-format Signature */
+    static fromSignature(ellipticSig, keyType, ec) {
+        const r = (0, bn_utils_1.toBEArray)(ellipticSig.r, 32);
+        const s = (0, bn_utils_1.toBEArray)(ellipticSig.s, 32);
+        let eosioRecoveryParam;
+        if (keyType === eosjs_numeric_1.KeyType.k1 || keyType === eosjs_numeric_1.KeyType.r1) {
+            eosioRecoveryParam = ellipticSig.recovery + 27;
+            if (ellipticSig.recovery <= 3) {
+                eosioRecoveryParam += 4;
+            }
+        }
+        else if (keyType === eosjs_numeric_1.KeyType.wa) {
+            eosioRecoveryParam = ellipticSig.recovery;
+        }
+        const sigData = new Uint8Array([eosioRecoveryParam].concat(r, s));
+        if (!ec) {
+            ec = (0, eosjs_key_conversions_1.constructElliptic)(keyType);
+        }
+        return new Signature({
+            type: keyType,
+            data: sigData
+        }, ec);
+    }
+    /** Export Signature as `elliptic`-format Signature
+     * NOTE: This isn't an actual elliptic-format Signature, as ec.Signature is not exported by the library.
+     * That's also why the return type is `any`.  We're *actually* returning an object with the 3 params
+     * not an ec.Signature.
+     * Further NOTE: @types/elliptic shows ec.Signature as exported; it is *not*.  Hence the `any`.
+     */
+    toRecoveredSignature() {
+        const lengthOfR = 32;
+        const lengthOfS = 32;
+        const r = (0, bn_utils_1.toBigInt)(this.signature.data.slice(1, lengthOfR + 1));
+        const s = (0, bn_utils_1.toBigInt)(this.signature.data.slice(lengthOfR + 1, lengthOfR + lengthOfS + 1));
+        let ellipticRecoveryBitField;
+        if (this.signature.type === eosjs_numeric_1.KeyType.k1 || this.signature.type === eosjs_numeric_1.KeyType.r1) {
+            ellipticRecoveryBitField = this.signature.data[0] - 27;
+            if (ellipticRecoveryBitField > 3) {
+                ellipticRecoveryBitField -= 4;
+            }
+        }
+        else if (this.signature.type === eosjs_numeric_1.KeyType.wa) {
+            ellipticRecoveryBitField = this.signature.data[0];
+        }
+        const recoveryParam = ellipticRecoveryBitField & 3;
+        const sig = new this.ec.Signature(BigInt(r), BigInt(s));
+        return sig.addRecoveryBit(recoveryParam);
+    }
+    /** Export Signature as EOSIO-format Signature */
+    toString() {
+        return (0, eosjs_numeric_1.signatureToString)(this.signature);
+    }
+    /** Export Signature in binary format */
+    toBinary() {
+        return this.signature.data;
+    }
+    /** Get key type from signature */
+    getType() {
+        return this.signature.type;
+    }
+    /** Recover a public key from a message or hashed message digest and signature */
+    recover(data, shouldHash = true, encoding = "utf8") {
+        if (shouldHash) {
+            if (typeof data === "string") {
+                data = Buffer.from(data, encoding);
+            }
+            data = this.ec.CURVE.hash(data);
+        }
+        const sig = this.toRecoveredSignature();
+        const recoveredPublicKey = sig.recoverPublicKey(data);
+        const ellipticKPub = this.ec.ProjectivePoint.fromHex(recoveredPublicKey.toHex());
+        return eosjs_key_conversions_1.PublicKey.fromPoint(ellipticKPub, this.getType(), this.ec);
+    }
+}
+exports.Signature = Signature;

package/lib/minify-eosjs/bn-utils.d.ts

@@ -0,0 +1,2 @@
+export declare const toBEArray: (num: bigint, width: number) => number[];
+export declare const toBigInt: (data: Uint8Array) => bigint;

package/lib/minify-eosjs/bn-utils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBigInt = exports.toBEArray = void 0;
+const toBEArray = (num, width) => {
+    const hex = num.toString(16);
+    const buf = Buffer.from(hex.padStart(width * 2, "0").slice(0, width * 2), "hex");
+    return Array.prototype.slice.call(buf, 0);
+};
+exports.toBEArray = toBEArray;
+const toBigInt = (data) => {
+    let encoded = BigInt(0);
+    for (let i = 0, l = data.length; i < l; i++) {
+        encoded |= BigInt(data[i]) << ((BigInt(l) - BigInt(i) - BigInt(1)) * BigInt(8));
+    }
+    return encoded;
+};
+exports.toBigInt = toBigInt;

package/lib/minify-eosjs/eosjs-key-conversions.d.ts

@@ -0,0 +1,12 @@
+/**
+ * forked from https://github.com/EOSIO/eosjs/blob/master/src/eosjs-key-conversions.ts
+ *
+ * rewrite curves
+ */
+import { KeyType } from "./eosjs-numeric";
+export { PrivateKey } from "./PrivateKey";
+export { PublicKey } from "./PublicKey";
+export { Signature } from "./Signature";
+import { CurveFn } from "@noble/curves/abstract/weierstrass";
+/** Construct the elliptic curve object based on key type */
+export declare const constructElliptic: (type: KeyType) => CurveFn;

package/lib/minify-eosjs/eosjs-key-conversions.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * forked from https://github.com/EOSIO/eosjs/blob/master/src/eosjs-key-conversions.ts
+ *
+ * rewrite curves
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constructElliptic = exports.Signature = exports.PublicKey = exports.PrivateKey = void 0;
+const eosjs_numeric_1 = require("./eosjs-numeric");
+var PrivateKey_1 = require("./PrivateKey");
+Object.defineProperty(exports, "PrivateKey", { enumerable: true, get: function () { return PrivateKey_1.PrivateKey; } });
+var PublicKey_1 = require("./PublicKey");
+Object.defineProperty(exports, "PublicKey", { enumerable: true, get: function () { return PublicKey_1.PublicKey; } });
+var Signature_1 = require("./Signature");
+Object.defineProperty(exports, "Signature", { enumerable: true, get: function () { return Signature_1.Signature; } });
+const secp256k1_1 = require("@noble/curves/secp256k1");
+const p256_1 = require("@noble/curves/p256");
+/** Construct the elliptic curve object based on key type */
+const constructElliptic = (type) => {
+    if (type === eosjs_numeric_1.KeyType.k1) {
+        return secp256k1_1.secp256k1;
+    }
+    return p256_1.p256;
+};
+exports.constructElliptic = constructElliptic;

package/lib/minify-eosjs/eosjs-numeric.d.ts

@@ -0,0 +1,48 @@
+/**
+ * forked from https://github.com/EOSIO/eosjs/blob/master/src/eosjs-key-conversions.ts
+ *
+ * rewrite ripemd160
+ *
+ */
+/**
+ * Convert an unsigned base-58 number in `s` to a bignum
+ *
+ * @param size bignum size (bytes)
+ */
+export declare const base58ToBinary: (size: number, s: string) => Uint8Array;
+/**
+ * Convert `bignum` to a base-58 number
+ *
+ * @param minDigits 0-pad result to this many digits
+ */
+export declare const binaryToBase58: (bignum: Uint8Array) => string;
+/** Key types this library supports */
+export declare enum KeyType {
+    k1 = 0,
+    r1 = 1,
+    wa = 2
+}
+/** Public key data size, excluding type field */
+export declare const publicKeyDataSize = 33;
+/** Private key data size, excluding type field */
+export declare const privateKeyDataSize = 32;
+/** Signature data size, excluding type field */
+export declare const signatureDataSize = 65;
+/** Public key, private key, or signature in binary form */
+export interface Key {
+    type: KeyType;
+    data: Uint8Array;
+}
+/** Convert key in `s` to binary form */
+export declare const stringToPublicKey: (s: string) => Key;
+/** Convert public `key` to legacy string (base-58) form */
+export declare const publicKeyToLegacyString: (key: Key) => string;
+/** Convert key in `s` to binary form */
+export declare const stringToPrivateKey: (s: string) => Key;
+/** Convert key in `s` to binary form */
+export declare const stringToSignature: (s: string) => Key;
+/** Convert `signature` to string (base-58) form */
+export declare const signatureToString: (signature: Key) => string;
+export declare const privateKeyToLegacyString: (key: Key) => string;
+/** Convert `key` to string (base-58) form */
+export declare const privateKeyToString: (key: Key) => string;