@bitgo/sdk-core 1.0.2-rc.0 → 1.1.0-rc.10

package/dist/src/account-lib/util/crypto.d.ts

@@ -0,0 +1,106 @@
+/// <reference types="node" />
+import { ExtendedKeys } from '../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;
+/**
+ * Returns a Uint8Array of the given hex string
+ *
+ * @param {string} str - the hex string to be converted
+ * @returns {string} - the Uint8Array value
+ */
+export declare function toUint8Array(str: string): Uint8Array;
+//# sourceMappingURL=crypto.d.ts.map

package/dist/src/account-lib/util/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../../../src/account-lib/util/crypto.ts"],"names":[],"mappings":";AAMA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGjD;;;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;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAEpD"}

package/dist/src/account-lib/util/crypto.js

@@ -0,0 +1,269 @@
+"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.toUint8Array = 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;
+const bip32 = __importStar(require("bip32"));
+const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+const nacl = __importStar(require("tweetnacl"));
+const hex = __importStar(require("@stablelib/hex"));
+const bls = __importStar(require("noble-bls12-381"));
+const strip_hex_prefix_1 = __importDefault(require("strip-hex-prefix"));
+const 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');
+    }
+    const { privateKey } = bip32.fromBase58(xprv, bitcoinjs_lib_1.networks.bitcoin);
+    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) {
+    const 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 {
+        const decodedPrv = 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 {
+        const decodedPrv = 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 {
+        const 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(strip_hex_prefix_1.default(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) {
+    const 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;
+/**
+ * Returns a Uint8Array of the given hex string
+ *
+ * @param {string} str - the hex string to be converted
+ * @returns {string} - the Uint8Array value
+ */
+function toUint8Array(str) {
+    return hex.decode(str);
+}
+exports.toUint8Array = toUint8Array;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"crypto.js","sourceRoot":"","sources":["../../../../src/account-lib/util/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 'strip-hex-prefix';\nimport { ExtendedKeys } from '../baseCoin/iface';\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\n/**\n * Returns a Uint8Array of the given hex string\n *\n * @param {string} str - the hex string to be converted\n * @returns {string} - the Uint8Array value\n */\nexport function toUint8Array(str: string): Uint8Array {\n  return hex.decode(str);\n}\n"]}

package/dist/src/account-lib/util/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/account-lib/util/ed25519KeyDeriver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ed25519KeyDeriver.d.ts","sourceRoot":"","sources":["../../../../src/account-lib/util/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/account-lib/util/ed25519KeyDeriver.js

@@ -0,0 +1,87 @@
+"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
+ */
+const 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
+ */
+class Ed25519KeyDeriver {
+    /**
+     * Derive a SLIP-0010 key given a path and master key seed.
+     *
+     * @param path derivation path
+     * @param seed key seed
+     */
+    static derivePath(path, seed) {
+        if (!this.isValidPath(path)) {
+            throw new Error('Invalid derivation path');
+        }
+        const { key, chainCode } = this.getMasterKeyFromSeed(seed);
+        const segments = path.split('/').slice(1).map(this.replaceDerive);
+        return segments.reduce((parentKeys, segment) => this.CKDPriv(parentKeys, segment + Ed25519KeyDeriver.HARDENED_OFFSET), { key, chainCode });
+    }
+    /**
+     * Generate a SLIP-0010 master key from the entropy seed
+     *
+     * @param seed master key seed used to recreate master key
+     */
+    static getMasterKeyFromSeed(seed) {
+        const hmac = create_hmac_1.default('sha512', Ed25519KeyDeriver.ED25519_CURVE);
+        const I = hmac.update(Buffer.from(seed, 'hex')).digest();
+        const IL = I.slice(0, 32);
+        const 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
+     */
+    static CKDPriv({ key, chainCode }, index) {
+        const indexBuffer = Buffer.allocUnsafe(4);
+        indexBuffer.writeUInt32BE(index, 0);
+        const data = Buffer.concat([Buffer.alloc(1, 0), key, indexBuffer]);
+        const I = create_hmac_1.default('sha512', chainCode).update(data).digest();
+        const IL = I.slice(0, 32);
+        const IR = I.slice(32);
+        return {
+            key: IL,
+            chainCode: IR,
+        };
+    }
+    static isValidPath(path) {
+        if (!Ed25519KeyDeriver.PATH_REGEX.test(path)) {
+            return false;
+        }
+        return !path.split('/').slice(1).map(this.replaceDerive).some(isNaN);
+    }
+}
+exports.Ed25519KeyDeriver = 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".
+ */
+Ed25519KeyDeriver.ED25519_CURVE = 'ed25519 seed';
+Ed25519KeyDeriver.HARDENED_OFFSET = 0x80000000;
+Ed25519KeyDeriver.PATH_REGEX = new RegExp("^m(\\/[0-9]+')+$");
+Ed25519KeyDeriver.replaceDerive = (val) => parseInt(val.replace("'", ''), 10);
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/api/bip32path.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @prettier
+ */
+/**
+ * BitGoJS includes some custom hand-rolled bip32 derivation logic in `bitcoin.ts`, which sadly
+ * has numerous bugs.
+ *
+ * One of the effects is that the methods accept invalid bip32 paths:
+ * - the `m` prefix is ignored ('m/0' === '0')
+ * - path components that cannot be parsed as base-10 numbers are mapped to `0` ('0/x' === '0/0')
+ * - path components with trailing characters after numerals are accepted, trailing characters
+ *   are ignored ('1x' === '1')
+ *
+ * This probably does not cover everything but it should cover most bugs encountered in our code.
+ *
+ * This method attempts to convert a "legacy path", which may be invalid, to a standard bip32 path:
+ * meaning the result should be equivalent to the input path when passed to either our custom
+ * derivation log or when passed to a standard bip32 library.
+ *
+ * @param path - legacy path
+ * @return string - somewhat sanitized path that can be passed to standard bip32 libraries
+ */
+export declare function sanitizeLegacyPath(path: string): string;
+//# sourceMappingURL=bip32path.d.ts.map

package/dist/src/api/bip32path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bip32path.d.ts","sourceRoot":"","sources":["../../../src/api/bip32path.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAkBvD"}

package/dist/src/api/bip32path.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * @prettier
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeLegacyPath = void 0;
+/**
+ * BitGoJS includes some custom hand-rolled bip32 derivation logic in `bitcoin.ts`, which sadly
+ * has numerous bugs.
+ *
+ * One of the effects is that the methods accept invalid bip32 paths:
+ * - the `m` prefix is ignored ('m/0' === '0')
+ * - path components that cannot be parsed as base-10 numbers are mapped to `0` ('0/x' === '0/0')
+ * - path components with trailing characters after numerals are accepted, trailing characters
+ *   are ignored ('1x' === '1')
+ *
+ * This probably does not cover everything but it should cover most bugs encountered in our code.
+ *
+ * This method attempts to convert a "legacy path", which may be invalid, to a standard bip32 path:
+ * meaning the result should be equivalent to the input path when passed to either our custom
+ * derivation log or when passed to a standard bip32 library.
+ *
+ * @param path - legacy path
+ * @return string - somewhat sanitized path that can be passed to standard bip32 libraries
+ */
+function sanitizeLegacyPath(path) {
+    const parts = path
+        .split('/')
+        .filter((p) => p !== '')
+        .filter((p, i) => i !== 0 || p !== 'm')
+        .map((p) => {
+        const hardened = p.slice(-1) === "'";
+        const v = parseInt(p.slice(0, hardened ? -1 : undefined), 10);
+        if (Number.isNaN(v)) {
+            return '0';
+        }
+        return String(v) + (hardened ? "'" : '');
+    });
+    if (parts.length === 0) {
+        throw new Error(`empty path`);
+    }
+    return parts.join('/');
+}
+exports.sanitizeLegacyPath = sanitizeLegacyPath;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/api/index.d.ts

@@ -0,0 +1,3 @@
+export * from './bip32path';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC"}

package/dist/src/{v2 → api}/index.js

@@ -10,6 +10,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./environments"), exports);
+__exportStar(require("./bip32path"), exports);
 __exportStar(require("./types"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdjIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7O0FBQUEsaURBQStCO0FBQy9CLDBDQUF3QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZW52aXJvbm1lbnRzJztcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXBpL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7OztBQUFBLDhDQUE0QjtBQUM1QiwwQ0FBd0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2JpcDMycGF0aCc7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbiJdfQ==