@safeheron/master-key-derive/dist/lib/ed25519_utils.js

Mnemonic Generation;

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ed25519_hd_verify = exports.ed25519_hd_sign = exports.ed25519_verify = exports.ed25519_sign = exports.ed25519_get_pubkey_hex = void 0;
const crypto_bip32_1 = require("@safeheron/crypto-bip32");
const elliptic = require("elliptic");
const crypto_rand_1 = require("@safeheron/crypto-rand");
const utils = elliptic.utils;
const parseBytes = utils.parseBytes;
const Ed25519 = new elliptic.eddsa('ed25519');
function ed25519_get_pubkey_hex(priv) {
    if (typeof priv === 'string') {
        priv = utils.intFromLE(priv);
    }
    let A = Ed25519.curve.g.mul(priv);
    let A_encode = Ed25519.encodePoint(A);
    return utils.toHex(A_encode);
}
exports.ed25519_get_pubkey_hex = ed25519_get_pubkey_hex;
/**
 * ed25519_sign
 * @param priv BN or hex string
 * @param messageHex message in hex string
 */
function ed25519_sign(priv, messageHex) {
    return __awaiter(this, void 0, void 0, function* () {
        if (typeof priv === 'string') {
            priv = utils.intFromLE(priv);
        }
        let message = parseBytes(messageHex);
        let A = Ed25519.curve.g.mul(priv);
        let r = yield crypto_rand_1.Rand.randomBNLt(Ed25519.curve.n);
        let R = Ed25519.curve.g.mul(r);
        let Rencoded = Ed25519.encodePoint(R);
        let s_ = Ed25519.hashInt(Rencoded, Ed25519.encodePoint(A), message).mul(priv);
        let S = r.add(s_).umod(Ed25519.curve.n);
        let sig = Ed25519.makeSignature({ R: R, S: S, Rencoded: Rencoded });
        return utils.toHex(sig.Rencoded()) + utils.toHex(sig.Sencoded());
    });
}
exports.ed25519_sign = ed25519_sign;
/**
 * ed25519_verify
 * @param pubHex public key encode in hex format
 * @param messageHex
 * @param sigHex
 */
function ed25519_verify(pubHex, messageHex, sigHex) {
    return Ed25519.verify(messageHex, sigHex, pubHex);
}
exports.ed25519_verify = ed25519_verify;
/**
 * ed25519_hd_sign
 * @param xprv
 * @param path
 * @param messageHex
 */
function ed25519_hd_sign(xprv, path, messageHex) {
    return __awaiter(this, void 0, void 0, function* () {
        let hdKey = crypto_bip32_1.Ed25519HDKey.fromExtendedKey(xprv);
        let childHDKey = hdKey.derive(path);
        return yield ed25519_sign(childHDKey.privateKey, messageHex);
    });
}
exports.ed25519_hd_sign = ed25519_hd_sign;
/**
 * ed25519_hd_verify
 * @param xpub
 * @param path
 * @param messageHex
 * @param sigHex
 */
function ed25519_hd_verify(xpub, path, messageHex, sigHex) {
    let hdKey = crypto_bip32_1.Ed25519HDKey.fromExtendedKey(xpub);
    let childHDKey = hdKey.derive(path);
    let pubHex = utils.toHex(Ed25519.encodePoint(childHDKey.publicKey));
    return ed25519_verify(pubHex, messageHex, sigHex);
}
exports.ed25519_hd_verify = ed25519_hd_verify;
//# sourceMappingURL=ed25519_utils.js.map