@onekeyfe/blockchain-libs/dist/secret/curves/elliptic.js

OneKey Blockchain Libs

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ed25519 = exports.nistp256 = exports.secp256k1 = void 0;
const bignumber_js_1 = __importDefault(require("bignumber.js"));
const elliptic_1 = __importDefault(require("elliptic"));
const bip32_1 = require("../bip32");
class EllipticECWrapper {
    constructor(curve) {
        this.curve = curve;
        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
        this.groupOrder = new bignumber_js_1.default(curve.n.toString());
    }
    transformPublicKey(publicKey) {
        let toCompressed;
        if (publicKey.length == 33 && (publicKey[0] === 2 || publicKey[0] === 3)) {
            toCompressed = false;
        }
        else if (publicKey.length == 65 && publicKey[0] === 4) {
            toCompressed = true;
        }
        else {
            throw new Error('Invalid public key.');
        }
        return Buffer.from(this.curve
            .keyFromPublic(publicKey)
            .getPublic()
            .encode(undefined, toCompressed));
    }
    publicFromPrivate(privateKey) {
        return Buffer.from(this.curve.keyFromPrivate(privateKey).getPublic().encodeCompressed());
    }
    verify(publicKey, digest, signature) {
        if (signature.length != 65) {
            return false;
        }
        return this.curve.keyFromPublic(publicKey).verify(digest, {
            r: signature.slice(0, 32),
            s: signature.slice(32, 64),
            recoveryParam: parseInt(signature[64].toString()),
        });
    }
    sign(privateKey, digest) {
        const signature = this.curve
            .keyFromPrivate(privateKey)
            .sign(digest, { canonical: true });
        return Buffer.concat([
            signature.r.toArrayLike(Buffer, 'be', 32),
            signature.s.toArrayLike(Buffer, 'be', 32),
            Buffer.from([signature.recoveryParam]),
        ]);
    }
    getChildPublicKey(IL, parentPublicKey) {
        if ((0, bip32_1.parse256)(IL).gte(this.groupOrder)) {
            return null;
        }
        const p = this.curve.keyFromPrivate(IL).getPublic();
        const q = this.curve.keyFromPublic(parentPublicKey).getPublic();
        const r = p.add(q);
        if (r.isInfinity()) {
            return null;
        }
        return Buffer.from(r.encodeCompressed());
    }
}
class EllipticEDDSAWrapper {
    constructor(curve) {
        this.curve = curve;
    }
    transformPublicKey(publicKey) {
        return publicKey;
    }
    publicFromPrivate(privateKey) {
        return Buffer.from(this.curve.keyFromSecret(privateKey).getPublic());
    }
    verify(publicKey, digest, signature) {
        return this.curve
            .keyFromPublic(publicKey.toString('hex'))
            .verify(digest, signature.toString('hex'));
    }
    sign(privateKey, digest) {
        return Buffer.from(this.curve.keyFromSecret(privateKey).sign(digest).toBytes());
    }
}
const secp256k1 = new EllipticECWrapper(new elliptic_1.default.ec('secp256k1'));
exports.secp256k1 = secp256k1;
const nistp256 = new EllipticECWrapper(new elliptic_1.default.ec('p256'));
exports.nistp256 = nistp256;
const ed25519 = new EllipticEDDSAWrapper(new elliptic_1.default.eddsa('ed25519'));
exports.ed25519 = ed25519;
//# sourceMappingURL=elliptic.js.map