@bitgo/account-lib 2.20.1-rc.2 → 2.21.0-hotfix.0

package/dist/src/utils/crypto.d.ts

@@ -0,0 +1,99 @@
+/// <reference types="node" />
+import { ExtendedKeys } from '../coin/baseCoin/iface';
+/**
+ * @param {string} xpub - a base-58 encoded extended public key (BIP32)
+ * @returns {string} the uncompressed public key in hexadecimal
+ */
+export declare function xpubToUncompressedPub(xpub: string): string;
+/**
+ * @param {string} xprv - base58-encoded extended private key (BIP32)
+ * @returns {string} the hex-encoded raw private key
+ */
+export declare function xprvToRawPrv(xprv: string): string;
+/**
+ * @param {string} prv - Private key in hex format to get the extended keys for
+ * @returns {ExtendedKeys} xprv and xpub in string format
+ */
+export declare function rawPrvToExtendedKeys(prv: string): ExtendedKeys;
+/**
+ * Whether the input is a valid BIP32 xpub or not
+ *
+ * @param xpub
+ */
+export declare function isValidXpub(xpub: string): boolean;
+/**
+ * Whether the input is a valid BIP32 xprv or not
+ *
+ * @param xprv
+ */
+export declare function isValidXprv(xprv: string): boolean;
+/**
+ * Whether the input is a valid secp256k1 public key
+ *
+ * @param pub
+ */
+export declare function isValidPub(pub: string): boolean;
+/**
+ * Whether the input is a valid secp256k1 private key
+ *
+ * @param prv
+ */
+export declare function isValidPrv(prv: string): boolean;
+/**
+ * Whether the input is a valid ed25519 private key
+ *
+ * @param {string} prv A hexadecimal private key to validate
+ * @returns {boolean} Whether the input is a valid public key or not
+ */
+export declare function isValidEd25519Seed(prv: string): boolean;
+/**
+ * Whether the input is a valid ed25519 private key
+ *
+ * @param {string} prv A hexadecimal private key to validate
+ * @returns {boolean} Whether the input is a valid public key or not
+ */
+export declare function isValidEd25519SecretKey(prv: string): boolean;
+/**
+ * Whether the input is a valid ed25519 public key
+ *
+ * @param {string} pub A hexadecimal public key to validate
+ * @returns {boolean} Whether the input is a valid public key or not
+ */
+export declare function isValidEd25519PublicKey(pub: string): boolean;
+/**
+ * Whether the input is a valid BLS private key
+ *
+ * @param {string} prv a private key to validate
+ * @returns {boolean} Whether the input is a valid private key or not
+ */
+export declare function isValidBLSPrivateKey(prv: string): boolean;
+/**
+ * Whether input is a valid BLS public key
+ *
+ * @param {string} pub the public key to validate
+ * @returns {boolean} Whether input is a valid public key or not
+ */
+export declare function isValidBLSPublicKey(pub: string): boolean;
+/**
+ * Returns an hex string of the given buffer
+ *
+ * @param {Buffer | Uint8Array} buffer - the buffer to be converted to hex
+ * @returns {string} - the hex value
+ */
+export declare function toHex(buffer: Buffer | Uint8Array): string;
+/**
+ * Returns an hex string of the given bigint
+ *
+ * @param {bigint} bigint - the bigint to be converted to hex
+ * @returns {string} - the hex value
+ */
+export declare function bigIntToHex(bigint: bigint): string;
+/**
+ * Check if base58 decoded string is equale to length
+ *
+ * @param {string} value - string to be checked
+ * @param {number} length - expected decoded length
+ * @return {boolean} if the string can decoded as base58 and match the expected length
+ */
+export declare function isBase58(value: string, length: number): boolean;
+//# sourceMappingURL=crypto.d.ts.map

package/dist/src/utils/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../../src/utils/crypto.ts"],"names":[],"mappings":";AAMA,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAItD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAO1D;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAUjD;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAM9D;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAYjD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAYjD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAO/C;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAO/C;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAOvD;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAO5D;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAO5D;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAMzD;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAOxD;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,CAEzD;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAGlD;AAED;;;;;;GAMG;AAEH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAM/D"}

package/dist/src/utils/crypto.js

@@ -0,0 +1,260 @@
+"use strict";
+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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBase58 = exports.bigIntToHex = exports.toHex = exports.isValidBLSPublicKey = exports.isValidBLSPrivateKey = exports.isValidEd25519PublicKey = exports.isValidEd25519SecretKey = exports.isValidEd25519Seed = exports.isValidPrv = exports.isValidPub = exports.isValidXprv = exports.isValidXpub = exports.rawPrvToExtendedKeys = exports.xprvToRawPrv = exports.xpubToUncompressedPub = void 0;
+var bip32 = __importStar(require("bip32"));
+var bitcoinjs_lib_1 = require("bitcoinjs-lib");
+var nacl = __importStar(require("tweetnacl"));
+var hex = __importStar(require("@stablelib/hex"));
+var bls = __importStar(require("noble-bls12-381"));
+var ethereumjs_utils_old_1 = require("ethereumjs-utils-old");
+var utils_1 = require("../coin/hbar/utils");
+var bs58_1 = __importDefault(require("bs58"));
+/**
+ * @param {string} xpub - a base-58 encoded extended public key (BIP32)
+ * @returns {string} the uncompressed public key in hexadecimal
+ */
+function xpubToUncompressedPub(xpub) {
+    if (!isValidXpub(xpub)) {
+        throw new Error('invalid xpub');
+    }
+    return bitcoinjs_lib_1.ECPair.fromPublicKey(bip32.fromBase58(xpub, bitcoinjs_lib_1.networks.bitcoin).publicKey, {
+        compressed: false,
+    }).publicKey.toString('hex');
+}
+exports.xpubToUncompressedPub = xpubToUncompressedPub;
+/**
+ * @param {string} xprv - base58-encoded extended private key (BIP32)
+ * @returns {string} the hex-encoded raw private key
+ */
+function xprvToRawPrv(xprv) {
+    if (!isValidXprv(xprv)) {
+        throw new Error('invalid xprv');
+    }
+    var privateKey = bip32.fromBase58(xprv, bitcoinjs_lib_1.networks.bitcoin).privateKey;
+    if (!privateKey) {
+        throw new Error('invalid xprv');
+    }
+    return privateKey.toString('hex');
+}
+exports.xprvToRawPrv = xprvToRawPrv;
+/**
+ * @param {string} prv - Private key in hex format to get the extended keys for
+ * @returns {ExtendedKeys} xprv and xpub in string format
+ */
+function rawPrvToExtendedKeys(prv) {
+    var hd = bip32.fromPrivateKey(Buffer.from(prv, 'hex'), Buffer.alloc(32));
+    return {
+        xprv: hd.toBase58(),
+        xpub: hd.neutered().toBase58(),
+    };
+}
+exports.rawPrvToExtendedKeys = rawPrvToExtendedKeys;
+/**
+ * Whether the input is a valid BIP32 xpub or not
+ *
+ * @param xpub
+ */
+function isValidXpub(xpub) {
+    if (xpub.substr(0, 4) !== 'xpub') {
+        // check for xpub formats we don't support, such as tpub
+        return false;
+    }
+    try {
+        bip32.fromBase58(xpub, bitcoinjs_lib_1.networks.bitcoin);
+    }
+    catch (err) {
+        return false;
+    }
+    // if HD generation didn't throw, it is a valid xpub
+    return true;
+}
+exports.isValidXpub = isValidXpub;
+/**
+ * Whether the input is a valid BIP32 xprv or not
+ *
+ * @param xprv
+ */
+function isValidXprv(xprv) {
+    if (xprv.substr(0, 4) !== 'xprv') {
+        // check for xprv formats we don't support
+        return false;
+    }
+    try {
+        bip32.fromBase58(xprv, bitcoinjs_lib_1.networks.bitcoin);
+    }
+    catch (err) {
+        return false;
+    }
+    // if HD generation didn't throw, it is a valid xprv
+    return true;
+}
+exports.isValidXprv = isValidXprv;
+/**
+ * Whether the input is a valid secp256k1 public key
+ *
+ * @param pub
+ */
+function isValidPub(pub) {
+    try {
+        bitcoinjs_lib_1.ECPair.fromPublicKey(Buffer.from(pub, 'hex'));
+    }
+    catch (e) {
+        return false;
+    }
+    return true;
+}
+exports.isValidPub = isValidPub;
+/**
+ * Whether the input is a valid secp256k1 private key
+ *
+ * @param prv
+ */
+function isValidPrv(prv) {
+    try {
+        bitcoinjs_lib_1.ECPair.fromPrivateKey(Buffer.from(prv, 'hex'));
+    }
+    catch (e) {
+        return false;
+    }
+    return true;
+}
+exports.isValidPrv = isValidPrv;
+/**
+ * Whether the input is a valid ed25519 private key
+ *
+ * @param {string} prv A hexadecimal private key to validate
+ * @returns {boolean} Whether the input is a valid public key or not
+ */
+function isValidEd25519Seed(prv) {
+    try {
+        var decodedPrv = utils_1.toUint8Array(prv);
+        return decodedPrv.length === nacl.sign.seedLength;
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.isValidEd25519Seed = isValidEd25519Seed;
+/**
+ * Whether the input is a valid ed25519 private key
+ *
+ * @param {string} prv A hexadecimal private key to validate
+ * @returns {boolean} Whether the input is a valid public key or not
+ */
+function isValidEd25519SecretKey(prv) {
+    try {
+        var decodedPrv = utils_1.toUint8Array(prv);
+        return decodedPrv.length === nacl.sign.secretKeyLength;
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.isValidEd25519SecretKey = isValidEd25519SecretKey;
+/**
+ * Whether the input is a valid ed25519 public key
+ *
+ * @param {string} pub A hexadecimal public key to validate
+ * @returns {boolean} Whether the input is a valid public key or not
+ */
+function isValidEd25519PublicKey(pub) {
+    try {
+        var decodedPub = new Uint8Array(Buffer.from(pub, 'hex'));
+        return decodedPub.length === nacl.sign.publicKeyLength;
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.isValidEd25519PublicKey = isValidEd25519PublicKey;
+/**
+ * Whether the input is a valid BLS private key
+ *
+ * @param {string} prv a private key to validate
+ * @returns {boolean} Whether the input is a valid private key or not
+ */
+function isValidBLSPrivateKey(prv) {
+    try {
+        return bls.Fr.isValid(BigInt(prv));
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.isValidBLSPrivateKey = isValidBLSPrivateKey;
+/**
+ * Whether input is a valid BLS public key
+ *
+ * @param {string} pub the public key to validate
+ * @returns {boolean} Whether input is a valid public key or not
+ */
+function isValidBLSPublicKey(pub) {
+    try {
+        bls.PointG1.fromCompressedHex(ethereumjs_utils_old_1.stripHexPrefix(pub)).assertValidity();
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.isValidBLSPublicKey = isValidBLSPublicKey;
+/**
+ * Returns an hex string of the given buffer
+ *
+ * @param {Buffer | Uint8Array} buffer - the buffer to be converted to hex
+ * @returns {string} - the hex value
+ */
+function toHex(buffer) {
+    return hex.encode(buffer, true);
+}
+exports.toHex = toHex;
+/**
+ * Returns an hex string of the given bigint
+ *
+ * @param {bigint} bigint - the bigint to be converted to hex
+ * @returns {string} - the hex value
+ */
+function bigIntToHex(bigint) {
+    var hex = bigint.toString(16);
+    return '0x' + '0'.slice(0, hex.length % 2) + hex;
+}
+exports.bigIntToHex = bigIntToHex;
+/**
+ * Check if base58 decoded string is equale to length
+ *
+ * @param {string} value - string to be checked
+ * @param {number} length - expected decoded length
+ * @return {boolean} if the string can decoded as base58 and match the expected length
+ */
+function isBase58(value, length) {
+    try {
+        return !!value && bs58_1.default.decode(value).length === length;
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.isBase58 = isBase58;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"crypto.js","sourceRoot":"","sources":["../../../src/utils/crypto.ts"],"names":[],"mappings":"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","sourcesContent":["import * as bip32 from 'bip32';\nimport { ECPair, networks } from 'bitcoinjs-lib';\nimport * as nacl from 'tweetnacl';\nimport * as hex from '@stablelib/hex';\nimport * as bls from 'noble-bls12-381';\nimport { stripHexPrefix } from 'ethereumjs-utils-old';\nimport { ExtendedKeys } from '../coin/baseCoin/iface';\nimport { toUint8Array } from '../coin/hbar/utils';\nimport bs58 from 'bs58';\n\n/**\n * @param {string} xpub - a base-58 encoded extended public key (BIP32)\n * @returns {string} the uncompressed public key in hexadecimal\n */\nexport function xpubToUncompressedPub(xpub: string): string {\n  if (!isValidXpub(xpub)) {\n    throw new Error('invalid xpub');\n  }\n  return ECPair.fromPublicKey(bip32.fromBase58(xpub, networks.bitcoin).publicKey, {\n    compressed: false,\n  }).publicKey.toString('hex');\n}\n\n/**\n * @param {string} xprv - base58-encoded extended private key (BIP32)\n * @returns {string} the hex-encoded raw private key\n */\nexport function xprvToRawPrv(xprv: string): string {\n  if (!isValidXprv(xprv)) {\n    throw new Error('invalid xprv');\n  }\n\n  const { privateKey } = bip32.fromBase58(xprv, networks.bitcoin);\n  if (!privateKey) {\n    throw new Error('invalid xprv');\n  }\n  return privateKey.toString('hex');\n}\n\n/**\n * @param {string} prv - Private key in hex format to get the extended keys for\n * @returns {ExtendedKeys} xprv and xpub in string format\n */\nexport function rawPrvToExtendedKeys(prv: string): ExtendedKeys {\n  const hd = bip32.fromPrivateKey(Buffer.from(prv, 'hex'), Buffer.alloc(32));\n  return {\n    xprv: hd.toBase58(),\n    xpub: hd.neutered().toBase58(),\n  };\n}\n\n/**\n * Whether the input is a valid BIP32 xpub or not\n *\n * @param xpub\n */\nexport function isValidXpub(xpub: string): boolean {\n  if (xpub.substr(0, 4) !== 'xpub') {\n    // check for xpub formats we don't support, such as tpub\n    return false;\n  }\n  try {\n    bip32.fromBase58(xpub, networks.bitcoin);\n  } catch (err) {\n    return false;\n  }\n  // if HD generation didn't throw, it is a valid xpub\n  return true;\n}\n\n/**\n * Whether the input is a valid BIP32 xprv or not\n *\n * @param xprv\n */\nexport function isValidXprv(xprv: string): boolean {\n  if (xprv.substr(0, 4) !== 'xprv') {\n    // check for xprv formats we don't support\n    return false;\n  }\n  try {\n    bip32.fromBase58(xprv, networks.bitcoin);\n  } catch (err) {\n    return false;\n  }\n  // if HD generation didn't throw, it is a valid xprv\n  return true;\n}\n\n/**\n * Whether the input is a valid secp256k1 public key\n *\n * @param pub\n */\nexport function isValidPub(pub: string): boolean {\n  try {\n    ECPair.fromPublicKey(Buffer.from(pub, 'hex'));\n  } catch (e) {\n    return false;\n  }\n  return true;\n}\n\n/**\n * Whether the input is a valid secp256k1 private key\n *\n * @param prv\n */\nexport function isValidPrv(prv: string): boolean {\n  try {\n    ECPair.fromPrivateKey(Buffer.from(prv, 'hex'));\n  } catch (e) {\n    return false;\n  }\n  return true;\n}\n\n/**\n * Whether the input is a valid ed25519 private key\n *\n * @param {string} prv A hexadecimal private key to validate\n * @returns {boolean} Whether the input is a valid public key or not\n */\nexport function isValidEd25519Seed(prv: string): boolean {\n  try {\n    const decodedPrv = toUint8Array(prv);\n    return decodedPrv.length === nacl.sign.seedLength;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Whether the input is a valid ed25519 private key\n *\n * @param {string} prv A hexadecimal private key to validate\n * @returns {boolean} Whether the input is a valid public key or not\n */\nexport function isValidEd25519SecretKey(prv: string): boolean {\n  try {\n    const decodedPrv = toUint8Array(prv);\n    return decodedPrv.length === nacl.sign.secretKeyLength;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Whether the input is a valid ed25519 public key\n *\n * @param {string} pub A hexadecimal public key to validate\n * @returns {boolean} Whether the input is a valid public key or not\n */\nexport function isValidEd25519PublicKey(pub: string): boolean {\n  try {\n    const decodedPub = new Uint8Array(Buffer.from(pub, 'hex'));\n    return decodedPub.length === nacl.sign.publicKeyLength;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Whether the input is a valid BLS private key\n *\n * @param {string} prv a private key to validate\n * @returns {boolean} Whether the input is a valid private key or not\n */\nexport function isValidBLSPrivateKey(prv: string): boolean {\n  try {\n    return bls.Fr.isValid(BigInt(prv));\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Whether input is a valid BLS public key\n *\n * @param {string} pub the public key to validate\n * @returns {boolean} Whether input is a valid public key or not\n */\nexport function isValidBLSPublicKey(pub: string): boolean {\n  try {\n    bls.PointG1.fromCompressedHex(stripHexPrefix(pub)).assertValidity();\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Returns an hex string of the given buffer\n *\n * @param {Buffer | Uint8Array} buffer - the buffer to be converted to hex\n * @returns {string} - the hex value\n */\nexport function toHex(buffer: Buffer | Uint8Array): string {\n  return hex.encode(buffer, true);\n}\n\n/**\n * Returns an hex string of the given bigint\n *\n * @param {bigint} bigint - the bigint to be converted to hex\n * @returns {string} - the hex value\n */\nexport function bigIntToHex(bigint: bigint): string {\n  const hex = bigint.toString(16);\n  return '0x' + '0'.slice(0, hex.length % 2) + hex;\n}\n\n/**\n * Check if base58 decoded string is equale to length\n *\n * @param {string} value - string to be checked\n * @param {number} length - expected decoded length\n * @return {boolean} if the string can decoded as base58 and match the expected length\n */\n\nexport function isBase58(value: string, length: number): boolean {\n  try {\n    return !!value && bs58.decode(value).length === length;\n  } catch (e) {\n    return false;\n  }\n}\n"]}

package/dist/src/utils/ed25519KeyDeriver.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="node" />
+export interface HdKeypair {
+    key: Buffer;
+    chainCode: Buffer;
+}
+/**
+ * Heirarchical determinisitic key derivation for the ed25519 elliptic curve,
+ * as defined in SLIP-0010.
+ *
+ * https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0005.md
+ * https://github.com/satoshilabs/slips/blob/master/slip-0010.md
+ */
+export declare class Ed25519KeyDeriver {
+    /**
+     * This key derivation code was copied and adapted from:
+     * https://github.com/chatch/stellar-hd-wallet/blob/612c12325ca9047dce460016fb7d148f55f575ca/src/hd-key.js
+     *
+     * There have been some slight modifications to improve typescript support.
+     *
+     * The original ed25519-hd-key module is licensed under "GPL-3".
+     */
+    private static readonly ED25519_CURVE;
+    private static readonly HARDENED_OFFSET;
+    private static readonly PATH_REGEX;
+    /**
+     * Derive a SLIP-0010 key given a path and master key seed.
+     *
+     * @param path derivation path
+     * @param seed key seed
+     */
+    static derivePath(path: string, seed: string): HdKeypair;
+    /**
+     * Generate a SLIP-0010 master key from the entropy seed
+     *
+     * @param seed master key seed used to recreate master key
+     */
+    private static getMasterKeyFromSeed;
+    /**
+     * Calculate a child private key given the parent key, the chain code, and the child index.
+     *
+     * @param key parent key
+     * @param chainCode chain code for parent key
+     * @param index index of child to derive
+     */
+    private static CKDPriv;
+    private static replaceDerive;
+    private static isValidPath;
+}
+//# sourceMappingURL=ed25519KeyDeriver.d.ts.map

package/dist/src/utils/ed25519KeyDeriver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ed25519KeyDeriver.d.ts","sourceRoot":"","sources":["../../../src/utils/ed25519KeyDeriver.ts"],"names":[],"mappings":";AAKA,MAAM,WAAW,SAAS;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;GAMG;AACH,qBAAa,iBAAiB;IAC5B;;;;;;;OAOG;IAEH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAkB;IACvD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAc;IACrD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAkC;IAEpE;;;;;OAKG;WACW,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS;IAY/D;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAWnC;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,OAAO;IAatB,OAAO,CAAC,MAAM,CAAC,aAAa,CAA+D;IAC3F,OAAO,CAAC,MAAM,CAAC,WAAW;CAM3B"}

package/dist/src/utils/ed25519KeyDeriver.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ed25519KeyDeriver = void 0;
+/**
+ * @prettier
+ */
+var create_hmac_1 = __importDefault(require("create-hmac"));
+/**
+ * Heirarchical determinisitic key derivation for the ed25519 elliptic curve,
+ * as defined in SLIP-0010.
+ *
+ * https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0005.md
+ * https://github.com/satoshilabs/slips/blob/master/slip-0010.md
+ */
+var Ed25519KeyDeriver = /** @class */ (function () {
+    function Ed25519KeyDeriver() {
+    }
+    /**
+     * Derive a SLIP-0010 key given a path and master key seed.
+     *
+     * @param path derivation path
+     * @param seed key seed
+     */
+    Ed25519KeyDeriver.derivePath = function (path, seed) {
+        var _this = this;
+        if (!this.isValidPath(path)) {
+            throw new Error('Invalid derivation path');
+        }
+        var _a = this.getMasterKeyFromSeed(seed), key = _a.key, chainCode = _a.chainCode;
+        var segments = path.split('/').slice(1).map(this.replaceDerive);
+        return segments.reduce(function (parentKeys, segment) { return _this.CKDPriv(parentKeys, segment + Ed25519KeyDeriver.HARDENED_OFFSET); }, { key: key, chainCode: chainCode });
+    };
+    /**
+     * Generate a SLIP-0010 master key from the entropy seed
+     *
+     * @param seed master key seed used to recreate master key
+     */
+    Ed25519KeyDeriver.getMasterKeyFromSeed = function (seed) {
+        var hmac = create_hmac_1.default('sha512', Ed25519KeyDeriver.ED25519_CURVE);
+        var I = hmac.update(Buffer.from(seed, 'hex')).digest();
+        var IL = I.slice(0, 32);
+        var IR = I.slice(32);
+        return {
+            key: IL,
+            chainCode: IR,
+        };
+    };
+    /**
+     * Calculate a child private key given the parent key, the chain code, and the child index.
+     *
+     * @param key parent key
+     * @param chainCode chain code for parent key
+     * @param index index of child to derive
+     */
+    Ed25519KeyDeriver.CKDPriv = function (_a, index) {
+        var key = _a.key, chainCode = _a.chainCode;
+        var indexBuffer = Buffer.allocUnsafe(4);
+        indexBuffer.writeUInt32BE(index, 0);
+        var data = Buffer.concat([Buffer.alloc(1, 0), key, indexBuffer]);
+        var I = create_hmac_1.default('sha512', chainCode).update(data).digest();
+        var IL = I.slice(0, 32);
+        var IR = I.slice(32);
+        return {
+            key: IL,
+            chainCode: IR,
+        };
+    };
+    Ed25519KeyDeriver.isValidPath = function (path) {
+        if (!Ed25519KeyDeriver.PATH_REGEX.test(path)) {
+            return false;
+        }
+        return !path.split('/').slice(1).map(this.replaceDerive).some(isNaN);
+    };
+    /**
+     * This key derivation code was copied and adapted from:
+     * https://github.com/chatch/stellar-hd-wallet/blob/612c12325ca9047dce460016fb7d148f55f575ca/src/hd-key.js
+     *
+     * There have been some slight modifications to improve typescript support.
+     *
+     * The original ed25519-hd-key module is licensed under "GPL-3".
+     */
+    Ed25519KeyDeriver.ED25519_CURVE = 'ed25519 seed';
+    Ed25519KeyDeriver.HARDENED_OFFSET = 0x80000000;
+    Ed25519KeyDeriver.PATH_REGEX = new RegExp("^m(\\/[0-9]+')+$");
+    Ed25519KeyDeriver.replaceDerive = function (val) { return parseInt(val.replace("'", ''), 10); };
+    return Ed25519KeyDeriver;
+}());
+exports.Ed25519KeyDeriver = Ed25519KeyDeriver;
+//# sourceMappingURL=data:application/json;base64,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