@pgchain/blockchain-libs
Version:
PGWallet Blockchain Libs
198 lines • 8.14 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.mnemonicFromEntropy = exports.revealableSeedFromMnemonic = exports.CKDPub = exports.CKDPriv = exports.N = exports.generateMasterKeyFromSeed = exports.batchGetPublicKeys = exports.batchGetPrivateKeys = exports.sign = exports.verify = exports.compressPublicKey = exports.uncompressPublicKey = exports.publicFromPrivate = void 0;
const bip32_1 = require("./bip32");
const bip39_1 = require("./bip39");
const curves_1 = require("./curves");
const encryptor = __importStar(require("./encryptors/aes256"));
const hash_1 = require("./hash");
const curves = new Map([
['secp256k1', curves_1.secp256k1],
['nistp256', curves_1.nistp256],
['ed25519', curves_1.ed25519],
]);
const derivers = new Map([
[
'secp256k1',
new bip32_1.BaseBip32KeyDeriver(Buffer.from('Bitcoin seed'), curves_1.secp256k1),
],
[
'nistp256',
new bip32_1.BaseBip32KeyDeriver(Buffer.from('Nist256p1 seed'), curves_1.nistp256),
],
[
'ed25519',
new bip32_1.ED25519Bip32KeyDeriver(Buffer.from('ed25519 seed'), curves_1.ed25519),
],
]);
function getCurveByName(curveName) {
const curve = curves.get(curveName);
if (curve === undefined) {
throw Error(`Curve ${curveName} is not supported.`);
}
return curve;
}
function getDeriverByCurveName(curveName) {
const deriver = derivers.get(curveName);
if (deriver === undefined) {
throw Error(`Key derivation is not supported for curve ${curveName}.`);
}
return deriver;
}
function verify(curveName, publicKey, digest, signature) {
return getCurveByName(curveName).verify(publicKey, digest, signature);
}
exports.verify = verify;
function sign(curveName, encryptedPrivateKey, digest, password) {
return getCurveByName(curveName).sign(encryptor.decrypt(password, encryptedPrivateKey), digest);
}
exports.sign = sign;
function publicFromPrivate(curveName, encryptedPrivateKey, password) {
return getCurveByName(curveName).publicFromPrivate(encryptor.decrypt(password, encryptedPrivateKey));
}
exports.publicFromPrivate = publicFromPrivate;
function uncompressPublicKey(curveName, publicKey) {
if (publicKey.length === 65) {
return publicKey;
}
return getCurveByName(curveName).transformPublicKey(publicKey);
}
exports.uncompressPublicKey = uncompressPublicKey;
function compressPublicKey(curveName, publicKey) {
if (publicKey.length === 33) {
return publicKey;
}
return getCurveByName(curveName).transformPublicKey(publicKey);
}
exports.compressPublicKey = compressPublicKey;
function batchGetKeys(curveName, encryptedSeed, password, prefix, relPaths, type) {
const ret = [];
const cache = {};
const deriver = getDeriverByCurveName(curveName);
const seed = encryptor.decrypt(password, encryptedSeed);
let key = deriver.generateMasterKeyFromSeed(seed);
prefix.split('/').forEach((pathComponent) => {
if (pathComponent === 'm') {
return;
}
const index = pathComponent.endsWith("'")
? parseInt(pathComponent.slice(0, -1)) + 2 ** 31
: parseInt(pathComponent);
key = deriver.CKDPriv(key, index);
});
cache[prefix] = {
fingerPrint: (0, hash_1.hash160)(deriver.N(key).key).slice(0, 4),
parentFingerPrint: Buffer.from([]),
privkey: key,
};
relPaths.forEach((relPath) => {
const pathComponents = relPath.split('/');
let currentPath = prefix;
let parent = cache[currentPath];
pathComponents.forEach((pathComponent) => {
currentPath = `${currentPath}/${pathComponent}`;
if (typeof cache[currentPath] === 'undefined') {
const index = pathComponent.endsWith("'")
? parseInt(pathComponent.slice(0, -1)) + 2 ** 31
: parseInt(pathComponent);
const privkey = deriver.CKDPriv(parent.privkey, index);
if (typeof parent.fingerPrint === 'undefined') {
parent.fingerPrint = (0, hash_1.hash160)(deriver.N(parent.privkey).key).slice(0, 4);
}
cache[currentPath] = {
fingerPrint: undefined,
parentFingerPrint: parent.fingerPrint,
privkey: privkey,
};
}
parent = cache[currentPath];
});
ret.push({
path: currentPath,
parentFingerPrint: cache[currentPath].parentFingerPrint,
extendedKey: type === 'private'
? {
chainCode: cache[currentPath].privkey.chainCode,
key: encryptor.encrypt(password, cache[currentPath].privkey.key),
}
: deriver.N(cache[currentPath].privkey),
});
});
return ret;
}
function batchGetPrivateKeys(curveName, encryptedSeed, password, prefix, relPaths) {
return batchGetKeys(curveName, encryptedSeed, password, prefix, relPaths, 'private');
}
exports.batchGetPrivateKeys = batchGetPrivateKeys;
function batchGetPublicKeys(curveName, encryptedSeed, password, prefix, relPaths) {
return batchGetKeys(curveName, encryptedSeed, password, prefix, relPaths, 'public');
}
exports.batchGetPublicKeys = batchGetPublicKeys;
function generateMasterKeyFromSeed(curveName, encryptedSeed, password) {
const deriver = getDeriverByCurveName(curveName);
const seed = encryptor.decrypt(password, encryptedSeed);
const masterKey = deriver.generateMasterKeyFromSeed(seed);
return {
key: encryptor.encrypt(password, masterKey.key),
chainCode: masterKey.chainCode,
};
}
exports.generateMasterKeyFromSeed = generateMasterKeyFromSeed;
function N(curveName, encryptedExtPriv, password) {
const deriver = getDeriverByCurveName(curveName);
const extPriv = {
key: encryptor.decrypt(password, encryptedExtPriv.key),
chainCode: encryptedExtPriv.chainCode,
};
return deriver.N(extPriv);
}
exports.N = N;
function CKDPriv(curveName, encryptedParent, index, password) {
const deriver = getDeriverByCurveName(curveName);
const parent = {
key: encryptor.decrypt(password, encryptedParent.key),
chainCode: encryptedParent.chainCode,
};
const child = deriver.CKDPriv(parent, index);
return {
key: encryptor.encrypt(password, child.key),
chainCode: child.chainCode,
};
}
exports.CKDPriv = CKDPriv;
function CKDPub(curveName, parent, index) {
return getDeriverByCurveName(curveName).CKDPub(parent, index);
}
exports.CKDPub = CKDPub;
function revealableSeedFromMnemonic(mnemonic, password, passphrase) {
const rs = (0, bip39_1.mnemonicToRevealableSeed)(mnemonic, passphrase);
return {
entropyWithLangPrefixed: encryptor.encrypt(password, rs.entropyWithLangPrefixed),
seed: encryptor.encrypt(password, rs.seed),
};
}
exports.revealableSeedFromMnemonic = revealableSeedFromMnemonic;
function mnemonicFromEntropy(encryptedEntropy, password) {
return (0, bip39_1.revealEntropy)(encryptor.decrypt(password, encryptedEntropy));
}
exports.mnemonicFromEntropy = mnemonicFromEntropy;
//# sourceMappingURL=index.js.map