@bitgo-beta/utxo-lib 8.0.3-beta.13 → 8.0.3-beta.1300

package/dist/src/bitgo/wallet/WalletKeys.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RootWalletKeys = exports.DerivedWalletKeys = exports.WalletKeys = exports.eqPublicKey = void 0;
+exports.RootWalletKeys = exports.DerivedWalletKeys = exports.WalletKeys = void 0;
+exports.eqPublicKey = eqPublicKey;
 function eqPublicKey(a, b) {
     return a.publicKey.equals(b.publicKey);
 }
-exports.eqPublicKey = eqPublicKey;
 /**
  * Base class for RootWalletKeys and DerivedWalletKeys.
  * Keys can be either public keys or private keys.
@@ -101,4 +101,4 @@ class RootWalletKeys extends WalletKeys {
 }
 exports.RootWalletKeys = RootWalletKeys;
 RootWalletKeys.defaultPrefix = '0/0';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"WalletKeys.js","sourceRoot":"","sources":["../../../../src/bitgo/wallet/WalletKeys.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Classes for deriving key triples for wallet addresses.\n *\n * By default, BitGo wallets consist of a triple of bip32 extend keypairs.\n * Every wallet address can be identified by _(chain: number, index: number)_.\n * The key set for a particular address can be obtained by deriving with the path\n * `0/0/${chain}/${index}`. (In rare cases the prefix 0/0 can be different)\n *\n * Since we never use other derivations for utxo address scripts, the classes defined here only\n * allow exactly one level of derivation.\n */\nimport { BIP32Interface } from 'bip32';\n\nimport { Triple } from '../types';\n\nexport type KeyName = 'user' | 'backup' | 'bitgo';\n\nexport function eqPublicKey(a: BIP32Interface, b: BIP32Interface): boolean {\n  return a.publicKey.equals(b.publicKey);\n}\n\n/**\n * Base class for RootWalletKeys and DerivedWalletKeys.\n * Keys can be either public keys or private keys.\n */\nexport class WalletKeys {\n  public readonly publicKeys: Triple<Buffer>;\n\n  /**\n   * @param triple - bip32 key triple\n   */\n  constructor(public readonly triple: Triple<BIP32Interface>) {\n    triple.forEach((a, i) => {\n      triple.forEach((b, j) => {\n        if (eqPublicKey(a, b) && i !== j) {\n          throw new Error(`wallet keys must be distinct`);\n        }\n      });\n    });\n\n    this.publicKeys = this.triple.map((k) => k.publicKey) as Triple<Buffer>;\n  }\n\n  get user(): BIP32Interface {\n    return this.triple[0];\n  }\n\n  get backup(): BIP32Interface {\n    return this.triple[1];\n  }\n\n  get bitgo(): BIP32Interface {\n    return this.triple[2];\n  }\n}\n\n/**\n * Set of WalletKeys derived from RootWalletKeys. Suitable for signing transaction inputs.\n * Contains reference to the RootWalletKeys this was derived from as well as the paths used\n * for derivation.\n */\nexport class DerivedWalletKeys extends WalletKeys {\n  /**\n   * @param parent - wallet keys to derive from\n   * @param paths - paths to derive with\n   */\n  constructor(public parent: RootWalletKeys, public paths: Triple<string>) {\n    super(parent.triple.map((k, i) => k.derivePath(paths[i])) as Triple<BIP32Interface>);\n  }\n}\n\n/**\n * Set of root wallet keys, typically instantiated using the wallet xpub triple.\n */\nexport class RootWalletKeys extends WalletKeys {\n  static readonly defaultPrefix = '0/0';\n\n  /**\n   * @param triple - bip32 key triple\n   * @param derivationPrefixes - Certain v1 wallets or their migrated v2 counterparts\n   *                             can have a nonstandard prefix.\n   */\n  constructor(\n    triple: Triple<BIP32Interface>,\n    public readonly derivationPrefixes: Triple<string> = [\n      RootWalletKeys.defaultPrefix,\n      RootWalletKeys.defaultPrefix,\n      RootWalletKeys.defaultPrefix,\n    ]\n  ) {\n    super(triple);\n\n    derivationPrefixes.forEach((p) => {\n      if (p.startsWith('/') || p.endsWith('/')) {\n        throw new Error(`derivation prefix must not start or end with a slash`);\n      }\n    });\n  }\n\n  /**\n   * @param key\n   * @param chain\n   * @param index\n   * @return full derivation path for key, including key-specific prefix\n   */\n  getDerivationPath(key: BIP32Interface, chain: number, index: number): string {\n    if (!this.derivationPrefixes) {\n      throw new Error(`no derivation prefixes`);\n    }\n    const prefix = this.derivationPrefixes.find((prefix, i) => eqPublicKey(key, this.triple[i]));\n    if (prefix === undefined) {\n      throw new Error(`key not in walletKeys`);\n    }\n    return `${prefix}/${chain}/${index}`;\n  }\n\n  /**\n   * @param chain\n   * @param index\n   * @return walletKeys for a particular address identified by (chain, index)\n   */\n  deriveForChainAndIndex(chain: number, index: number): DerivedWalletKeys {\n    return new DerivedWalletKeys(\n      this,\n      this.triple.map((k) => this.getDerivationPath(k, chain, index)) as Triple<string>\n    );\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"WalletKeys.js","sourceRoot":"","sources":["../../../../src/bitgo/wallet/WalletKeys.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Classes for deriving key triples for wallet addresses.\n *\n * By default, BitGo wallets consist of a triple of bip32 extend keypairs.\n * Every wallet address can be identified by _(chain: number, index: number)_.\n * The key set for a particular address can be obtained by deriving with the path\n * `0/0/${chain}/${index}`. (In rare cases the prefix 0/0 can be different)\n *\n * Since we never use other derivations for utxo address scripts, the classes defined here only\n * allow exactly one level of derivation.\n */\nimport { BIP32Interface } from '@bitgo-beta/secp256k1';\n\nimport { Triple } from '../types';\n\nexport type KeyName = 'user' | 'backup' | 'bitgo';\n\nexport function eqPublicKey(a: BIP32Interface, b: BIP32Interface): boolean {\n  return a.publicKey.equals(b.publicKey);\n}\n\n/**\n * Base class for RootWalletKeys and DerivedWalletKeys.\n * Keys can be either public keys or private keys.\n */\nexport class WalletKeys {\n  public readonly publicKeys: Triple<Buffer>;\n\n  /**\n   * @param triple - bip32 key triple\n   */\n  constructor(public readonly triple: Triple<BIP32Interface>) {\n    triple.forEach((a, i) => {\n      triple.forEach((b, j) => {\n        if (eqPublicKey(a, b) && i !== j) {\n          throw new Error(`wallet keys must be distinct`);\n        }\n      });\n    });\n\n    this.publicKeys = this.triple.map((k) => k.publicKey) as Triple<Buffer>;\n  }\n\n  get user(): BIP32Interface {\n    return this.triple[0];\n  }\n\n  get backup(): BIP32Interface {\n    return this.triple[1];\n  }\n\n  get bitgo(): BIP32Interface {\n    return this.triple[2];\n  }\n}\n\n/**\n * Set of WalletKeys derived from RootWalletKeys. Suitable for signing transaction inputs.\n * Contains reference to the RootWalletKeys this was derived from as well as the paths used\n * for derivation.\n */\nexport class DerivedWalletKeys extends WalletKeys {\n  /**\n   * @param parent - wallet keys to derive from\n   * @param paths - paths to derive with\n   */\n  constructor(public parent: RootWalletKeys, public paths: Triple<string>) {\n    super(parent.triple.map((k, i) => k.derivePath(paths[i])) as Triple<BIP32Interface>);\n  }\n}\n\n/**\n * Set of root wallet keys, typically instantiated using the wallet xpub triple.\n */\nexport class RootWalletKeys extends WalletKeys {\n  static readonly defaultPrefix = '0/0';\n\n  /**\n   * @param triple - bip32 key triple\n   * @param derivationPrefixes - Certain v1 wallets or their migrated v2 counterparts\n   *                             can have a nonstandard prefix.\n   */\n  constructor(\n    triple: Triple<BIP32Interface>,\n    public readonly derivationPrefixes: Triple<string> = [\n      RootWalletKeys.defaultPrefix,\n      RootWalletKeys.defaultPrefix,\n      RootWalletKeys.defaultPrefix,\n    ]\n  ) {\n    super(triple);\n\n    derivationPrefixes.forEach((p) => {\n      if (p.startsWith('/') || p.endsWith('/')) {\n        throw new Error(`derivation prefix must not start or end with a slash`);\n      }\n    });\n  }\n\n  /**\n   * @param key\n   * @param chain\n   * @param index\n   * @return full derivation path for key, including key-specific prefix\n   */\n  getDerivationPath(key: BIP32Interface, chain: number, index: number): string {\n    if (!this.derivationPrefixes) {\n      throw new Error(`no derivation prefixes`);\n    }\n    const prefix = this.derivationPrefixes.find((prefix, i) => eqPublicKey(key, this.triple[i]));\n    if (prefix === undefined) {\n      throw new Error(`key not in walletKeys`);\n    }\n    return `${prefix}/${chain}/${index}`;\n  }\n\n  /**\n   * @param chain\n   * @param index\n   * @return walletKeys for a particular address identified by (chain, index)\n   */\n  deriveForChainAndIndex(chain: number, index: number): DerivedWalletKeys {\n    return new DerivedWalletKeys(\n      this,\n      this.triple.map((k) => this.getDerivationPath(k, chain, index)) as Triple<string>\n    );\n  }\n}\n"]}

package/dist/src/bitgo/wallet/WalletOutput.d.ts

@@ -1,10 +1,62 @@
+import { Payment } from 'bitcoinjs-lib';
+import { PsbtOutput, PsbtOutputUpdate } from 'bip174/src/lib/interfaces';
 import { UtxoPsbt } from '../UtxoPsbt';
-import { RootWalletKeys } from './WalletKeys';
+import { RootWalletKeys, DerivedWalletKeys } from './WalletKeys';
 import { ChainCode } from './chains';
+import { ScriptId } from './ScriptId';
+/**
+ * Get the BIP32 derivation data for a PSBT output.
+ *
+ * @param rootWalletKeys root wallet keys used for master fingerprints
+ * @param walletKeys derived wallet keys for the specific chain and index
+ * @param scriptType the script type to determine whether to use regular or taproot derivation
+ * @param payment optional payment object for taproot scripts to calculate leaf hashes
+ * @returns Object containing BIP32 derivation data
+ */
+export declare function getPsbtBip32DerivationOutputUpdate(rootWalletKeys: RootWalletKeys, walletKeys: DerivedWalletKeys, scriptType: string, payment?: Payment): PsbtOutputUpdate;
+/**
+ * Get the PSBT output update object from a PSBT output and output script.
+ *
+ * @param output the PSBT output to get update for
+ * @param outputScript the output script
+ * @param rootWalletKeys keys that will be able to spend the output
+ * @param chain chain code to use for deriving scripts (and to determine script type)
+ * @param index derivation index for the change address
+ * @returns PsbtOutputUpdate object with the required information
+ */
+export declare function getPsbtOutputUpdateFromPsbtOutput(output: PsbtOutput, outputScript: Buffer, rootWalletKeys: RootWalletKeys, chain: ChainCode, index: number): PsbtOutputUpdate;
+/**
+ * Get the PSBT output update object with the required information.
+ *
+ * @param psbt the PSBT to get output update for
+ * @param rootWalletKeys keys that will be able to spend the output
+ * @param outputIndex output index where to update the output
+ * @param chain chain code to use for deriving scripts (and to determine script
+ *              type) chain is an API parameter in the BitGo API, and may be
+ *              any valid ChainCode
+ * @param index derivation index for the change address
+ * @returns PsbtOutputUpdate object with the required information
+ */
+export declare function getPsbtOutputUpdate(psbt: UtxoPsbt, rootWalletKeys: RootWalletKeys, outputIndex: number, chain: ChainCode, index: number): PsbtOutputUpdate;
+/**
+ * Update the wallet output with the required information when necessary. If the
+ * information is there already, it will skip over it.
+ *
+ * This function assumes that the output script and value have already been set.
+ *
+ * @param psbt the PSBT to update change output at
+ * @param rootWalletKeys keys that will be able to spend the output
+ * @param outputIndex output index where to update the output
+ * @param chain chain code to use for deriving scripts (and to determine script
+ *              type) chain is an API parameter in the BitGo API, and may be
+ *              any valid ChainCode
+ * @param index derivation index for the change address
+ */
+export declare function updateWalletOutputForPsbt(psbt: UtxoPsbt, rootWalletKeys: RootWalletKeys, outputIndex: number, chain: ChainCode, index: number): void;
 /**
  * Add a verifiable wallet output to the PSBT. The output and all data
  * needed to verify it from public keys only are added to the PSBT.
- * Typically these are change outputs
+ * Typically these are change outputs.
  *
  * @param psbt the PSBT to add change output to
  * @param rootWalletKeys keys that will be able to spend the output
@@ -15,4 +67,20 @@ import { ChainCode } from './chains';
  * @param value value of the change output
  */
 export declare function addWalletOutputToPsbt(psbt: UtxoPsbt, rootWalletKeys: RootWalletKeys, chain: ChainCode, index: number, value: bigint): void;
+/**
+ * Get the script id from the output.
+ * The output can have either bip32Derivation or tapBip32Derivation, but not both.
+ * @param output
+ * @throws Error if neither or both bip32Derivation and tapBip32Derivation are present
+ * @throws Error if the output is empty
+ * @throws Error if we cannot fold the script ids into a single script id
+ */
+export declare function getScriptIdFromOutput(output: {
+    bip32Derivation?: {
+        path: string;
+    }[];
+    tapBip32Derivation?: {
+        path: string;
+    }[];
+}): ScriptId;
 //# sourceMappingURL=WalletOutput.d.ts.map

package/dist/src/bitgo/wallet/WalletOutput.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WalletOutput.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/wallet/WalletOutput.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAsB,MAAM,UAAU,CAAC;AAGzD;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,QAAQ,EACd,cAAc,EAAE,cAAc,EAC9B,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GACZ,IAAI,CAgDN"}
+{"version":3,"file":"WalletOutput.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/wallet/WalletOutput.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAW,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AACzE,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACjE,OAAO,EAAE,SAAS,EAAsB,MAAM,UAAU,CAAC;AACzD,OAAO,EAAuB,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3D;;;;;;;;GAQG;AACH,wBAAgB,kCAAkC,CAChD,cAAc,EAAE,cAAc,EAC9B,UAAU,EAAE,iBAAiB,EAC7B,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,OAAO,GAChB,gBAAgB,CAqClB;AAED;;;;;;;;;GASG;AACH,wBAAgB,iCAAiC,CAC/C,MAAM,EAAE,UAAU,EAClB,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,cAAc,EAC9B,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,MAAM,GACZ,gBAAgB,CA2ClB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,QAAQ,EACd,cAAc,EAAE,cAAc,EAC9B,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,MAAM,GACZ,gBAAgB,CAWlB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,QAAQ,EACd,cAAc,EAAE,cAAc,EAC9B,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,MAAM,GACZ,IAAI,CAEN;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,QAAQ,EACd,cAAc,EAAE,cAAc,EAC9B,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GACZ,IAAI,CAYN;AAqBD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC5C,eAAe,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACrC,kBAAkB,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACzC,GAAG,QAAQ,CAWX"}

package/dist/src/bitgo/wallet/WalletOutput.js

@@ -1,13 +1,147 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addWalletOutputToPsbt = void 0;
+exports.getPsbtBip32DerivationOutputUpdate = getPsbtBip32DerivationOutputUpdate;
+exports.getPsbtOutputUpdateFromPsbtOutput = getPsbtOutputUpdateFromPsbtOutput;
+exports.getPsbtOutputUpdate = getPsbtOutputUpdate;
+exports.updateWalletOutputForPsbt = updateWalletOutputForPsbt;
+exports.addWalletOutputToPsbt = addWalletOutputToPsbt;
+exports.getScriptIdFromOutput = getScriptIdFromOutput;
+const assert_1 = require("assert");
 const bitcoinjs_lib_1 = require("bitcoinjs-lib");
 const chains_1 = require("./chains");
+const ScriptId_1 = require("./ScriptId");
 const outputScripts_1 = require("../outputScripts");
+/**
+ * Get the BIP32 derivation data for a PSBT output.
+ *
+ * @param rootWalletKeys root wallet keys used for master fingerprints
+ * @param walletKeys derived wallet keys for the specific chain and index
+ * @param scriptType the script type to determine whether to use regular or taproot derivation
+ * @param payment optional payment object for taproot scripts to calculate leaf hashes
+ * @returns Object containing BIP32 derivation data
+ */
+function getPsbtBip32DerivationOutputUpdate(rootWalletKeys, walletKeys, scriptType, payment) {
+    const update = {};
+    if (scriptType === 'p2tr' || scriptType === 'p2trMusig2') {
+        if (!payment || !payment.redeems) {
+            throw new Error('Payment object with redeems is required for taproot derivation');
+        }
+        const allLeafHashes = payment.redeems.map((r) => bitcoinjs_lib_1.taproot.hashTapLeaf(r.output));
+        update.tapBip32Derivation = [0, 1, 2].map((idx) => {
+            const pubkey = (0, outputScripts_1.toXOnlyPublicKey)(walletKeys.triple[idx].publicKey);
+            const leafHashes = [];
+            (0, assert_1.ok)(payment.redeems);
+            payment.redeems.forEach((r, redeemIdx) => {
+                if (r.pubkeys.find((pk) => pk.equals(pubkey))) {
+                    leafHashes.push(allLeafHashes[redeemIdx]);
+                }
+            });
+            return {
+                leafHashes,
+                pubkey,
+                path: walletKeys.paths[idx],
+                masterFingerprint: rootWalletKeys.triple[idx].fingerprint,
+            };
+        });
+    }
+    else {
+        update.bip32Derivation = [0, 1, 2].map((idx) => ({
+            pubkey: walletKeys.triple[idx].publicKey,
+            path: walletKeys.paths[idx],
+            masterFingerprint: rootWalletKeys.triple[idx].fingerprint,
+        }));
+    }
+    return update;
+}
+/**
+ * Get the PSBT output update object from a PSBT output and output script.
+ *
+ * @param output the PSBT output to get update for
+ * @param outputScript the output script
+ * @param rootWalletKeys keys that will be able to spend the output
+ * @param chain chain code to use for deriving scripts (and to determine script type)
+ * @param index derivation index for the change address
+ * @returns PsbtOutputUpdate object with the required information
+ */
+function getPsbtOutputUpdateFromPsbtOutput(output, outputScript, rootWalletKeys, chain, index) {
+    const walletKeys = rootWalletKeys.deriveForChainAndIndex(chain, index);
+    const scriptType = (0, chains_1.scriptTypeForChain)(chain);
+    const update = {};
+    if (scriptType === 'p2tr' || scriptType === 'p2trMusig2') {
+        const payment = scriptType === 'p2tr' ? (0, outputScripts_1.createPaymentP2tr)(walletKeys.publicKeys) : (0, outputScripts_1.createPaymentP2trMusig2)(walletKeys.publicKeys);
+        if (!payment.output || !payment.output.equals(outputScript)) {
+            throw new Error(`cannot update a p2tr output where the scripts do not match - Failing.`);
+        }
+        if (!output.tapTree) {
+            update.tapTree = payment.tapTree;
+        }
+        if (!output.tapInternalKey) {
+            update.tapInternalKey = payment.internalPubkey;
+        }
+        if (!output.tapBip32Derivation) {
+            const derivationUpdate = getPsbtBip32DerivationOutputUpdate(rootWalletKeys, walletKeys, scriptType, payment);
+            update.tapBip32Derivation = derivationUpdate.tapBip32Derivation;
+        }
+    }
+    else {
+        const { scriptPubKey, witnessScript, redeemScript } = (0, outputScripts_1.createOutputScript2of3)(walletKeys.publicKeys, scriptType);
+        if (!scriptPubKey.equals(outputScript)) {
+            throw new Error(`cannot update an output where the scripts do not match - Failing.`);
+        }
+        if (!output.bip32Derivation) {
+            const derivationUpdate = getPsbtBip32DerivationOutputUpdate(rootWalletKeys, walletKeys, scriptType);
+            update.bip32Derivation = derivationUpdate.bip32Derivation;
+        }
+        if (!output.witnessScript && witnessScript) {
+            update.witnessScript = witnessScript;
+        }
+        if (!output.redeemScript && redeemScript) {
+            update.redeemScript = redeemScript;
+        }
+    }
+    return update;
+}
+/**
+ * Get the PSBT output update object with the required information.
+ *
+ * @param psbt the PSBT to get output update for
+ * @param rootWalletKeys keys that will be able to spend the output
+ * @param outputIndex output index where to update the output
+ * @param chain chain code to use for deriving scripts (and to determine script
+ *              type) chain is an API parameter in the BitGo API, and may be
+ *              any valid ChainCode
+ * @param index derivation index for the change address
+ * @returns PsbtOutputUpdate object with the required information
+ */
+function getPsbtOutputUpdate(psbt, rootWalletKeys, outputIndex, chain, index) {
+    if (psbt.data.outputs.length <= outputIndex) {
+        throw new Error(`outputIndex (${outputIndex}) is too large for the number of outputs (${psbt.data.outputs.length})`);
+    }
+    const outputScript = psbt.getOutputScript(outputIndex);
+    const output = psbt.data.outputs[outputIndex];
+    return getPsbtOutputUpdateFromPsbtOutput(output, outputScript, rootWalletKeys, chain, index);
+}
+/**
+ * Update the wallet output with the required information when necessary. If the
+ * information is there already, it will skip over it.
+ *
+ * This function assumes that the output script and value have already been set.
+ *
+ * @param psbt the PSBT to update change output at
+ * @param rootWalletKeys keys that will be able to spend the output
+ * @param outputIndex output index where to update the output
+ * @param chain chain code to use for deriving scripts (and to determine script
+ *              type) chain is an API parameter in the BitGo API, and may be
+ *              any valid ChainCode
+ * @param index derivation index for the change address
+ */
+function updateWalletOutputForPsbt(psbt, rootWalletKeys, outputIndex, chain, index) {
+    psbt.updateOutput(outputIndex, getPsbtOutputUpdate(psbt, rootWalletKeys, outputIndex, chain, index));
+}
 /**
  * Add a verifiable wallet output to the PSBT. The output and all data
  * needed to verify it from public keys only are added to the PSBT.
- * Typically these are change outputs
+ * Typically these are change outputs.
  *
  * @param psbt the PSBT to add change output to
  * @param rootWalletKeys keys that will be able to spend the output
@@ -19,51 +153,53 @@ const outputScripts_1 = require("../outputScripts");
  */
 function addWalletOutputToPsbt(psbt, rootWalletKeys, chain, index, value) {
     const walletKeys = rootWalletKeys.deriveForChainAndIndex(chain, index);
-    const scriptType = chains_1.scriptTypeForChain(chain);
+    const scriptType = (0, chains_1.scriptTypeForChain)(chain);
     if (scriptType === 'p2tr' || scriptType === 'p2trMusig2') {
-        const payment = scriptType === 'p2tr' ? outputScripts_1.createPaymentP2tr(walletKeys.publicKeys) : outputScripts_1.createPaymentP2trMusig2(walletKeys.publicKeys);
-        const allLeafHashes = payment.redeems.map((r) => bitcoinjs_lib_1.taproot.hashTapLeaf(r.output));
-        psbt.addOutput({
-            script: payment.output,
-            value,
-            tapTree: payment.tapTree,
-            tapInternalKey: payment.internalPubkey,
-            tapBip32Derivation: [0, 1, 2].map((idx) => {
-                const pubkey = outputScripts_1.toXOnlyPublicKey(walletKeys.triple[idx].publicKey);
-                const leafHashes = [];
-                payment.redeems.forEach((r, idx) => {
-                    if (r.pubkeys.find((pk) => pk.equals(pubkey))) {
-                        leafHashes.push(allLeafHashes[idx]);
-                    }
-                });
-                return {
-                    leafHashes,
-                    pubkey,
-                    path: walletKeys.paths[idx],
-                    masterFingerprint: rootWalletKeys.triple[idx].fingerprint,
-                };
-            }),
-        });
+        const payment = scriptType === 'p2tr' ? (0, outputScripts_1.createPaymentP2tr)(walletKeys.publicKeys) : (0, outputScripts_1.createPaymentP2trMusig2)(walletKeys.publicKeys);
+        psbt.addOutput({ script: payment.output, value });
     }
     else {
-        const { scriptPubKey, witnessScript, redeemScript } = outputScripts_1.createOutputScript2of3(walletKeys.publicKeys, scriptType);
-        psbt.addOutput({
-            script: scriptPubKey,
-            value,
-            bip32Derivation: [0, 1, 2].map((idx) => ({
-                pubkey: walletKeys.triple[idx].publicKey,
-                path: walletKeys.paths[idx],
-                masterFingerprint: rootWalletKeys.triple[idx].fingerprint,
-            })),
-        });
-        const outputIndex = psbt.txOutputs.length - 1;
-        if (witnessScript) {
-            psbt.updateOutput(outputIndex, { witnessScript });
+        const { scriptPubKey: script } = (0, outputScripts_1.createOutputScript2of3)(walletKeys.publicKeys, scriptType);
+        psbt.addOutput({ script, value });
+    }
+    updateWalletOutputForPsbt(psbt, rootWalletKeys, psbt.data.outputs.length - 1, chain, index);
+}
+/**
+ * Fold the script ids into a single script id, if they are all the same.
+ * @param scriptIds
+ */
+function foldScriptIds(scriptIds) {
+    if (scriptIds.length === 0) {
+        throw new Error('cannot fold empty script ids');
+    }
+    scriptIds.forEach((scriptId, i) => {
+        if (scriptId.chain !== scriptIds[0].chain) {
+            throw new Error(`chain mismatch: ${scriptId.chain} != ${scriptIds[0].chain}`);
         }
-        if (redeemScript) {
-            psbt.updateOutput(outputIndex, { redeemScript });
+        if (scriptId.index !== scriptIds[0].index) {
+            throw new Error(`index mismatch: ${scriptId.index} != ${scriptIds[0].index}`);
         }
+    });
+    return scriptIds[0];
+}
+/**
+ * Get the script id from the output.
+ * The output can have either bip32Derivation or tapBip32Derivation, but not both.
+ * @param output
+ * @throws Error if neither or both bip32Derivation and tapBip32Derivation are present
+ * @throws Error if the output is empty
+ * @throws Error if we cannot fold the script ids into a single script id
+ */
+function getScriptIdFromOutput(output) {
+    if (output.bip32Derivation && output.tapBip32Derivation) {
+        throw new Error('cannot get script id from output with both bip32Derivation and tapBip32Derivation');
+    }
+    if (output.bip32Derivation) {
+        return foldScriptIds(output.bip32Derivation.map((d) => (0, ScriptId_1.getScriptIdFromPath)(d.path)));
     }
+    if (output.tapBip32Derivation) {
+        return foldScriptIds(output.tapBip32Derivation.map((d) => (0, ScriptId_1.getScriptIdFromPath)(d.path)));
+    }
+    throw new Error('cannot get script id from output without bip32Derivation or tapBip32Derivation');
 }
-exports.addWalletOutputToPsbt = addWalletOutputToPsbt;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"WalletOutput.js","sourceRoot":"","sources":["../../../../src/bitgo/wallet/WalletOutput.ts"],"names":[],"mappings":"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","sourcesContent":["import { ok as assert } from 'assert';\n\nimport { Payment, taproot } from 'bitcoinjs-lib';\nimport { PsbtOutput, PsbtOutputUpdate } from 'bip174/src/lib/interfaces';\nimport { UtxoPsbt } from '../UtxoPsbt';\nimport { RootWalletKeys, DerivedWalletKeys } from './WalletKeys';\nimport { ChainCode, scriptTypeForChain } from './chains';\nimport { getScriptIdFromPath, ScriptId } from './ScriptId';\nimport { createOutputScript2of3, createPaymentP2tr, createPaymentP2trMusig2, toXOnlyPublicKey } from '../outputScripts';\n\n/**\n * Get the BIP32 derivation data for a PSBT output.\n *\n * @param rootWalletKeys root wallet keys used for master fingerprints\n * @param walletKeys derived wallet keys for the specific chain and index\n * @param scriptType the script type to determine whether to use regular or taproot derivation\n * @param payment optional payment object for taproot scripts to calculate leaf hashes\n * @returns Object containing BIP32 derivation data\n */\nexport function getPsbtBip32DerivationOutputUpdate(\n  rootWalletKeys: RootWalletKeys,\n  walletKeys: DerivedWalletKeys,\n  scriptType: string,\n  payment?: Payment\n): PsbtOutputUpdate {\n  const update: PsbtOutputUpdate = {};\n\n  if (scriptType === 'p2tr' || scriptType === 'p2trMusig2') {\n    if (!payment || !payment.redeems) {\n      throw new Error('Payment object with redeems is required for taproot derivation');\n    }\n\n    const allLeafHashes = payment.redeems.map((r) => taproot.hashTapLeaf(r.output!));\n\n    update.tapBip32Derivation = [0, 1, 2].map((idx) => {\n      const pubkey = toXOnlyPublicKey(walletKeys.triple[idx].publicKey);\n      const leafHashes: Buffer[] = [];\n\n      assert(payment.redeems);\n      payment.redeems.forEach((r: any, redeemIdx: number) => {\n        if (r.pubkeys!.find((pk: Buffer) => pk.equals(pubkey))) {\n          leafHashes.push(allLeafHashes[redeemIdx]);\n        }\n      });\n\n      return {\n        leafHashes,\n        pubkey,\n        path: walletKeys.paths[idx],\n        masterFingerprint: rootWalletKeys.triple[idx].fingerprint,\n      };\n    });\n  } else {\n    update.bip32Derivation = [0, 1, 2].map((idx) => ({\n      pubkey: walletKeys.triple[idx].publicKey,\n      path: walletKeys.paths[idx],\n      masterFingerprint: rootWalletKeys.triple[idx].fingerprint,\n    }));\n  }\n\n  return update;\n}\n\n/**\n * Get the PSBT output update object from a PSBT output and output script.\n *\n * @param output the PSBT output to get update for\n * @param outputScript the output script\n * @param rootWalletKeys keys that will be able to spend the output\n * @param chain chain code to use for deriving scripts (and to determine script type)\n * @param index derivation index for the change address\n * @returns PsbtOutputUpdate object with the required information\n */\nexport function getPsbtOutputUpdateFromPsbtOutput(\n  output: PsbtOutput,\n  outputScript: Buffer,\n  rootWalletKeys: RootWalletKeys,\n  chain: ChainCode,\n  index: number\n): PsbtOutputUpdate {\n  const walletKeys = rootWalletKeys.deriveForChainAndIndex(chain, index);\n  const scriptType = scriptTypeForChain(chain);\n  const update: PsbtOutputUpdate = {};\n\n  if (scriptType === 'p2tr' || scriptType === 'p2trMusig2') {\n    const payment =\n      scriptType === 'p2tr' ? createPaymentP2tr(walletKeys.publicKeys) : createPaymentP2trMusig2(walletKeys.publicKeys);\n    if (!payment.output || !payment.output.equals(outputScript)) {\n      throw new Error(`cannot update a p2tr output where the scripts do not match - Failing.`);\n    }\n\n    if (!output.tapTree) {\n      update.tapTree = payment.tapTree;\n    }\n    if (!output.tapInternalKey) {\n      update.tapInternalKey = payment.internalPubkey;\n    }\n\n    if (!output.tapBip32Derivation) {\n      const derivationUpdate = getPsbtBip32DerivationOutputUpdate(rootWalletKeys, walletKeys, scriptType, payment);\n      update.tapBip32Derivation = derivationUpdate.tapBip32Derivation;\n    }\n  } else {\n    const { scriptPubKey, witnessScript, redeemScript } = createOutputScript2of3(walletKeys.publicKeys, scriptType);\n    if (!scriptPubKey.equals(outputScript)) {\n      throw new Error(`cannot update an output where the scripts do not match - Failing.`);\n    }\n\n    if (!output.bip32Derivation) {\n      const derivationUpdate = getPsbtBip32DerivationOutputUpdate(rootWalletKeys, walletKeys, scriptType);\n      update.bip32Derivation = derivationUpdate.bip32Derivation;\n    }\n\n    if (!output.witnessScript && witnessScript) {\n      update.witnessScript = witnessScript;\n    }\n    if (!output.redeemScript && redeemScript) {\n      update.redeemScript = redeemScript;\n    }\n  }\n\n  return update;\n}\n\n/**\n * Get the PSBT output update object with the required information.\n *\n * @param psbt the PSBT to get output update for\n * @param rootWalletKeys keys that will be able to spend the output\n * @param outputIndex output index where to update the output\n * @param chain chain code to use for deriving scripts (and to determine script\n *              type) chain is an API parameter in the BitGo API, and may be\n *              any valid ChainCode\n * @param index derivation index for the change address\n * @returns PsbtOutputUpdate object with the required information\n */\nexport function getPsbtOutputUpdate(\n  psbt: UtxoPsbt,\n  rootWalletKeys: RootWalletKeys,\n  outputIndex: number,\n  chain: ChainCode,\n  index: number\n): PsbtOutputUpdate {\n  if (psbt.data.outputs.length <= outputIndex) {\n    throw new Error(\n      `outputIndex (${outputIndex}) is too large for the number of outputs (${psbt.data.outputs.length})`\n    );\n  }\n\n  const outputScript = psbt.getOutputScript(outputIndex);\n  const output = psbt.data.outputs[outputIndex];\n\n  return getPsbtOutputUpdateFromPsbtOutput(output, outputScript, rootWalletKeys, chain, index);\n}\n\n/**\n * Update the wallet output with the required information when necessary. If the\n * information is there already, it will skip over it.\n *\n * This function assumes that the output script and value have already been set.\n *\n * @param psbt the PSBT to update change output at\n * @param rootWalletKeys keys that will be able to spend the output\n * @param outputIndex output index where to update the output\n * @param chain chain code to use for deriving scripts (and to determine script\n *              type) chain is an API parameter in the BitGo API, and may be\n *              any valid ChainCode\n * @param index derivation index for the change address\n */\nexport function updateWalletOutputForPsbt(\n  psbt: UtxoPsbt,\n  rootWalletKeys: RootWalletKeys,\n  outputIndex: number,\n  chain: ChainCode,\n  index: number\n): void {\n  psbt.updateOutput(outputIndex, getPsbtOutputUpdate(psbt, rootWalletKeys, outputIndex, chain, index));\n}\n\n/**\n * Add a verifiable wallet output to the PSBT. The output and all data\n * needed to verify it from public keys only are added to the PSBT.\n * Typically these are change outputs.\n *\n * @param psbt the PSBT to add change output to\n * @param rootWalletKeys keys that will be able to spend the output\n * @param chain chain code to use for deriving scripts (and to determine script\n *              type) chain is an API parameter in the BitGo API, and may be\n *              any valid ChainCode\n * @param index derivation index for the change address\n * @param value value of the change output\n */\nexport function addWalletOutputToPsbt(\n  psbt: UtxoPsbt,\n  rootWalletKeys: RootWalletKeys,\n  chain: ChainCode,\n  index: number,\n  value: bigint\n): void {\n  const walletKeys = rootWalletKeys.deriveForChainAndIndex(chain, index);\n  const scriptType = scriptTypeForChain(chain);\n  if (scriptType === 'p2tr' || scriptType === 'p2trMusig2') {\n    const payment =\n      scriptType === 'p2tr' ? createPaymentP2tr(walletKeys.publicKeys) : createPaymentP2trMusig2(walletKeys.publicKeys);\n    psbt.addOutput({ script: payment.output!, value });\n  } else {\n    const { scriptPubKey: script } = createOutputScript2of3(walletKeys.publicKeys, scriptType);\n    psbt.addOutput({ script, value });\n  }\n  updateWalletOutputForPsbt(psbt, rootWalletKeys, psbt.data.outputs.length - 1, chain, index);\n}\n\n/**\n * Fold the script ids into a single script id, if they are all the same.\n * @param scriptIds\n */\nfunction foldScriptIds(scriptIds: ScriptId[]): ScriptId {\n  if (scriptIds.length === 0) {\n    throw new Error('cannot fold empty script ids');\n  }\n  scriptIds.forEach((scriptId, i) => {\n    if (scriptId.chain !== scriptIds[0].chain) {\n      throw new Error(`chain mismatch: ${scriptId.chain} != ${scriptIds[0].chain}`);\n    }\n    if (scriptId.index !== scriptIds[0].index) {\n      throw new Error(`index mismatch: ${scriptId.index} != ${scriptIds[0].index}`);\n    }\n  });\n  return scriptIds[0];\n}\n\n/**\n * Get the script id from the output.\n * The output can have either bip32Derivation or tapBip32Derivation, but not both.\n * @param output\n * @throws Error if neither or both bip32Derivation and tapBip32Derivation are present\n * @throws Error if the output is empty\n * @throws Error if we cannot fold the script ids into a single script id\n */\nexport function getScriptIdFromOutput(output: {\n  bip32Derivation?: { path: string }[];\n  tapBip32Derivation?: { path: string }[];\n}): ScriptId {\n  if (output.bip32Derivation && output.tapBip32Derivation) {\n    throw new Error('cannot get script id from output with both bip32Derivation and tapBip32Derivation');\n  }\n  if (output.bip32Derivation) {\n    return foldScriptIds(output.bip32Derivation.map((d) => getScriptIdFromPath(d.path)));\n  }\n  if (output.tapBip32Derivation) {\n    return foldScriptIds(output.tapBip32Derivation.map((d) => getScriptIdFromPath(d.path)));\n  }\n  throw new Error('cannot get script id from output without bip32Derivation or tapBip32Derivation');\n}\n"]}

package/dist/src/bitgo/wallet/WalletScripts.js

@@ -1,15 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getWalletAddress = exports.getWalletOutputScripts = void 0;
+exports.getWalletOutputScripts = getWalletOutputScripts;
+exports.getWalletAddress = getWalletAddress;
 const __1 = require("../..");
 const __2 = require("..");
 const outputScripts_1 = require("../outputScripts");
 function getWalletOutputScripts(keys, chain, index) {
-    return __2.outputScripts.createOutputScript2of3(keys.deriveForChainAndIndex(chain, index).publicKeys, outputScripts_1.scriptTypeForChain(chain));
+    return __2.outputScripts.createOutputScript2of3(keys.deriveForChainAndIndex(chain, index).publicKeys, (0, outputScripts_1.scriptTypeForChain)(chain));
 }
-exports.getWalletOutputScripts = getWalletOutputScripts;
 function getWalletAddress(keys, chain, index, network) {
     return __1.address.fromOutputScript(getWalletOutputScripts(keys, chain, index).scriptPubKey, network);
 }
-exports.getWalletAddress = getWalletAddress;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiV2FsbGV0U2NyaXB0cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9iaXRnby93YWxsZXQvV2FsbGV0U2NyaXB0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSw2QkFBeUM7QUFDekMsMEJBQThDO0FBRTlDLG9EQUF1RTtBQUV2RSxTQUFnQixzQkFBc0IsQ0FBQyxJQUFvQixFQUFFLEtBQWdCLEVBQUUsS0FBYTtJQUMxRixPQUFPLGlCQUFhLENBQUMsc0JBQXNCLENBQ3pDLElBQUksQ0FBQyxzQkFBc0IsQ0FBQyxLQUFLLEVBQUUsS0FBSyxDQUFDLENBQUMsVUFBVSxFQUNwRCxrQ0FBa0IsQ0FBQyxLQUFLLENBQUMsQ0FDMUIsQ0FBQztBQUNKLENBQUM7QUFMRCx3REFLQztBQUVELFNBQWdCLGdCQUFnQixDQUFDLElBQW9CLEVBQUUsS0FBZ0IsRUFBRSxLQUFhLEVBQUUsT0FBZ0I7SUFDdEcsT0FBTyxXQUFPLENBQUMsZ0JBQWdCLENBQUMsc0JBQXNCLENBQUMsSUFBSSxFQUFFLEtBQUssRUFBRSxLQUFLLENBQUMsQ0FBQyxZQUFZLEVBQUUsT0FBTyxDQUFDLENBQUM7QUFDcEcsQ0FBQztBQUZELDRDQUVDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmV0d29yaywgYWRkcmVzcyB9IGZyb20gJy4uLy4uJztcbmltcG9ydCB7IENoYWluQ29kZSwgb3V0cHV0U2NyaXB0cyB9IGZyb20gJy4uJztcbmltcG9ydCB7IFJvb3RXYWxsZXRLZXlzIH0gZnJvbSAnLi9XYWxsZXRLZXlzJztcbmltcG9ydCB7IHNjcmlwdFR5cGVGb3JDaGFpbiwgU3BlbmRhYmxlU2NyaXB0IH0gZnJvbSAnLi4vb3V0cHV0U2NyaXB0cyc7XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRXYWxsZXRPdXRwdXRTY3JpcHRzKGtleXM6IFJvb3RXYWxsZXRLZXlzLCBjaGFpbjogQ2hhaW5Db2RlLCBpbmRleDogbnVtYmVyKTogU3BlbmRhYmxlU2NyaXB0IHtcbiAgcmV0dXJuIG91dHB1dFNjcmlwdHMuY3JlYXRlT3V0cHV0U2NyaXB0Mm9mMyhcbiAgICBrZXlzLmRlcml2ZUZvckNoYWluQW5kSW5kZXgoY2hhaW4sIGluZGV4KS5wdWJsaWNLZXlzLFxuICAgIHNjcmlwdFR5cGVGb3JDaGFpbihjaGFpbilcbiAgKTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGdldFdhbGxldEFkZHJlc3Moa2V5czogUm9vdFdhbGxldEtleXMsIGNoYWluOiBDaGFpbkNvZGUsIGluZGV4OiBudW1iZXIsIG5ldHdvcms6IE5ldHdvcmspOiBzdHJpbmcge1xuICByZXR1cm4gYWRkcmVzcy5mcm9tT3V0cHV0U2NyaXB0KGdldFdhbGxldE91dHB1dFNjcmlwdHMoa2V5cywgY2hhaW4sIGluZGV4KS5zY3JpcHRQdWJLZXksIG5ldHdvcmspO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiV2FsbGV0U2NyaXB0cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9iaXRnby93YWxsZXQvV2FsbGV0U2NyaXB0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUtBLHdEQUtDO0FBRUQsNENBRUM7QUFkRCw2QkFBeUM7QUFDekMsMEJBQThDO0FBRTlDLG9EQUF1RTtBQUV2RSxTQUFnQixzQkFBc0IsQ0FBQyxJQUFvQixFQUFFLEtBQWdCLEVBQUUsS0FBYTtJQUMxRixPQUFPLGlCQUFhLENBQUMsc0JBQXNCLENBQ3pDLElBQUksQ0FBQyxzQkFBc0IsQ0FBQyxLQUFLLEVBQUUsS0FBSyxDQUFDLENBQUMsVUFBVSxFQUNwRCxJQUFBLGtDQUFrQixFQUFDLEtBQUssQ0FBQyxDQUMxQixDQUFDO0FBQ0osQ0FBQztBQUVELFNBQWdCLGdCQUFnQixDQUFDLElBQW9CLEVBQUUsS0FBZ0IsRUFBRSxLQUFhLEVBQUUsT0FBZ0I7SUFDdEcsT0FBTyxXQUFPLENBQUMsZ0JBQWdCLENBQUMsc0JBQXNCLENBQUMsSUFBSSxFQUFFLEtBQUssRUFBRSxLQUFLLENBQUMsQ0FBQyxZQUFZLEVBQUUsT0FBTyxDQUFDLENBQUM7QUFDcEcsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5ldHdvcmssIGFkZHJlc3MgfSBmcm9tICcuLi8uLic7XG5pbXBvcnQgeyBDaGFpbkNvZGUsIG91dHB1dFNjcmlwdHMgfSBmcm9tICcuLic7XG5pbXBvcnQgeyBSb290V2FsbGV0S2V5cyB9IGZyb20gJy4vV2FsbGV0S2V5cyc7XG5pbXBvcnQgeyBzY3JpcHRUeXBlRm9yQ2hhaW4sIFNwZW5kYWJsZVNjcmlwdCB9IGZyb20gJy4uL291dHB1dFNjcmlwdHMnO1xuXG5leHBvcnQgZnVuY3Rpb24gZ2V0V2FsbGV0T3V0cHV0U2NyaXB0cyhrZXlzOiBSb290V2FsbGV0S2V5cywgY2hhaW46IENoYWluQ29kZSwgaW5kZXg6IG51bWJlcik6IFNwZW5kYWJsZVNjcmlwdCB7XG4gIHJldHVybiBvdXRwdXRTY3JpcHRzLmNyZWF0ZU91dHB1dFNjcmlwdDJvZjMoXG4gICAga2V5cy5kZXJpdmVGb3JDaGFpbkFuZEluZGV4KGNoYWluLCBpbmRleCkucHVibGljS2V5cyxcbiAgICBzY3JpcHRUeXBlRm9yQ2hhaW4oY2hhaW4pXG4gICk7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRXYWxsZXRBZGRyZXNzKGtleXM6IFJvb3RXYWxsZXRLZXlzLCBjaGFpbjogQ2hhaW5Db2RlLCBpbmRleDogbnVtYmVyLCBuZXR3b3JrOiBOZXR3b3JrKTogc3RyaW5nIHtcbiAgcmV0dXJuIGFkZHJlc3MuZnJvbU91dHB1dFNjcmlwdChnZXRXYWxsZXRPdXRwdXRTY3JpcHRzKGtleXMsIGNoYWluLCBpbmRleCkuc2NyaXB0UHViS2V5LCBuZXR3b3JrKTtcbn1cbiJdfQ==

package/dist/src/bitgo/wallet/WalletUnspentSigner.d.ts

@@ -1,4 +1,4 @@
-import { BIP32Interface } from 'bip32';
+import { BIP32Interface } from '@bitgo-beta/secp256k1';
 import { DerivedWalletKeys, RootWalletKeys, WalletKeys } from './WalletKeys';
 import { Triple } from '../types';
 export declare class WalletUnspentSigner<T extends WalletKeys> {

package/dist/src/bitgo/wallet/WalletUnspentSigner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WalletUnspentSigner.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/wallet/WalletUnspentSigner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,EAAE,iBAAiB,EAAe,cAAc,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1F,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,qBAAa,mBAAmB,CAAC,CAAC,SAAS,UAAU;IAgB1C,MAAM,EAAE,cAAc;IACtB,QAAQ,EAAE,cAAc;IAhBjC,SAAgB,UAAU,EAAE,CAAC,CAAC;IAE9B,MAAM,CAAC,IAAI,CACT,UAAU,EAAE,cAAc,EAC1B,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,cAAc,GACvB,mBAAmB,CAAC,cAAc,CAAC;IAItC,QAAQ,CAAC,WAAW,MAAC;IACrB,QAAQ,CAAC,aAAa,MAAC;gBAGrB,UAAU,EAAE,UAAU,GAAG,MAAM,CAAC,cAAc,CAAC,EACxC,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,cAAc;IAwBjC;;;;OAIG;IACH,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,mBAAmB,CAAC,iBAAiB,CAAC;CAe7F"}
+{"version":3,"file":"WalletUnspentSigner.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/wallet/WalletUnspentSigner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,OAAO,EAAE,iBAAiB,EAAe,cAAc,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1F,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,qBAAa,mBAAmB,CAAC,CAAC,SAAS,UAAU;IAgB1C,MAAM,EAAE,cAAc;IACtB,QAAQ,EAAE,cAAc;IAhBjC,SAAgB,UAAU,EAAE,CAAC,CAAC;IAE9B,MAAM,CAAC,IAAI,CACT,UAAU,EAAE,cAAc,EAC1B,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,cAAc,GACvB,mBAAmB,CAAC,cAAc,CAAC;IAItC,QAAQ,CAAC,WAAW,MAAC;IACrB,QAAQ,CAAC,aAAa,MAAC;gBAGrB,UAAU,EAAE,UAAU,GAAG,MAAM,CAAC,cAAc,CAAC,EACxC,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,cAAc;IAwBjC;;;;OAIG;IACH,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,mBAAmB,CAAC,iBAAiB,CAAC;CAe7F"}

package/dist/src/bitgo/wallet/WalletUnspentSigner.js

@@ -3,31 +3,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WalletUnspentSigner = void 0;
 const WalletKeys_1 = require("./WalletKeys");
 class WalletUnspentSigner {
+    static from(walletKeys, signer, cosigner) {
+        return new WalletUnspentSigner(walletKeys, signer, cosigner);
+    }
     constructor(walletKeys, signer, cosigner) {
         this.signer = signer;
         this.cosigner = cosigner;
         if (Array.isArray(walletKeys)) {
             walletKeys = new WalletKeys_1.RootWalletKeys(walletKeys);
         }
-        this.signerIndex = walletKeys.triple.findIndex((k) => WalletKeys_1.eqPublicKey(k, signer));
+        this.signerIndex = walletKeys.triple.findIndex((k) => (0, WalletKeys_1.eqPublicKey)(k, signer));
         if (this.signerIndex === undefined) {
             throw new Error(`signer not part of walletKeys`);
         }
-        this.cosignerIndex = walletKeys.triple.findIndex((k) => WalletKeys_1.eqPublicKey(k, cosigner));
+        this.cosignerIndex = walletKeys.triple.findIndex((k) => (0, WalletKeys_1.eqPublicKey)(k, cosigner));
         if (this.cosignerIndex === undefined) {
             throw new Error(`cosigner not part of walletKeys`);
         }
         this.walletKeys = walletKeys;
-        if (WalletKeys_1.eqPublicKey(signer, cosigner)) {
+        if ((0, WalletKeys_1.eqPublicKey)(signer, cosigner)) {
             throw new Error(`signer must not equal cosigner`);
         }
         if (signer.isNeutered()) {
             throw new Error(`signer must have private key`);
         }
     }
-    static from(walletKeys, signer, cosigner) {
-        return new WalletUnspentSigner(walletKeys, signer, cosigner);
-    }
     /**
      * @param chain
      * @param index
@@ -44,4 +44,4 @@ class WalletUnspentSigner {
     }
 }
 exports.WalletUnspentSigner = WalletUnspentSigner;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/bitgo/wallet/chains.d.ts

@@ -18,14 +18,14 @@ export declare const chainCodesP2shP2wsh: readonly [10, 11];
 export declare const chainCodesP2wsh: readonly [20, 21];
 export declare const chainCodesP2tr: readonly [30, 31];
 export declare const chainCodesP2trMusig2: readonly [40, 41];
-export declare const chainCodes: (0 | 1 | 31 | 30 | 10 | 11 | 20 | 21 | 40 | 41)[];
-export declare type ChainCode = (typeof chainCodes)[number];
+export declare const chainCodes: (0 | 1 | 31 | 10 | 11 | 20 | 21 | 30 | 40 | 41)[];
+export type ChainCode = (typeof chainCodes)[number];
 export declare function isChainCode(n: unknown): n is ChainCode;
 /**
  * A script type maps to two ChainCodes:
  * External addresses are intended for deposits, internal addresses are intended for change outputs.
  */
-export declare type ChainCodePair = Readonly<[external: ChainCode, internal: ChainCode]>;
+export type ChainCodePair = Readonly<[external: ChainCode, internal: ChainCode]>;
 /**
  * @return ChainCodePair for input
  */

package/dist/src/bitgo/wallet/chains.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chains.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/wallet/chains.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,cAAc,iBAAkB,CAAC;AAC9C,eAAO,MAAM,mBAAmB,mBAAoB,CAAC;AACrD,eAAO,MAAM,eAAe,mBAAoB,CAAC;AACjD,eAAO,MAAM,cAAc,mBAAoB,CAAC;AAChD,eAAO,MAAM,oBAAoB,mBAAoB,CAAC;AACtD,eAAO,MAAM,UAAU,mDAMtB,CAAC;AACF,oBAAY,SAAS,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;AACpD,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,SAAS,CAEtD;AAED;;;GAGG;AACH,oBAAY,aAAa,GAAG,QAAQ,CAAC,CAAC,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;AAcjF;;GAEG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,aAAa,GAAG,SAAS,GAAG,cAAc,GAAG,aAAa,CAiBxF;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,GAAG,cAAc,CAOnE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,aAAa,GAAG,cAAc,GAAG,SAAS,GAAG,SAAS,CAE7F;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,aAAa,GAAG,cAAc,GAAG,SAAS,GAAG,SAAS,CAE7F;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,SAAS,GAAG,OAAO,CAEzD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,SAAS,GAAG,OAAO,CAEzD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,GAAG,OAAO,CAQ9C"}
+{"version":3,"file":"chains.d.ts","sourceRoot":"","sources":["../../../../src/bitgo/wallet/chains.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,cAAc,iBAAkB,CAAC;AAC9C,eAAO,MAAM,mBAAmB,mBAAoB,CAAC;AACrD,eAAO,MAAM,eAAe,mBAAoB,CAAC;AACjD,eAAO,MAAM,cAAc,mBAAoB,CAAC;AAChD,eAAO,MAAM,oBAAoB,mBAAoB,CAAC;AACtD,eAAO,MAAM,UAAU,mDAMtB,CAAC;AACF,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;AACpD,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,SAAS,CAEtD;AAED;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC,CAAC,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;AAcjF;;GAEG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,aAAa,GAAG,SAAS,GAAG,cAAc,GAAG,aAAa,CAiBxF;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,GAAG,cAAc,CAOnE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,aAAa,GAAG,cAAc,GAAG,SAAS,GAAG,SAAS,CAE7F;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,aAAa,GAAG,cAAc,GAAG,SAAS,GAAG,SAAS,CAE7F;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,SAAS,GAAG,OAAO,CAEzD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,SAAS,GAAG,OAAO,CAEzD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,GAAG,OAAO,CAQ9C"}