@bitgo-beta/abstract-utxo 1.1.1-beta.201 → 1.1.1-beta.2011

package/dist/esm/address/fixedScript.d.ts

@@ -0,0 +1,44 @@
+import { CreateAddressFormat, Triple } from '@bitgo-beta/sdk-core';
+import { fixedScriptWallet } from '@bitgo/wasm-utxo';
+import { UtxoCoinName } from '../names';
+type ChainCode = fixedScriptWallet.ChainCode;
+export interface FixedScriptAddressCoinSpecific {
+    outputScript?: string;
+}
+export interface GenerateAddressOptions {
+    chain?: number;
+    index?: number;
+    segwit?: boolean;
+    bech32?: boolean;
+}
+interface GenerateFixedScriptAddressOptions extends GenerateAddressOptions {
+    format?: CreateAddressFormat;
+    keychains: {
+        pub: string;
+    }[];
+}
+export declare function generateAddressWithChainAndIndex(coinName: UtxoCoinName, keychains: fixedScriptWallet.WalletKeysArg | Triple<string>, chain: ChainCode, index: number, format: CreateAddressFormat | undefined): string;
+/**
+ * Generate an address for a wallet based on a set of configurations
+ * @param params.keychains   {[object]} Array of objects with xpubs
+ * @param params.threshold   {number}   Minimum number of signatures
+ * @param params.chain       {number}   Derivation chain (see https://github.com/BitGo/unspents/blob/master/src/codes.ts for
+ *                                                 the corresponding address type of a given chain code)
+ * @param params.index       {number}   Derivation index
+ * @param params.segwit      {boolean}  Deprecated
+ * @param params.bech32      {boolean}  Deprecated
+ * @returns {string} The generated address
+ */
+export declare function generateAddress(coinName: UtxoCoinName, params: GenerateFixedScriptAddressOptions): string;
+type Keychain = {
+    pub: string;
+};
+export declare function assertFixedScriptWalletAddress(coinName: UtxoCoinName, { chain, index, keychains, format, address, }: {
+    chain: number | undefined;
+    index: number;
+    keychains: Keychain[];
+    format: CreateAddressFormat;
+    address: string;
+}): void;
+export {};
+//# sourceMappingURL=fixedScript.d.ts.map

package/dist/esm/address/fixedScript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixedScript.d.ts","sourceRoot":"","sources":["../../../src/address/fixedScript.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,mBAAmB,EASnB,MAAM,EACP,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAGxC,KAAK,SAAS,GAAG,iBAAiB,CAAC,SAAS,CAAC;AAE7C,MAAM,WAAW,8BAA8B;IAC7C,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,UAAU,iCAAkC,SAAQ,sBAAsB;IACxE,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,SAAS,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC9B;AAaD,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,YAAY,EACtB,SAAS,EAAE,iBAAiB,CAAC,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,EAC3D,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,mBAAmB,GAAG,SAAS,GACtC,MAAM,CAKR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,iCAAiC,GAAG,MAAM,CAiEzG;AAED,KAAK,QAAQ,GAAG;IACd,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,YAAY,EACtB,EACE,KAAK,EACL,KAAK,EACL,SAAS,EACT,MAAM,EACN,OAAO,GACR,EAAE;IACD,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;CACjB,GACA,IAAI,CAqBN"}

package/dist/esm/address/fixedScript.js

@@ -0,0 +1,100 @@
+import _ from 'lodash';
+import { AddressTypeChainMismatchError, InvalidAddressDerivationPropertyError, UnexpectedAddressError, P2shP2wshUnsupportedError, P2trMusig2UnsupportedError, P2trUnsupportedError, P2wshUnsupportedError, UnsupportedAddressTypeError, isTriple, } from '@bitgo-beta/sdk-core';
+import { fixedScriptWallet } from '@bitgo/wasm-utxo';
+function supportsAddressType(coinName, addressType) {
+    return fixedScriptWallet.supportsScriptType(coinName, addressType);
+}
+/**
+ * Normalize script type aliases. "p2tr" is an alias for "p2trLegacy".
+ */
+function normalizeScriptType(scriptType) {
+    return scriptType === 'p2tr' ? 'p2trLegacy' : scriptType;
+}
+export function generateAddressWithChainAndIndex(coinName, keychains, chain, index, format) {
+    // Convert CreateAddressFormat to AddressFormat for wasm-utxo
+    // 'base58' -> 'default', 'cashaddr' -> 'cashaddr'
+    const wasmFormat = format === 'base58' ? 'default' : format;
+    return fixedScriptWallet.address(keychains, chain, index, coinName, wasmFormat);
+}
+/**
+ * Generate an address for a wallet based on a set of configurations
+ * @param params.keychains   {[object]} Array of objects with xpubs
+ * @param params.threshold   {number}   Minimum number of signatures
+ * @param params.chain       {number}   Derivation chain (see https://github.com/BitGo/unspents/blob/master/src/codes.ts for
+ *                                                 the corresponding address type of a given chain code)
+ * @param params.index       {number}   Derivation index
+ * @param params.segwit      {boolean}  Deprecated
+ * @param params.bech32      {boolean}  Deprecated
+ * @returns {string} The generated address
+ */
+export function generateAddress(coinName, params) {
+    let derivationIndex = 0;
+    if (_.isInteger(params.index) && params.index > 0) {
+        derivationIndex = params.index;
+    }
+    const { keychains, chain, segwit = false, bech32 = false } = params;
+    if (_.isNumber(chain) && _.isInteger(chain) && !fixedScriptWallet.ChainCode.is(chain)) {
+        throw new InvalidAddressDerivationPropertyError(`address validation failure: unrecognised chain code (${chain})`);
+    }
+    let derivationChain = fixedScriptWallet.ChainCode.value('p2sh', 'external');
+    if (_.isNumber(chain) && _.isInteger(chain) && fixedScriptWallet.ChainCode.is(chain)) {
+        derivationChain = chain;
+    }
+    function convertFlagsToAddressType() {
+        if (fixedScriptWallet.ChainCode.is(chain)) {
+            return fixedScriptWallet.ChainCode.scriptType(chain);
+        }
+        if (_.isBoolean(segwit) && segwit) {
+            return 'p2shP2wsh';
+        }
+        else if (_.isBoolean(bech32) && bech32) {
+            return 'p2wsh';
+        }
+        else {
+            return 'p2sh';
+        }
+    }
+    const addressType = normalizeScriptType(convertFlagsToAddressType());
+    if (addressType !== fixedScriptWallet.ChainCode.scriptType(derivationChain)) {
+        throw new AddressTypeChainMismatchError(addressType, derivationChain);
+    }
+    if (!supportsAddressType(coinName, addressType)) {
+        switch (addressType) {
+            case 'p2sh':
+                throw new Error(`internal error: p2sh should always be supported`);
+            case 'p2shP2wsh':
+                throw new P2shP2wshUnsupportedError();
+            case 'p2wsh':
+                throw new P2wshUnsupportedError();
+            case 'p2tr':
+            case 'p2trLegacy':
+                throw new P2trUnsupportedError();
+            case 'p2trMusig2':
+                throw new P2trMusig2UnsupportedError();
+            default:
+                throw new UnsupportedAddressTypeError();
+        }
+    }
+    if (!isTriple(keychains)) {
+        throw new Error('keychains must be a triple');
+    }
+    return generateAddressWithChainAndIndex(coinName, keychains.map((k) => k.pub), derivationChain, derivationIndex, params.format);
+}
+export function assertFixedScriptWalletAddress(coinName, { chain, index, keychains, format, address, }) {
+    if ((_.isUndefined(chain) && _.isUndefined(index)) || !(_.isFinite(chain) && _.isFinite(index))) {
+        throw new InvalidAddressDerivationPropertyError(`address validation failure: invalid chain (${chain}) or index (${index})`);
+    }
+    if (!keychains) {
+        throw new Error('missing required param keychains');
+    }
+    const expectedAddress = generateAddress(coinName, {
+        format,
+        keychains,
+        chain,
+        index,
+    });
+    if (expectedAddress !== address) {
+        throw new UnexpectedAddressError(`address validation failure: expected ${expectedAddress} but got ${address}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fixedScript.js","sourceRoot":"","sources":["../../../src/address/fixedScript.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AACvB,OAAO,EACL,6BAA6B,EAE7B,qCAAqC,EACrC,sBAAsB,EACtB,yBAAyB,EACzB,0BAA0B,EAC1B,oBAAoB,EACpB,qBAAqB,EACrB,2BAA2B,EAC3B,QAAQ,GAET,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAuBrD,SAAS,mBAAmB,CAAC,QAAsB,EAAE,WAA2B;IAC9E,OAAO,iBAAiB,CAAC,kBAAkB,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;AACrE,CAAC;AAED;;GAEG;AACH,SAAS,mBAAmB,CAAC,UAAmC;IAC9D,OAAO,UAAU,KAAK,MAAM,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,UAAU,CAAC;AAC3D,CAAC;AAED,MAAM,UAAU,gCAAgC,CAC9C,QAAsB,EACtB,SAA2D,EAC3D,KAAgB,EAChB,KAAa,EACb,MAAuC;IAEvC,6DAA6D;IAC7D,kDAAkD;IAClD,MAAM,UAAU,GAAG,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC;IAC5D,OAAO,iBAAiB,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC;AAClF,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,eAAe,CAAC,QAAsB,EAAE,MAAyC;IAC/F,IAAI,eAAe,GAAG,CAAC,CAAC;IACxB,IAAI,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,IAAK,MAAM,CAAC,KAAgB,GAAG,CAAC,EAAE,CAAC;QAC9D,eAAe,GAAG,MAAM,CAAC,KAAe,CAAC;IAC3C,CAAC;IAED,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,EAAE,MAAM,GAAG,KAAK,EAAE,GAAG,MAA2C,CAAC;IAEzG,IAAI,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;QACtF,MAAM,IAAI,qCAAqC,CAAC,wDAAwD,KAAK,GAAG,CAAC,CAAC;IACpH,CAAC;IAED,IAAI,eAAe,GAAc,iBAAiB,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACvF,IAAI,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,iBAAiB,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;QACrF,eAAe,GAAG,KAAK,CAAC;IAC1B,CAAC;IAED,SAAS,yBAAyB;QAChC,IAAI,iBAAiB,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1C,OAAO,iBAAiB,CAAC,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACvD,CAAC;QACD,IAAI,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;YAClC,OAAO,WAAW,CAAC;QACrB,CAAC;aAAM,IAAI,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;YACzC,OAAO,OAAO,CAAC;QACjB,CAAC;aAAM,CAAC;YACN,OAAO,MAAM,CAAC;QAChB,CAAC;IACH,CAAC;IAED,MAAM,WAAW,GAAG,mBAAmB,CAAC,yBAAyB,EAAE,CAAC,CAAC;IAErE,IAAI,WAAW,KAAK,iBAAiB,CAAC,SAAS,CAAC,UAAU,CAAC,eAAe,CAAC,EAAE,CAAC;QAC5E,MAAM,IAAI,6BAA6B,CAAC,WAAW,EAAE,eAAe,CAAC,CAAC;IACxE,CAAC;IAED,IAAI,CAAC,mBAAmB,CAAC,QAAQ,EAAE,WAAW,CAAC,EAAE,CAAC;QAChD,QAAQ,WAAW,EAAE,CAAC;YACpB,KAAK,MAAM;gBACT,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;YACrE,KAAK,WAAW;gBACd,MAAM,IAAI,yBAAyB,EAAE,CAAC;YACxC,KAAK,OAAO;gBACV,MAAM,IAAI,qBAAqB,EAAE,CAAC;YACpC,KAAK,MAAM,CAAC;YACZ,KAAK,YAAY;gBACf,MAAM,IAAI,oBAAoB,EAAE,CAAC;YACnC,KAAK,YAAY;gBACf,MAAM,IAAI,0BAA0B,EAAE,CAAC;YACzC;gBACE,MAAM,IAAI,2BAA2B,EAAE,CAAC;QAC5C,CAAC;IACH,CAAC;IAED,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;IAChD,CAAC;IAED,OAAO,gCAAgC,CACrC,QAAQ,EACR,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAmB,EAC7C,eAAe,EACf,eAAe,EACf,MAAM,CAAC,MAAM,CACd,CAAC;AACJ,CAAC;AAMD,MAAM,UAAU,8BAA8B,CAC5C,QAAsB,EACtB,EACE,KAAK,EACL,KAAK,EACL,SAAS,EACT,MAAM,EACN,OAAO,GAOR;IAED,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;QAChG,MAAM,IAAI,qCAAqC,CAC7C,8CAA8C,KAAK,eAAe,KAAK,GAAG,CAC3E,CAAC;IACJ,CAAC;IAED,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAC;IACtD,CAAC;IAED,MAAM,eAAe,GAAG,eAAe,CAAC,QAAQ,EAAE;QAChD,MAAM;QACN,SAAS;QACT,KAAK;QACL,KAAK;KACN,CAAC,CAAC;IAEH,IAAI,eAAe,KAAK,OAAO,EAAE,CAAC;QAChC,MAAM,IAAI,sBAAsB,CAAC,wCAAwC,eAAe,YAAY,OAAO,EAAE,CAAC,CAAC;IACjH,CAAC;AACH,CAAC","sourcesContent":["import _ from 'lodash';\nimport {\n  AddressTypeChainMismatchError,\n  CreateAddressFormat,\n  InvalidAddressDerivationPropertyError,\n  UnexpectedAddressError,\n  P2shP2wshUnsupportedError,\n  P2trMusig2UnsupportedError,\n  P2trUnsupportedError,\n  P2wshUnsupportedError,\n  UnsupportedAddressTypeError,\n  isTriple,\n  Triple,\n} from '@bitgo-beta/sdk-core';\nimport { fixedScriptWallet } from '@bitgo/wasm-utxo';\n\nimport { UtxoCoinName } from '../names';\n\ntype ScriptType2Of3 = fixedScriptWallet.OutputScriptType;\ntype ChainCode = fixedScriptWallet.ChainCode;\n\nexport interface FixedScriptAddressCoinSpecific {\n  outputScript?: string;\n}\n\nexport interface GenerateAddressOptions {\n  chain?: number;\n  index?: number;\n  segwit?: boolean;\n  bech32?: boolean;\n}\n\ninterface GenerateFixedScriptAddressOptions extends GenerateAddressOptions {\n  format?: CreateAddressFormat;\n  keychains: { pub: string }[];\n}\n\nfunction supportsAddressType(coinName: UtxoCoinName, addressType: ScriptType2Of3): boolean {\n  return fixedScriptWallet.supportsScriptType(coinName, addressType);\n}\n\n/**\n * Normalize script type aliases. \"p2tr\" is an alias for \"p2trLegacy\".\n */\nfunction normalizeScriptType(scriptType: ScriptType2Of3 | 'p2tr'): ScriptType2Of3 {\n  return scriptType === 'p2tr' ? 'p2trLegacy' : scriptType;\n}\n\nexport function generateAddressWithChainAndIndex(\n  coinName: UtxoCoinName,\n  keychains: fixedScriptWallet.WalletKeysArg | Triple<string>,\n  chain: ChainCode,\n  index: number,\n  format: CreateAddressFormat | undefined\n): string {\n  // Convert CreateAddressFormat to AddressFormat for wasm-utxo\n  // 'base58' -> 'default', 'cashaddr' -> 'cashaddr'\n  const wasmFormat = format === 'base58' ? 'default' : format;\n  return fixedScriptWallet.address(keychains, chain, index, coinName, wasmFormat);\n}\n\n/**\n * Generate an address for a wallet based on a set of configurations\n * @param params.keychains   {[object]} Array of objects with xpubs\n * @param params.threshold   {number}   Minimum number of signatures\n * @param params.chain       {number}   Derivation chain (see https://github.com/BitGo/unspents/blob/master/src/codes.ts for\n *                                                 the corresponding address type of a given chain code)\n * @param params.index       {number}   Derivation index\n * @param params.segwit      {boolean}  Deprecated\n * @param params.bech32      {boolean}  Deprecated\n * @returns {string} The generated address\n */\nexport function generateAddress(coinName: UtxoCoinName, params: GenerateFixedScriptAddressOptions): string {\n  let derivationIndex = 0;\n  if (_.isInteger(params.index) && (params.index as number) > 0) {\n    derivationIndex = params.index as number;\n  }\n\n  const { keychains, chain, segwit = false, bech32 = false } = params as GenerateFixedScriptAddressOptions;\n\n  if (_.isNumber(chain) && _.isInteger(chain) && !fixedScriptWallet.ChainCode.is(chain)) {\n    throw new InvalidAddressDerivationPropertyError(`address validation failure: unrecognised chain code (${chain})`);\n  }\n\n  let derivationChain: ChainCode = fixedScriptWallet.ChainCode.value('p2sh', 'external');\n  if (_.isNumber(chain) && _.isInteger(chain) && fixedScriptWallet.ChainCode.is(chain)) {\n    derivationChain = chain;\n  }\n\n  function convertFlagsToAddressType(): ScriptType2Of3 {\n    if (fixedScriptWallet.ChainCode.is(chain)) {\n      return fixedScriptWallet.ChainCode.scriptType(chain);\n    }\n    if (_.isBoolean(segwit) && segwit) {\n      return 'p2shP2wsh';\n    } else if (_.isBoolean(bech32) && bech32) {\n      return 'p2wsh';\n    } else {\n      return 'p2sh';\n    }\n  }\n\n  const addressType = normalizeScriptType(convertFlagsToAddressType());\n\n  if (addressType !== fixedScriptWallet.ChainCode.scriptType(derivationChain)) {\n    throw new AddressTypeChainMismatchError(addressType, derivationChain);\n  }\n\n  if (!supportsAddressType(coinName, addressType)) {\n    switch (addressType) {\n      case 'p2sh':\n        throw new Error(`internal error: p2sh should always be supported`);\n      case 'p2shP2wsh':\n        throw new P2shP2wshUnsupportedError();\n      case 'p2wsh':\n        throw new P2wshUnsupportedError();\n      case 'p2tr':\n      case 'p2trLegacy':\n        throw new P2trUnsupportedError();\n      case 'p2trMusig2':\n        throw new P2trMusig2UnsupportedError();\n      default:\n        throw new UnsupportedAddressTypeError();\n    }\n  }\n\n  if (!isTriple(keychains)) {\n    throw new Error('keychains must be a triple');\n  }\n\n  return generateAddressWithChainAndIndex(\n    coinName,\n    keychains.map((k) => k.pub) as Triple<string>,\n    derivationChain,\n    derivationIndex,\n    params.format\n  );\n}\n\ntype Keychain = {\n  pub: string;\n};\n\nexport function assertFixedScriptWalletAddress(\n  coinName: UtxoCoinName,\n  {\n    chain,\n    index,\n    keychains,\n    format,\n    address,\n  }: {\n    chain: number | undefined;\n    index: number;\n    keychains: Keychain[];\n    format: CreateAddressFormat;\n    address: string;\n  }\n): void {\n  if ((_.isUndefined(chain) && _.isUndefined(index)) || !(_.isFinite(chain) && _.isFinite(index))) {\n    throw new InvalidAddressDerivationPropertyError(\n      `address validation failure: invalid chain (${chain}) or index (${index})`\n    );\n  }\n\n  if (!keychains) {\n    throw new Error('missing required param keychains');\n  }\n\n  const expectedAddress = generateAddress(coinName, {\n    format,\n    keychains,\n    chain,\n    index,\n  });\n\n  if (expectedAddress !== address) {\n    throw new UnexpectedAddressError(`address validation failure: expected ${expectedAddress} but got ${address}`);\n  }\n}\n"]}

package/dist/esm/address/index.d.ts

@@ -0,0 +1,2 @@
+export { generateAddress, generateAddressWithChainAndIndex, assertFixedScriptWalletAddress, FixedScriptAddressCoinSpecific, } from './fixedScript';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/address/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/address/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,gCAAgC,EAChC,8BAA8B,EAC9B,8BAA8B,GAC/B,MAAM,eAAe,CAAC"}

package/dist/esm/address/index.js

@@ -0,0 +1,2 @@
+export { generateAddress, generateAddressWithChainAndIndex, assertFixedScriptWalletAddress, } from './fixedScript';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYWRkcmVzcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsZUFBZSxFQUNmLGdDQUFnQyxFQUNoQyw4QkFBOEIsR0FFL0IsTUFBTSxlQUFlLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQge1xuICBnZW5lcmF0ZUFkZHJlc3MsXG4gIGdlbmVyYXRlQWRkcmVzc1dpdGhDaGFpbkFuZEluZGV4LFxuICBhc3NlcnRGaXhlZFNjcmlwdFdhbGxldEFkZHJlc3MsXG4gIEZpeGVkU2NyaXB0QWRkcmVzc0NvaW5TcGVjaWZpYyxcbn0gZnJvbSAnLi9maXhlZFNjcmlwdCc7XG4iXX0=

package/dist/esm/config.d.ts

@@ -0,0 +1,9 @@
+export declare const supportedCrossChainRecoveries: {
+    btc: string[];
+    bch: string[];
+    ltc: string[];
+    bsv: string[];
+    doge: string[];
+    bcha: string[];
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/esm/config.js

@@ -0,0 +1,11 @@
+// Supported cross-chain recovery routes. The object index is the coin to be recovered, and the value is
+// an array of valid coins for recipient wallets of the original accidental/unintentional deposit.
+export const supportedCrossChainRecoveries = {
+    btc: ['bch', 'ltc', 'bsv', 'doge'],
+    bch: ['btc', 'ltc', 'bsv', 'doge'],
+    ltc: ['btc', 'bch', 'bsv', 'doge'],
+    bsv: ['btc', 'ltc', 'bch', 'doge'],
+    doge: ['btc', 'bch', 'ltc', 'bsv'],
+    bcha: ['btc', 'bch'],
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSx3R0FBd0c7QUFDeEcsa0dBQWtHO0FBQ2xHLE1BQU0sQ0FBQyxNQUFNLDZCQUE2QixHQUFHO0lBQzNDLEdBQUcsRUFBRSxDQUFDLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLE1BQU0sQ0FBQztJQUNsQyxHQUFHLEVBQUUsQ0FBQyxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLENBQUM7SUFDbEMsR0FBRyxFQUFFLENBQUMsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsTUFBTSxDQUFDO0lBQ2xDLEdBQUcsRUFBRSxDQUFDLEtBQUssRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLE1BQU0sQ0FBQztJQUNsQyxJQUFJLEVBQUUsQ0FBQyxLQUFLLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLENBQUM7SUFDbEMsSUFBSSxFQUFFLENBQUMsS0FBSyxFQUFFLEtBQUssQ0FBQztDQUNyQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gU3VwcG9ydGVkIGNyb3NzLWNoYWluIHJlY292ZXJ5IHJvdXRlcy4gVGhlIG9iamVjdCBpbmRleCBpcyB0aGUgY29pbiB0byBiZSByZWNvdmVyZWQsIGFuZCB0aGUgdmFsdWUgaXNcbi8vIGFuIGFycmF5IG9mIHZhbGlkIGNvaW5zIGZvciByZWNpcGllbnQgd2FsbGV0cyBvZiB0aGUgb3JpZ2luYWwgYWNjaWRlbnRhbC91bmludGVudGlvbmFsIGRlcG9zaXQuXG5leHBvcnQgY29uc3Qgc3VwcG9ydGVkQ3Jvc3NDaGFpblJlY292ZXJpZXMgPSB7XG4gIGJ0YzogWydiY2gnLCAnbHRjJywgJ2JzdicsICdkb2dlJ10sXG4gIGJjaDogWydidGMnLCAnbHRjJywgJ2JzdicsICdkb2dlJ10sXG4gIGx0YzogWydidGMnLCAnYmNoJywgJ2JzdicsICdkb2dlJ10sXG4gIGJzdjogWydidGMnLCAnbHRjJywgJ2JjaCcsICdkb2dlJ10sXG4gIGRvZ2U6IFsnYnRjJywgJ2JjaCcsICdsdGMnLCAnYnN2J10sXG4gIGJjaGE6IFsnYnRjJywgJ2JjaCddLFxufTtcbiJdfQ==

package/dist/esm/descriptor/NamedDescriptor.d.ts

@@ -0,0 +1,19 @@
+import * as t from 'io-ts';
+import { Descriptor, DescriptorPkType, bip32 } from '@bitgo/wasm-utxo';
+export declare const NamedDescriptor: t.IntersectionC<[t.TypeC<{
+    name: t.StringC;
+    value: t.StringC;
+}>, t.PartialC<{
+    signatures: t.UnionC<[t.ArrayC<t.StringC>, t.UndefinedC]>;
+}>]>;
+export type NamedDescriptor<T = string> = {
+    name: string;
+    value: T;
+    signatures?: string[];
+};
+export type NamedDescriptorNative = NamedDescriptor<Descriptor>;
+export declare function createNamedDescriptorWithSignature(name: string, descriptor: string | Descriptor, signingKey: bip32.BIP32Interface): NamedDescriptor;
+export declare function toNamedDescriptorNative(e: NamedDescriptor, pkType: DescriptorPkType): NamedDescriptorNative;
+export declare function hasValidSignature(descriptor: string | Descriptor, key: bip32.BIP32Interface, signatures: string[]): boolean;
+export declare function assertHasValidSignature(namedDescriptor: NamedDescriptor, key: bip32.BIP32Interface): void;
+//# sourceMappingURL=NamedDescriptor.d.ts.map

package/dist/esm/descriptor/NamedDescriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NamedDescriptor.d.ts","sourceRoot":"","sources":["../../../src/descriptor/NamedDescriptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC;AAC3B,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,KAAK,EAAW,MAAM,kBAAkB,CAAC;AAEhF,eAAO,MAAM,eAAe;;;;;IAW3B,CAAC;AAEF,MAAM,MAAM,eAAe,CAAC,CAAC,GAAG,MAAM,IAAI;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,CAAC,CAAC;IACT,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,eAAe,CAAC,UAAU,CAAC,CAAC;AAEhE,wBAAgB,kCAAkC,CAChD,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,GAAG,UAAU,EAC/B,UAAU,EAAE,KAAK,CAAC,cAAc,GAC/B,eAAe,CAOjB;AAED,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,eAAe,EAAE,MAAM,EAAE,gBAAgB,GAAG,qBAAqB,CAE3G;AAED,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,MAAM,GAAG,UAAU,EAC/B,GAAG,EAAE,KAAK,CAAC,cAAc,EACzB,UAAU,EAAE,MAAM,EAAE,GACnB,OAAO,CAST;AAED,wBAAgB,uBAAuB,CAAC,eAAe,EAAE,eAAe,EAAE,GAAG,EAAE,KAAK,CAAC,cAAc,GAAG,IAAI,CAIzG"}

package/dist/esm/descriptor/NamedDescriptor.js

@@ -0,0 +1,37 @@
+import * as t from 'io-ts';
+import { Descriptor, message } from '@bitgo/wasm-utxo';
+export const NamedDescriptor = t.intersection([
+    t.type({
+        name: t.string,
+        value: t.string,
+    }),
+    t.partial({
+        signatures: t.union([t.array(t.string), t.undefined]),
+    }),
+], 'NamedDescriptor');
+export function createNamedDescriptorWithSignature(name, descriptor, signingKey) {
+    if (typeof descriptor === 'string') {
+        descriptor = Descriptor.fromString(descriptor, 'derivable');
+    }
+    const value = descriptor.toString();
+    const signature = Buffer.from(message.signMessage(value, signingKey.privateKey)).toString('hex');
+    return { name, value, signatures: [signature] };
+}
+export function toNamedDescriptorNative(e, pkType) {
+    return { ...e, value: Descriptor.fromString(e.value, pkType) };
+}
+export function hasValidSignature(descriptor, key, signatures) {
+    if (typeof descriptor === 'string') {
+        descriptor = Descriptor.fromString(descriptor, 'derivable');
+    }
+    const descriptorString = descriptor.toString();
+    return signatures.some((signature) => {
+        return message.verifyMessage(descriptorString, key.publicKey, Buffer.from(signature, 'hex'));
+    });
+}
+export function assertHasValidSignature(namedDescriptor, key) {
+    if (!hasValidSignature(namedDescriptor.value, key, namedDescriptor.signatures ?? [])) {
+        throw new Error(`Descriptor ${namedDescriptor.name} does not have a valid signature (key=${key.toBase58()})`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/descriptor/assertDescriptorWalletAddress.d.ts

@@ -0,0 +1,5 @@
+import { descriptorWallet } from '@bitgo/wasm-utxo';
+import { UtxoCoinSpecific, VerifyAddressOptions } from '../abstractUtxoCoin';
+import { UtxoCoinName } from '../names';
+export declare function assertDescriptorWalletAddress(coinName: UtxoCoinName, params: VerifyAddressOptions<UtxoCoinSpecific>, descriptors: descriptorWallet.DescriptorMap): void;
+//# sourceMappingURL=assertDescriptorWalletAddress.d.ts.map

package/dist/esm/descriptor/assertDescriptorWalletAddress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertDescriptorWalletAddress.d.ts","sourceRoot":"","sources":["../../../src/descriptor/assertDescriptorWalletAddress.ts"],"names":[],"mappings":"AAEA,OAAO,EAAuB,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzE,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC7E,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAUxC,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,YAAY,EACtB,MAAM,EAAE,oBAAoB,CAAC,gBAAgB,CAAC,EAC9C,WAAW,EAAE,gBAAgB,CAAC,aAAa,GAC1C,IAAI,CAoBN"}

package/dist/esm/descriptor/assertDescriptorWalletAddress.js

@@ -0,0 +1,27 @@
+import assert from 'assert';
+import { address } from '@bitgo/wasm-utxo';
+class DescriptorAddressMismatchError extends Error {
+    constructor(descriptor, index, derivedAddress, expectedAddress) {
+        super(`Address mismatch for descriptor ${descriptor.toString()} at index ${index}: ${derivedAddress} !== ${expectedAddress}`);
+    }
+}
+export function assertDescriptorWalletAddress(coinName, params, descriptors) {
+    assert(params.coinSpecific);
+    assert('descriptorName' in params.coinSpecific);
+    assert('descriptorChecksum' in params.coinSpecific);
+    const { descriptorName, descriptorChecksum } = params.coinSpecific;
+    const descriptor = descriptors.get(params.coinSpecific.descriptorName);
+    if (!descriptor) {
+        throw new Error(`Descriptor ${descriptorName} not found`);
+    }
+    const checksum = descriptor.toString().slice(-8);
+    if (checksum !== descriptorChecksum) {
+        throw new Error(`Descriptor checksum mismatch for descriptor name=${descriptorName}: ${checksum} !== ${descriptorChecksum}`);
+    }
+    const derivedScript = Buffer.from(descriptor.atDerivationIndex(params.index).scriptPubkey());
+    const derivedAddress = address.fromOutputScriptWithCoin(derivedScript, coinName);
+    if (params.address !== derivedAddress) {
+        throw new DescriptorAddressMismatchError(descriptor, params.index, derivedAddress, params.address);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/descriptor/builder/builder.d.ts

@@ -0,0 +1,12 @@
+import { bip32, Descriptor } from '@bitgo/wasm-utxo';
+type DescriptorWithKeys<TName extends string> = {
+    name: TName;
+    keys: bip32.BIP32Interface[];
+    path: string;
+};
+export type DescriptorBuilder = DescriptorWithKeys<'Wsh2Of2'> | DescriptorWithKeys<'Wsh2Of3'> | (DescriptorWithKeys<'ShWsh2Of3CltvDrop' | 'Wsh2Of3CltvDrop'> & {
+    locktime: number;
+});
+export declare function getDescriptorFromBuilder(builder: DescriptorBuilder): Descriptor;
+export {};
+//# sourceMappingURL=builder.d.ts.map

package/dist/esm/descriptor/builder/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../../../src/descriptor/builder/builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAErD,KAAK,kBAAkB,CAAC,KAAK,SAAS,MAAM,IAAI;IAC9C,IAAI,EAAE,KAAK,CAAC;IACZ,IAAI,EAAE,KAAK,CAAC,cAAc,EAAE,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,iBAAiB,GACzB,kBAAkB,CAAC,SAAS,CAAC,GAC7B,kBAAkB,CAAC,SAAS,CAAC,GAM7B,CAAC,kBAAkB,CAAC,mBAAmB,GAAG,iBAAiB,CAAC,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAkCzF,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,iBAAiB,GAAG,UAAU,CAE/E"}

package/dist/esm/descriptor/builder/builder.js

@@ -0,0 +1,34 @@
+import { Descriptor } from '@bitgo/wasm-utxo';
+function toXPub(k) {
+    if (typeof k === 'string') {
+        return k;
+    }
+    return k.neutered().toBase58();
+}
+function multi(m, n, keys, path) {
+    if (n < m) {
+        throw new Error(`Cannot create ${m} of ${n} multisig`);
+    }
+    if (keys.length < n) {
+        throw new Error(`Not enough keys for ${m} of ${n} multisig: keys.length=${keys.length}`);
+    }
+    keys = keys.slice(0, n);
+    return `multi(${m},${keys.map((k) => `${toXPub(k)}/${path}`).join(',')})`;
+}
+function getDescriptorString(builder) {
+    switch (builder.name) {
+        case 'Wsh2Of3':
+            return `wsh(${multi(2, 3, builder.keys, builder.path)})`;
+        case 'Wsh2Of2':
+            return `wsh(${multi(2, 2, builder.keys, builder.path)})`;
+        case 'Wsh2Of3CltvDrop':
+            return `wsh(and_v(r:after(${builder.locktime}),${multi(2, 3, builder.keys, builder.path)}))`;
+        case 'ShWsh2Of3CltvDrop':
+            return `sh(${getDescriptorString({ ...builder, name: 'Wsh2Of3CltvDrop' })})`;
+    }
+    throw new Error(`Unknown descriptor template: ${builder}`);
+}
+export function getDescriptorFromBuilder(builder) {
+    return Descriptor.fromString(getDescriptorString(builder), 'derivable');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/descriptor/builder/index.d.ts

@@ -0,0 +1,3 @@
+export { getDescriptorFromBuilder, DescriptorBuilder } from './builder';
+export { parseDescriptor } from './parse';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/descriptor/builder/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/descriptor/builder/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AACxE,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC"}

package/dist/esm/descriptor/builder/index.js

@@ -0,0 +1,3 @@
+export { getDescriptorFromBuilder } from './builder';
+export { parseDescriptor } from './parse';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZGVzY3JpcHRvci9idWlsZGVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx3QkFBd0IsRUFBcUIsTUFBTSxXQUFXLENBQUM7QUFDeEUsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IGdldERlc2NyaXB0b3JGcm9tQnVpbGRlciwgRGVzY3JpcHRvckJ1aWxkZXIgfSBmcm9tICcuL2J1aWxkZXInO1xuZXhwb3J0IHsgcGFyc2VEZXNjcmlwdG9yIH0gZnJvbSAnLi9wYXJzZSc7XG4iXX0=

package/dist/esm/descriptor/builder/parse.d.ts

@@ -0,0 +1,5 @@
+import { Descriptor } from '@bitgo/wasm-utxo';
+import { DescriptorBuilder } from './builder';
+export declare function parseDescriptorNode(node: unknown): DescriptorBuilder;
+export declare function parseDescriptor(descriptor: Descriptor): DescriptorBuilder;
+//# sourceMappingURL=parse.d.ts.map

package/dist/esm/descriptor/builder/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../src/descriptor/builder/parse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE5D,OAAO,EAAE,iBAAiB,EAA4B,MAAM,WAAW,CAAC;AA4GxE,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,iBAAiB,CASpE;AAED,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,iBAAiB,CAMzE"}

package/dist/esm/descriptor/builder/parse.js

@@ -0,0 +1,112 @@
+import { BIP32 } from '@bitgo/wasm-utxo';
+import { getDescriptorFromBuilder } from './builder';
+function isUnaryNode(node, key) {
+    if (typeof node !== 'object' || node === null) {
+        return false;
+    }
+    const keys = Object.keys(node);
+    return keys.length === 1 && keys[0] === key;
+}
+function unwrapNode(node, path) {
+    let current = node;
+    for (const key of path) {
+        if (!isUnaryNode(current, key)) {
+            return undefined;
+        }
+        current = current[key];
+    }
+    return current;
+}
+function parseMulti(node) {
+    if (!Array.isArray(node)) {
+        throw new Error('Unexpected node');
+    }
+    const [threshold, ...keyNodes] = node;
+    if (typeof threshold !== 'number') {
+        throw new Error('Expected threshold number');
+    }
+    const keyWithPath = keyNodes.map((keyNode) => {
+        if (!isUnaryNode(keyNode, 'XPub')) {
+            throw new Error('Expected XPub node');
+        }
+        if (typeof keyNode.XPub !== 'string') {
+            throw new Error('Expected XPub string');
+        }
+        const parts = keyNode.XPub.split('/');
+        return { xpub: parts[0], path: parts.slice(1).join('/') };
+    });
+    const paths = keyWithPath.map((k) => k.path);
+    paths.forEach((path, i) => {
+        if (path !== paths[0]) {
+            throw new Error(`Expected all paths to be the same: ${path} !== ${paths[0]}`);
+        }
+    });
+    return {
+        threshold,
+        keys: keyWithPath.map((k) => BIP32.fromBase58(k.xpub)),
+        path: paths[0],
+    };
+}
+function parseWshMulti(node) {
+    const wshMsMulti = unwrapNode(node, ['Wsh', 'Ms', 'Multi']);
+    if (wshMsMulti) {
+        const { threshold, keys, path } = parseMulti(wshMsMulti);
+        let name;
+        if (threshold === 2 && keys.length === 2) {
+            name = 'Wsh2Of2';
+        }
+        else if (threshold === 2 && keys.length === 3) {
+            name = 'Wsh2Of3';
+        }
+        else {
+            throw new Error('Unexpected multisig');
+        }
+        return {
+            name,
+            keys,
+            path,
+        };
+    }
+}
+function parseCltvDrop(node, name, wrapping) {
+    const unwrapped = unwrapNode(node, wrapping);
+    if (!unwrapped) {
+        return;
+    }
+    if (Array.isArray(unwrapped) && unwrapped.length === 2) {
+        const [a, b] = unwrapped;
+        const dropAfterAbsLocktime = unwrapNode(a, ['Drop', 'After', 'absLockTime']);
+        if (typeof dropAfterAbsLocktime !== 'number') {
+            throw new Error('Expected absLockTime number');
+        }
+        if (!isUnaryNode(b, 'Multi')) {
+            throw new Error('Expected Multi node');
+        }
+        const multi = parseMulti(b.Multi);
+        if (multi.threshold === 2 && multi.keys.length === 3) {
+            return {
+                name,
+                locktime: dropAfterAbsLocktime,
+                keys: multi.keys,
+                path: multi.path,
+            };
+        }
+    }
+}
+export function parseDescriptorNode(node) {
+    const parsed = parseWshMulti(node) ??
+        parseCltvDrop(node, 'ShWsh2Of3CltvDrop', ['Sh', 'Wsh', 'Ms', 'AndV']) ??
+        parseCltvDrop(node, 'Wsh2Of3CltvDrop', ['Wsh', 'Ms', 'AndV']);
+    if (!parsed) {
+        throw new Error('Failed to parse descriptor node');
+    }
+    return parsed;
+}
+export function parseDescriptor(descriptor) {
+    const builder = parseDescriptorNode(descriptor.node());
+    if (getDescriptorFromBuilder(builder).toString() !== descriptor.toString()) {
+        throw new Error('Failed to parse descriptor');
+    }
+    return builder;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parse.js","sourceRoot":"","sources":["../../../../src/descriptor/builder/parse.ts"],"names":[],"mappings":"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","sourcesContent":["import { BIP32, bip32, Descriptor } from '@bitgo/wasm-utxo';\n\nimport { DescriptorBuilder, getDescriptorFromBuilder } from './builder';\n\ntype NodeUnary<Key extends string> = { [k in Key]: unknown };\n\nfunction isUnaryNode<TKey extends string>(node: unknown, key: TKey): node is NodeUnary<TKey> {\n  if (typeof node !== 'object' || node === null) {\n    return false;\n  }\n  const keys = Object.keys(node);\n  return keys.length === 1 && keys[0] === key;\n}\n\nfunction unwrapNode(node: unknown, path: string[]): unknown {\n  let current = node;\n  for (const key of path) {\n    if (!isUnaryNode(current, key)) {\n      return undefined;\n    }\n    current = current[key];\n  }\n  return current;\n}\n\nfunction parseMulti(node: unknown): {\n  threshold: number;\n  keys: bip32.BIP32Interface[];\n  path: string;\n} {\n  if (!Array.isArray(node)) {\n    throw new Error('Unexpected node');\n  }\n  const [threshold, ...keyNodes] = node;\n  if (typeof threshold !== 'number') {\n    throw new Error('Expected threshold number');\n  }\n  const keyWithPath = keyNodes.map((keyNode) => {\n    if (!isUnaryNode(keyNode, 'XPub')) {\n      throw new Error('Expected XPub node');\n    }\n    if (typeof keyNode.XPub !== 'string') {\n      throw new Error('Expected XPub string');\n    }\n    const parts = keyNode.XPub.split('/');\n    return { xpub: parts[0], path: parts.slice(1).join('/') };\n  });\n  const paths = keyWithPath.map((k) => k.path);\n  paths.forEach((path, i) => {\n    if (path !== paths[0]) {\n      throw new Error(`Expected all paths to be the same: ${path} !== ${paths[0]}`);\n    }\n  });\n  return {\n    threshold,\n    keys: keyWithPath.map((k) => BIP32.fromBase58(k.xpub)),\n    path: paths[0],\n  };\n}\n\nfunction parseWshMulti(node: unknown): DescriptorBuilder | undefined {\n  const wshMsMulti = unwrapNode(node, ['Wsh', 'Ms', 'Multi']);\n  if (wshMsMulti) {\n    const { threshold, keys, path } = parseMulti(wshMsMulti);\n    let name;\n    if (threshold === 2 && keys.length === 2) {\n      name = 'Wsh2Of2';\n    } else if (threshold === 2 && keys.length === 3) {\n      name = 'Wsh2Of3';\n    } else {\n      throw new Error('Unexpected multisig');\n    }\n    return {\n      name,\n      keys,\n      path,\n    };\n  }\n}\n\nfunction parseCltvDrop(\n  node: unknown,\n  name: 'Wsh2Of3CltvDrop' | 'ShWsh2Of3CltvDrop',\n  wrapping: string[]\n): DescriptorBuilder | undefined {\n  const unwrapped = unwrapNode(node, wrapping);\n  if (!unwrapped) {\n    return;\n  }\n  if (Array.isArray(unwrapped) && unwrapped.length === 2) {\n    const [a, b] = unwrapped;\n    const dropAfterAbsLocktime = unwrapNode(a, ['Drop', 'After', 'absLockTime']);\n    if (typeof dropAfterAbsLocktime !== 'number') {\n      throw new Error('Expected absLockTime number');\n    }\n    if (!isUnaryNode(b, 'Multi')) {\n      throw new Error('Expected Multi node');\n    }\n    const multi = parseMulti(b.Multi);\n    if (multi.threshold === 2 && multi.keys.length === 3) {\n      return {\n        name,\n        locktime: dropAfterAbsLocktime,\n        keys: multi.keys,\n        path: multi.path,\n      };\n    }\n  }\n}\n\nexport function parseDescriptorNode(node: unknown): DescriptorBuilder {\n  const parsed =\n    parseWshMulti(node) ??\n    parseCltvDrop(node, 'ShWsh2Of3CltvDrop', ['Sh', 'Wsh', 'Ms', 'AndV']) ??\n    parseCltvDrop(node, 'Wsh2Of3CltvDrop', ['Wsh', 'Ms', 'AndV']);\n  if (!parsed) {\n    throw new Error('Failed to parse descriptor node');\n  }\n  return parsed;\n}\n\nexport function parseDescriptor(descriptor: Descriptor): DescriptorBuilder {\n  const builder = parseDescriptorNode(descriptor.node());\n  if (getDescriptorFromBuilder(builder).toString() !== descriptor.toString()) {\n    throw new Error('Failed to parse descriptor');\n  }\n  return builder;\n}\n"]}

package/dist/esm/descriptor/createWallet/createDescriptorWallet.d.ts

@@ -0,0 +1,20 @@
+import { BitGoAPI } from '@bitgo-beta/sdk-api';
+import { AbstractUtxoCoin } from '../../abstractUtxoCoin';
+import { IDescriptorWallet } from '../descriptorWallet';
+import { NamedDescriptor } from '../NamedDescriptor';
+import { DescriptorFromKeys } from './createDescriptors';
+export declare function createDescriptorWallet(bitgo: BitGoAPI, coin: AbstractUtxoCoin, { descriptors, ...params }: {
+    type: 'hot';
+    label: string;
+    enterprise: string;
+    keys: string[];
+    descriptors: NamedDescriptor[];
+}): Promise<IDescriptorWallet>;
+export declare function createDescriptorWalletWithWalletPassphrase(bitgo: BitGoAPI, coin: AbstractUtxoCoin, { enterprise, walletPassphrase, descriptorsFromKeys, ...params }: {
+    label: string;
+    enterprise: string;
+    walletPassphrase: string;
+    descriptorsFromKeys: DescriptorFromKeys;
+    [key: string]: unknown;
+}): Promise<IDescriptorWallet>;
+//# sourceMappingURL=createDescriptorWallet.d.ts.map

package/dist/esm/descriptor/createWallet/createDescriptorWallet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createDescriptorWallet.d.ts","sourceRoot":"","sources":["../../../../src/descriptor/createWallet/createDescriptorWallet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAI/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAEzD,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,QAAQ,EACf,IAAI,EAAE,gBAAgB,EACtB,EACE,WAAW,EACX,GAAG,MAAM,EACV,EAAE;IACD,IAAI,EAAE,KAAK,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,WAAW,EAAE,eAAe,EAAE,CAAC;CAChC,GACA,OAAO,CAAC,iBAAiB,CAAC,CAW5B;AAED,wBAAsB,0CAA0C,CAC9D,KAAK,EAAE,QAAQ,EACf,IAAI,EAAE,gBAAgB,EACtB,EACE,UAAU,EACV,gBAAgB,EAChB,mBAAmB,EACnB,GAAG,MAAM,EACV,EAAE;IACD,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;IACzB,mBAAmB,EAAE,kBAAkB,CAAC;IACxC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,GACA,OAAO,CAAC,iBAAiB,CAAC,CAqB5B"}