@bitgo/sdk-core 1.1.0-rc.0 → 1.1.0-rc.3

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

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+export declare function bigIntFromBufferLE(buf: Buffer): bigint;
+export declare function bigIntToBufferLE(n: bigint, bytes?: number): Buffer;
+export declare function bigIntFromBufferBE(buf: Buffer): bigint;
+export declare function bigIntFromU8ABE(buf: Uint8Array): bigint;
+export declare function bigIntToBufferBE(n: bigint, bytes?: number): Buffer;
+export declare function clamp(u: bigint): bigint;
+//# sourceMappingURL=util.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../../src/account-lib/mpc/util.ts"],"names":[],"mappings":";AAAA,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAQlE;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,CAEvD;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAQlE;AAED,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAIvC"}

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clamp = exports.bigIntToBufferBE = exports.bigIntFromU8ABE = exports.bigIntFromBufferBE = exports.bigIntToBufferLE = exports.bigIntFromBufferLE = void 0;
+function bigIntFromBufferLE(buf) {
+    return BigInt('0x' + Buffer.from(buf).reverse().toString('hex'));
+}
+exports.bigIntFromBufferLE = bigIntFromBufferLE;
+function bigIntToBufferLE(n, bytes) {
+    let v = n.toString(16);
+    v = '0'.slice(0, v.length % 2) + v;
+    const buf = Buffer.from(v, 'hex').reverse();
+    if (bytes && buf.length < bytes) {
+        return Buffer.concat([buf, Buffer.alloc(bytes - buf.length)]);
+    }
+    return buf;
+}
+exports.bigIntToBufferLE = bigIntToBufferLE;
+function bigIntFromBufferBE(buf) {
+    return BigInt('0x' + buf.toString('hex'));
+}
+exports.bigIntFromBufferBE = bigIntFromBufferBE;
+function bigIntFromU8ABE(buf) {
+    return bigIntFromBufferBE(Buffer.from(buf));
+}
+exports.bigIntFromU8ABE = bigIntFromU8ABE;
+function bigIntToBufferBE(n, bytes) {
+    let v = n.toString(16);
+    v = '0'.slice(0, v.length % 2) + v;
+    const buf = Buffer.from(v, 'hex');
+    if (bytes && buf.length < bytes) {
+        return Buffer.concat([Buffer.alloc(bytes - buf.length), buf]);
+    }
+    return buf;
+}
+exports.bigIntToBufferBE = bigIntToBufferBE;
+function clamp(u) {
+    u &= BigInt('0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8');
+    u |= BigInt('0x4000000000000000000000000000000000000000000000000000000000000000');
+    return u;
+}
+exports.clamp = clamp;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -28,7 +28,7 @@ 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 ethereumjs_utils_old_1 = require("ethereumjs-utils-old");
+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)
@@ -211,7 +211,7 @@ exports.isValidBLSPrivateKey = isValidBLSPrivateKey;
  */
 function isValidBLSPublicKey(pub) {
     try {
-        bls.PointG1.fromCompressedHex(ethereumjs_utils_old_1.stripHexPrefix(pub)).assertValidity();
+        bls.PointG1.fromCompressedHex(strip_hex_prefix_1.default(pub)).assertValidity();
         return true;
     }
     catch (e) {
@@ -266,4 +266,4 @@ 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 'ethereumjs-utils-old';\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"]}
+//# 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/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==

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

@@ -0,0 +1,20 @@
+import * as superagent from 'superagent';
+export interface BitGoRequest<ResultType = any> extends superagent.SuperAgentRequest {
+    result: (optionalField?: string) => Promise<ResultType>;
+}
+export interface DecryptOptions {
+    input: string;
+    password?: string;
+}
+export interface EncryptOptions {
+    input: string;
+    password?: string;
+}
+export interface GetSharingKeyOptions {
+    email: string;
+}
+export interface IRequestTracer {
+    inc(): void;
+    toString(): string;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/api/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,YAAY,CAAC;AAEzC,MAAM,WAAW,YAAY,CAAC,UAAU,GAAG,GAAG,CAAE,SAAQ,UAAU,CAAC,iBAAiB;IAClF,MAAM,EAAE,CAAC,aAAa,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;CACzD;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,cAAc;IAC7B,GAAG,IAAI,IAAI,CAAC;IACZ,QAAQ,IAAI,MAAM,CAAC;CACpB"}

package/dist/src/api/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXBpL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBzdXBlcmFnZW50IGZyb20gJ3N1cGVyYWdlbnQnO1xuXG5leHBvcnQgaW50ZXJmYWNlIEJpdEdvUmVxdWVzdDxSZXN1bHRUeXBlID0gYW55PiBleHRlbmRzIHN1cGVyYWdlbnQuU3VwZXJBZ2VudFJlcXVlc3Qge1xuICByZXN1bHQ6IChvcHRpb25hbEZpZWxkPzogc3RyaW5nKSA9PiBQcm9taXNlPFJlc3VsdFR5cGU+O1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIERlY3J5cHRPcHRpb25zIHtcbiAgaW5wdXQ6IHN0cmluZztcbiAgcGFzc3dvcmQ/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRW5jcnlwdE9wdGlvbnMge1xuICBpbnB1dDogc3RyaW5nO1xuICBwYXNzd29yZD86IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBHZXRTaGFyaW5nS2V5T3B0aW9ucyB7XG4gIGVtYWlsOiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgSVJlcXVlc3RUcmFjZXIge1xuICBpbmMoKTogdm9pZDtcbiAgdG9TdHJpbmcoKTogc3RyaW5nO1xufVxuIl19

package/dist/src/bitgo/baseCoin/baseCoin.d.ts

@@ -0,0 +1,230 @@
+/// <reference types="node" />
+import { InitiateRecoveryOptions } from '../recovery';
+import { BitGoBase } from '../bitgoBase';
+import { IEnterprises } from '../enterprise';
+import { IKeychains } from '../keychain';
+import { IMarkets } from '../market';
+import { IPendingApprovals } from '../pendingApproval';
+import { IWallets, IWallet } from '../wallet';
+import { IWebhooks } from '../webhook';
+import { IBaseCoin, ITransactionExplanation, VerifyTransactionOptions, VerifyAddressOptions, SupplementGenerateWalletOptions, KeychainsTriplet, KeyPair, ExtraPrebuildParamsOptions, TransactionPrebuild, PresignTransactionOptions, FeeEstimateOptions, PrecreateBitGoOptions, ParseTransactionOptions, ParsedTransaction, SignTransactionOptions, SignedTransaction, RecoverWalletTokenOptions, RecoverTokenTransaction } from './iBaseCoin';
+export declare abstract class BaseCoin implements IBaseCoin {
+    protected readonly bitgo: BitGoBase;
+    protected readonly _url: string;
+    protected readonly _enterprises: IEnterprises;
+    protected readonly _wallets: IWallets;
+    protected readonly _keychains: IKeychains;
+    protected readonly _webhooks: IWebhooks;
+    protected readonly _pendingApprovals: IPendingApprovals;
+    protected readonly _markets: IMarkets;
+    protected static readonly _coinTokenPatternSeparator = ":";
+    protected constructor(bitgo: BitGoBase);
+    url(suffix: string): string;
+    wallets(): IWallets;
+    enterprises(): IEnterprises;
+    keychains(): IKeychains;
+    webhooks(): IWebhooks;
+    pendingApprovals(): IPendingApprovals;
+    markets(): IMarkets;
+    static get coinTokenPatternSeparator(): string;
+    get type(): string;
+    /**
+     * Name of the chain which supports this coin (eg, 'btc', 'eth')
+     */
+    abstract getChain(): string;
+    /**
+     * Name of the coin family (eg. for tbtc, this would be btc)
+     */
+    abstract getFamily(): string;
+    /**
+     * Human readable full name for the coin
+     */
+    abstract getFullName(): string;
+    /**
+     * Flag for sending value of 0.
+     * @returns {boolean} True if okay to send 0 value, false otherwise
+     */
+    valuelessTransferAllowed(): boolean;
+    /**
+     * Use `sendMany()` to perform wallet sweep.
+     * FIXME(BG-39738): add coin.sweepWallet() instead
+     */
+    sweepWithSendMany(): boolean;
+    /**
+     * Flag for sending data along with transactions
+     * @returns {boolean} True if okay to send tx data (ETH), false otherwise
+     */
+    transactionDataAllowed(): boolean;
+    /**
+     * Flag for determining whether this coin supports account consolidations
+     * from its receive addresses to the root address.
+     * @returns {boolean} True if okay to consolidate over this coin; false, otherwise
+     */
+    allowsAccountConsolidations(): boolean;
+    /**
+     * Flag indicating if this coin supports TSS wallets.
+     * @returns {boolean} True if TSS Wallets can be created for this coin
+     */
+    supportsTss(): boolean;
+    /**
+     * Flag indicating if this coin supports BLS-DKG wallets.
+     * @returns {boolean} True if BLS-DKG Wallets can be created for this coin
+     */
+    supportsBlsDkg(): boolean;
+    /**
+     * Returns the factor between the base unit and its smallest subdivison
+     * @return {number}
+     */
+    abstract getBaseFactor(): number | string;
+    /**
+     * Convert a currency amount represented in base units (satoshi, wei, atoms, drops, stroops)
+     * to big units (btc, eth, xrp, xlm)
+     */
+    baseUnitsToBigUnits(baseUnits: string | number): string;
+    /**
+     * Convert a currency amount represented in big units (btc, eth, xrp, xlm)
+     * to base units (satoshi, wei, atoms, drops, stroops)
+     * @param bigUnits
+     */
+    bigUnitsToBaseUnits(bigUnits: string | number): string;
+    /**
+     * Sign message with private key
+     *
+     * @param key
+     * @param message
+     */
+    signMessage(key: {
+        prv: string;
+    }, message: string): Promise<Buffer>;
+    /**
+     * Decompose a raw transaction into useful information.
+     * @param options - coin-specific
+     */
+    explainTransaction(options: Record<string, any>): Promise<ITransactionExplanation<any, string | number> | undefined>;
+    /**
+     * Verify that a transaction prebuild complies with the original intention
+     */
+    abstract verifyTransaction(params: VerifyTransactionOptions): Promise<boolean>;
+    /**
+     * @deprecated use {@see isWalletAddress} instead
+     */
+    verifyAddress(params: VerifyAddressOptions): boolean;
+    /**
+     * @param params
+     * @return true iff address is a wallet address. Must return false if address is outside wallet.
+     */
+    abstract isWalletAddress(params: VerifyAddressOptions): boolean;
+    /**
+     * convert address into desired address format.
+     * @param address
+     * @param format
+     */
+    canonicalAddress(address: string, format?: unknown): string;
+    /**
+     * Check whether a coin supports blockTarget for transactions to be included in
+     * @returns {boolean}
+     */
+    supportsBlockTarget(): boolean;
+    /**
+     * Hook to add additional parameters to the wallet generation
+     * @param walletParams
+     * @param keychains
+     * @return {*}
+     */
+    supplementGenerateWallet(walletParams: SupplementGenerateWalletOptions, keychains: KeychainsTriplet): Promise<any>;
+    /**
+     * Get extra parameters for prebuilding a tx. Add things like hop transaction params
+     */
+    getExtraPrebuildParams(buildParams: ExtraPrebuildParamsOptions): Promise<Record<string, unknown>>;
+    /**
+     * Modify prebuild after receiving it from the server. Add things like nlocktime
+     */
+    postProcessPrebuild(prebuildResponse: TransactionPrebuild): Promise<TransactionPrebuild>;
+    /**
+     * Coin-specific things done before signing a transaction, i.e. verification
+     */
+    presignTransaction(params: PresignTransactionOptions): Promise<PresignTransactionOptions>;
+    /**
+     * Create a new wallet object from a wallet data object
+     * @param walletParams
+     */
+    newWalletObject(walletParams: any): IWallet;
+    /**
+     * Fetch fee estimate information from the server
+     * @param {Object} params The params passed into the function
+     * @param {Integer} params.numBlocks The number of blocks to target for conformation (Only works for btc)
+     * @returns {Object} The info returned from the merchant server
+     */
+    feeEstimate(params: FeeEstimateOptions): Promise<any>;
+    /**
+     * The cold wallet tool uses this function to derive an extended key that is based on the passed key and seed
+     * @param key
+     * @param seed
+     * @returns {{key: string, derivationPath: string}}
+     */
+    deriveKeyWithSeed({ key, seed }: {
+        key: string;
+        seed: string;
+    }): {
+        key: string;
+        derivationPath: string;
+    };
+    /**
+     * Specifies what key we will need for signing - right now we just need the
+     * user key.
+     */
+    keyIdsForSigning(): number[];
+    /**
+     * Perform additional checks before adding a bitgo key. Base controller
+     * is a no-op, but coin-specific controller may do something
+     * @param params
+     */
+    preCreateBitGo(params: PrecreateBitGoOptions): void;
+    /**
+     * @deprecated - use getBip32Keys() in conjunction with isValidAddress instead
+     */
+    initiateRecovery(params: InitiateRecoveryOptions): never;
+    abstract parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction>;
+    /**
+     * Generate a key pair on the curve used by the coin
+     *
+     * @param seed
+     */
+    abstract generateKeyPair(seed?: Buffer): KeyPair;
+    /**
+     * Return boolean indicating whether input is valid public key for the coin.
+     *
+     * @param {String} pub the pub to be checked
+     * @returns {Boolean} is it valid?
+     */
+    abstract isValidPub(pub: string): boolean;
+    /**
+     * Return wether the given m of n wallet signers/ key amounts are valid for the coin
+     */
+    isValidMofNSetup({ m, n }: {
+        m?: number;
+        n?: number;
+    }): boolean;
+    /**
+     * Check if `address` is a plausibly valid address for the given coin.
+     *
+     * Does not verify that the address belongs to a wallet. For that,
+     * use [[verifyAddress]]
+     * @param address
+     */
+    abstract isValidAddress(address: string): boolean;
+    /**
+     * Sign a transaction
+     */
+    abstract signTransaction(params: SignTransactionOptions): Promise<SignedTransaction>;
+    /**
+     * Returns the portion of the transaction that needs to be signed in Buffer format.
+     * Only needed for coins that support adding signatures directly (e.g. TSS).
+     *
+     * @param {String} serializedTx - the unsigned transaction in broadcast format
+     * @returns {Promise<Buffer>} - the portion of the transaction that needs to be signed
+     */
+    getSignablePayload(serializedTx: string): Promise<Buffer>;
+    recoverToken(params: RecoverWalletTokenOptions): Promise<RecoverTokenTransaction>;
+}
+//# sourceMappingURL=baseCoin.d.ts.map

package/dist/src/bitgo/baseCoin/baseCoin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseCoin.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/baseCoin/baseCoin.ts"],"names":[],"mappings":"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"}