@bitgo/abstract-utxo 10.11.1 → 10.13.0

package/dist/esm/recovery/psbt.js

@@ -0,0 +1,208 @@
+import * as utxolib from '@bitgo/utxo-lib';
+import { Dimensions } from '@bitgo/unspents';
+import { fixedScriptWallet } from '@bitgo/wasm-utxo';
+const { chainCodesP2tr, chainCodesP2trMusig2 } = utxolib.bitgo;
+/**
+ * Check if a chain code is for a taproot script type
+ */
+export function isTaprootChain(chain) {
+    return (chainCodesP2tr.includes(chain) || chainCodesP2trMusig2.includes(chain));
+}
+/**
+ * Convert utxolib Network to wasm-utxo network name
+ */
+export function toNetworkName(network) {
+    const networkName = utxolib.getNetworkName(network);
+    if (!networkName) {
+        throw new Error(`Invalid network`);
+    }
+    return networkName;
+}
+class InsufficientFundsError extends Error {
+    constructor(totalInputAmount, approximateFee, krsFee, recoveryAmount) {
+        super(`This wallet's balance is too low to pay the fees specified by the KRS provider.` +
+            `Existing balance on wallet: ${totalInputAmount.toString()}. ` +
+            `Estimated network fee for the recovery transaction: ${approximateFee.toString()}` +
+            `KRS fee to pay: ${krsFee.toString()}. ` +
+            `After deducting fees, your total recoverable balance is ${recoveryAmount.toString()}`);
+        this.totalInputAmount = totalInputAmount;
+        this.approximateFee = approximateFee;
+        this.krsFee = krsFee;
+        this.recoveryAmount = recoveryAmount;
+    }
+}
+/**
+ * Create a backup key recovery PSBT using utxolib (legacy implementation)
+ */
+function createBackupKeyRecoveryPsbtUtxolib(network, rootWalletKeys, unspents, options) {
+    const { feeRateSatVB, recoveryDestination, keyRecoveryServiceFee, keyRecoveryServiceFeeAddress } = options;
+    const psbt = utxolib.bitgo.createPsbtForNetwork({ network });
+    utxolib.bitgo.addXpubsToPsbt(psbt, rootWalletKeys);
+    unspents.forEach((unspent) => {
+        utxolib.bitgo.addWalletUnspentToPsbt(psbt, unspent, rootWalletKeys, 'user', 'backup');
+    });
+    let dimensions = Dimensions.fromPsbt(psbt).plus(Dimensions.fromOutput({ script: utxolib.address.toOutputScript(recoveryDestination, network) }));
+    if (keyRecoveryServiceFeeAddress) {
+        dimensions = dimensions.plus(Dimensions.fromOutput({
+            script: utxolib.address.toOutputScript(keyRecoveryServiceFeeAddress, network),
+        }));
+    }
+    const approximateFee = BigInt(dimensions.getVSize() * feeRateSatVB);
+    const totalInputAmount = utxolib.bitgo.unspentSum(unspents, 'bigint');
+    const recoveryAmount = totalInputAmount - approximateFee - keyRecoveryServiceFee;
+    if (recoveryAmount < BigInt(0)) {
+        throw new InsufficientFundsError(totalInputAmount, approximateFee, keyRecoveryServiceFee, recoveryAmount);
+    }
+    psbt.addOutput({ script: utxolib.address.toOutputScript(recoveryDestination, network), value: recoveryAmount });
+    if (keyRecoveryServiceFeeAddress) {
+        psbt.addOutput({
+            script: utxolib.address.toOutputScript(keyRecoveryServiceFeeAddress, network),
+            value: keyRecoveryServiceFee,
+        });
+    }
+    return psbt;
+}
+/**
+ * Check if the network is a Zcash network
+ */
+function isZcashNetwork(networkName) {
+    return networkName === 'zcash' || networkName === 'zcashTest';
+}
+/**
+ * Default block heights for Zcash networks if not provided.
+ * These should be set to a height after the latest network upgrade.
+ * TODO(BTC-2901): get the height from blockchair API instead of hardcoding.
+ */
+const ZCASH_DEFAULT_BLOCK_HEIGHTS = {
+    zcash: 3146400,
+    zcashTest: 3536500,
+};
+/**
+ * Create an empty wasm-utxo BitGoPsbt for a given network.
+ * Handles Zcash networks specially by using ZcashBitGoPsbt.
+ *
+ * @param network - The network for the PSBT
+ * @param rootWalletKeys - The wallet keys
+ * @param options - Optional settings (e.g., blockHeight for Zcash)
+ * @returns A wasm-utxo BitGoPsbt instance
+ */
+export function createEmptyWasmPsbt(network, rootWalletKeys, options) {
+    const networkName = toNetworkName(network);
+    if (isZcashNetwork(networkName)) {
+        // For Zcash, use ZcashBitGoPsbt which requires block height to determine consensus branch ID
+        const blockHeight = options?.blockHeight ?? ZCASH_DEFAULT_BLOCK_HEIGHTS[networkName];
+        return fixedScriptWallet.ZcashBitGoPsbt.createEmpty(networkName, rootWalletKeys, {
+            blockHeight,
+        });
+    }
+    return fixedScriptWallet.BitGoPsbt.createEmpty(networkName, rootWalletKeys);
+}
+/**
+ * Add wallet inputs from unspents to a wasm-utxo BitGoPsbt.
+ * Handles taproot inputs by setting the appropriate signPath.
+ *
+ * @param wasmPsbt - The wasm-utxo BitGoPsbt to add inputs to
+ * @param unspents - The wallet unspents to add as inputs
+ * @param rootWalletKeys - The wallet keys
+ */
+export function addWalletInputsToWasmPsbt(wasmPsbt, unspents, rootWalletKeys) {
+    unspents.forEach((unspent) => {
+        const { txid, vout } = utxolib.bitgo.parseOutputId(unspent.id);
+        const signPath = isTaprootChain(unspent.chain)
+            ? { signer: 'user', cosigner: 'backup' }
+            : undefined;
+        // prevTx may be added dynamically in backupKeyRecovery for non-segwit inputs
+        const prevTx = unspent.prevTx;
+        wasmPsbt.addWalletInput({
+            txid,
+            vout,
+            value: unspent.value,
+            prevTx: prevTx,
+        }, rootWalletKeys, {
+            scriptId: { chain: unspent.chain, index: unspent.index },
+            signPath,
+        });
+    });
+}
+/**
+ * Add an output to a wasm-utxo BitGoPsbt.
+ *
+ * @param wasmPsbt - The wasm-utxo BitGoPsbt to add the output to
+ * @param address - The destination address
+ * @param value - The output value in satoshis
+ * @param network - The network (used to convert address to script)
+ * @returns The output index
+ */
+export function addOutputToWasmPsbt(wasmPsbt, address, value, network) {
+    const script = utxolib.address.toOutputScript(address, network);
+    return wasmPsbt.addOutput({ script: new Uint8Array(script), value });
+}
+/**
+ * Convert a wasm-utxo BitGoPsbt to a utxolib UtxoPsbt.
+ *
+ * @param wasmPsbt - The wasm-utxo BitGoPsbt to convert
+ * @param network - The network
+ * @returns A utxolib UtxoPsbt
+ */
+export function wasmPsbtToUtxolibPsbt(wasmPsbt, network) {
+    return utxolib.bitgo.createPsbtFromBuffer(Buffer.from(wasmPsbt.serialize()), network);
+}
+/**
+ * Create a backup key recovery PSBT using wasm-utxo
+ */
+function createBackupKeyRecoveryPsbtWasm(network, rootWalletKeys, unspents, options) {
+    const { feeRateSatVB, recoveryDestination, keyRecoveryServiceFee, keyRecoveryServiceFeeAddress } = options;
+    // Create PSBT with wasm-utxo and add wallet inputs using shared utilities
+    const wasmPsbt = createEmptyWasmPsbt(network, rootWalletKeys, { blockHeight: options.blockHeight });
+    addWalletInputsToWasmPsbt(wasmPsbt, unspents, rootWalletKeys);
+    // Convert to utxolib PSBT temporarily for dimension calculation
+    const tempPsbt = wasmPsbtToUtxolibPsbt(wasmPsbt, network);
+    let dimensions = Dimensions.fromPsbt(tempPsbt).plus(Dimensions.fromOutput({ script: utxolib.address.toOutputScript(recoveryDestination, network) }));
+    if (keyRecoveryServiceFeeAddress) {
+        dimensions = dimensions.plus(Dimensions.fromOutput({
+            script: utxolib.address.toOutputScript(keyRecoveryServiceFeeAddress, network),
+        }));
+    }
+    const approximateFee = BigInt(dimensions.getVSize() * feeRateSatVB);
+    const totalInputAmount = utxolib.bitgo.unspentSum(unspents, 'bigint');
+    const recoveryAmount = totalInputAmount - approximateFee - keyRecoveryServiceFee;
+    if (recoveryAmount < BigInt(0)) {
+        throw new InsufficientFundsError(totalInputAmount, approximateFee, keyRecoveryServiceFee, recoveryAmount);
+    }
+    // Add outputs to wasm PSBT
+    addOutputToWasmPsbt(wasmPsbt, recoveryDestination, recoveryAmount, network);
+    if (keyRecoveryServiceFeeAddress) {
+        addOutputToWasmPsbt(wasmPsbt, keyRecoveryServiceFeeAddress, keyRecoveryServiceFee, network);
+    }
+    // Convert to utxolib PSBT for signing and return
+    return wasmPsbtToUtxolibPsbt(wasmPsbt, network);
+}
+/**
+ * Create a backup key recovery PSBT.
+ *
+ * @param network - The network for the PSBT
+ * @param rootWalletKeys - The wallet keys
+ * @param unspents - The unspents to include in the PSBT
+ * @param options - Options for creating the PSBT
+ * @param backend - Which backend to use for PSBT creation (default: 'wasm-utxo')
+ */
+export function createBackupKeyRecoveryPsbt(network, rootWalletKeys, unspents, options, backend = 'wasm-utxo') {
+    if (options.keyRecoveryServiceFee > 0 && !options.keyRecoveryServiceFeeAddress) {
+        throw new Error('keyRecoveryServiceFeeAddress is required when keyRecoveryServiceFee is provided');
+    }
+    if (backend === 'wasm-utxo') {
+        return createBackupKeyRecoveryPsbtWasm(network, rootWalletKeys, unspents, options);
+    }
+    else {
+        return createBackupKeyRecoveryPsbtUtxolib(network, rootWalletKeys, unspents, options);
+    }
+}
+export function getRecoveryAmount(psbt, address) {
+    const recoveryOutputScript = utxolib.address.toOutputScript(address, psbt.network);
+    const output = psbt.txOutputs.find((o) => o.script.equals(recoveryOutputScript));
+    if (!output) {
+        throw new Error(`Recovery destination output not found in PSBT: ${address}`);
+    }
+    return output.value;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"psbt.js","sourceRoot":"","sources":["../../../src/recovery/psbt.ts"],"names":[],"mappings":"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","sourcesContent":["import * as utxolib from '@bitgo/utxo-lib';\nimport { Dimensions } from '@bitgo/unspents';\nimport { fixedScriptWallet, utxolibCompat } from '@bitgo/wasm-utxo';\n\ntype RootWalletKeys = utxolib.bitgo.RootWalletKeys;\ntype WalletUnspent<TNumber extends number | bigint> = utxolib.bitgo.WalletUnspent<TNumber>;\n\nconst { chainCodesP2tr, chainCodesP2trMusig2 } = utxolib.bitgo;\n\ntype ChainCode = utxolib.bitgo.ChainCode;\n\n/**\n * Backend to use for PSBT creation.\n * - 'wasm-utxo': Use wasm-utxo for PSBT creation (default)\n * - 'utxolib': Use utxolib for PSBT creation (legacy)\n */\nexport type PsbtBackend = 'wasm-utxo' | 'utxolib';\n\n/**\n * Check if a chain code is for a taproot script type\n */\nexport function isTaprootChain(chain: ChainCode): boolean {\n  return (\n    (chainCodesP2tr as readonly number[]).includes(chain) || (chainCodesP2trMusig2 as readonly number[]).includes(chain)\n  );\n}\n\n/**\n * Convert utxolib Network to wasm-utxo network name\n */\nexport function toNetworkName(network: utxolib.Network): utxolibCompat.UtxolibName {\n  const networkName = utxolib.getNetworkName(network);\n  if (!networkName) {\n    throw new Error(`Invalid network`);\n  }\n  return networkName;\n}\n\nclass InsufficientFundsError extends Error {\n  constructor(\n    public totalInputAmount: bigint,\n    public approximateFee: bigint,\n    public krsFee: bigint,\n    public recoveryAmount: bigint\n  ) {\n    super(\n      `This wallet's balance is too low to pay the fees specified by the KRS provider.` +\n        `Existing balance on wallet: ${totalInputAmount.toString()}. ` +\n        `Estimated network fee for the recovery transaction: ${approximateFee.toString()}` +\n        `KRS fee to pay: ${krsFee.toString()}. ` +\n        `After deducting fees, your total recoverable balance is ${recoveryAmount.toString()}`\n    );\n  }\n}\n\ninterface CreateBackupKeyRecoveryPsbtOptions {\n  feeRateSatVB: number;\n  recoveryDestination: string;\n  keyRecoveryServiceFee: bigint;\n  keyRecoveryServiceFeeAddress: string | undefined;\n  /** Block height for Zcash networks (required to determine consensus branch ID) */\n  blockHeight?: number;\n}\n\n/**\n * Create a backup key recovery PSBT using utxolib (legacy implementation)\n */\nfunction createBackupKeyRecoveryPsbtUtxolib(\n  network: utxolib.Network,\n  rootWalletKeys: RootWalletKeys,\n  unspents: WalletUnspent<bigint>[],\n  options: CreateBackupKeyRecoveryPsbtOptions\n): utxolib.bitgo.UtxoPsbt {\n  const { feeRateSatVB, recoveryDestination, keyRecoveryServiceFee, keyRecoveryServiceFeeAddress } = options;\n\n  const psbt = utxolib.bitgo.createPsbtForNetwork({ network });\n  utxolib.bitgo.addXpubsToPsbt(psbt, rootWalletKeys);\n  unspents.forEach((unspent) => {\n    utxolib.bitgo.addWalletUnspentToPsbt(psbt, unspent, rootWalletKeys, 'user', 'backup');\n  });\n\n  let dimensions = Dimensions.fromPsbt(psbt).plus(\n    Dimensions.fromOutput({ script: utxolib.address.toOutputScript(recoveryDestination, network) })\n  );\n\n  if (keyRecoveryServiceFeeAddress) {\n    dimensions = dimensions.plus(\n      Dimensions.fromOutput({\n        script: utxolib.address.toOutputScript(keyRecoveryServiceFeeAddress, network),\n      })\n    );\n  }\n\n  const approximateFee = BigInt(dimensions.getVSize() * feeRateSatVB);\n  const totalInputAmount = utxolib.bitgo.unspentSum(unspents, 'bigint');\n  const recoveryAmount = totalInputAmount - approximateFee - keyRecoveryServiceFee;\n\n  if (recoveryAmount < BigInt(0)) {\n    throw new InsufficientFundsError(totalInputAmount, approximateFee, keyRecoveryServiceFee, recoveryAmount);\n  }\n\n  psbt.addOutput({ script: utxolib.address.toOutputScript(recoveryDestination, network), value: recoveryAmount });\n\n  if (keyRecoveryServiceFeeAddress) {\n    psbt.addOutput({\n      script: utxolib.address.toOutputScript(keyRecoveryServiceFeeAddress, network),\n      value: keyRecoveryServiceFee,\n    });\n  }\n\n  return psbt;\n}\n\n/**\n * Check if the network is a Zcash network\n */\nfunction isZcashNetwork(networkName: utxolibCompat.UtxolibName): boolean {\n  return networkName === 'zcash' || networkName === 'zcashTest';\n}\n\n/**\n * Default block heights for Zcash networks if not provided.\n * These should be set to a height after the latest network upgrade.\n * TODO(BTC-2901): get the height from blockchair API instead of hardcoding.\n */\nconst ZCASH_DEFAULT_BLOCK_HEIGHTS: Record<string, number> = {\n  zcash: 3146400,\n  zcashTest: 3536500,\n};\n\n/**\n * Options for creating an empty wasm-utxo PSBT\n */\nexport interface CreateEmptyWasmPsbtOptions {\n  /** Block height for Zcash networks (required to determine consensus branch ID) */\n  blockHeight?: number;\n}\n\n/**\n * Create an empty wasm-utxo BitGoPsbt for a given network.\n * Handles Zcash networks specially by using ZcashBitGoPsbt.\n *\n * @param network - The network for the PSBT\n * @param rootWalletKeys - The wallet keys\n * @param options - Optional settings (e.g., blockHeight for Zcash)\n * @returns A wasm-utxo BitGoPsbt instance\n */\nexport function createEmptyWasmPsbt(\n  network: utxolib.Network,\n  rootWalletKeys: RootWalletKeys,\n  options?: CreateEmptyWasmPsbtOptions\n): fixedScriptWallet.BitGoPsbt {\n  const networkName = toNetworkName(network);\n\n  if (isZcashNetwork(networkName)) {\n    // For Zcash, use ZcashBitGoPsbt which requires block height to determine consensus branch ID\n    const blockHeight = options?.blockHeight ?? ZCASH_DEFAULT_BLOCK_HEIGHTS[networkName];\n    return fixedScriptWallet.ZcashBitGoPsbt.createEmpty(networkName as 'zcash' | 'zcashTest', rootWalletKeys, {\n      blockHeight,\n    });\n  }\n\n  return fixedScriptWallet.BitGoPsbt.createEmpty(networkName, rootWalletKeys);\n}\n\n/**\n * Add wallet inputs from unspents to a wasm-utxo BitGoPsbt.\n * Handles taproot inputs by setting the appropriate signPath.\n *\n * @param wasmPsbt - The wasm-utxo BitGoPsbt to add inputs to\n * @param unspents - The wallet unspents to add as inputs\n * @param rootWalletKeys - The wallet keys\n */\nexport function addWalletInputsToWasmPsbt(\n  wasmPsbt: fixedScriptWallet.BitGoPsbt,\n  unspents: WalletUnspent<bigint>[],\n  rootWalletKeys: RootWalletKeys\n): void {\n  unspents.forEach((unspent) => {\n    const { txid, vout } = utxolib.bitgo.parseOutputId(unspent.id);\n    const signPath: fixedScriptWallet.SignPath | undefined = isTaprootChain(unspent.chain)\n      ? { signer: 'user', cosigner: 'backup' }\n      : undefined;\n\n    // prevTx may be added dynamically in backupKeyRecovery for non-segwit inputs\n    const prevTx = (unspent as WalletUnspent<bigint> & { prevTx?: Buffer }).prevTx;\n\n    wasmPsbt.addWalletInput(\n      {\n        txid,\n        vout,\n        value: unspent.value,\n        prevTx: prevTx,\n      },\n      rootWalletKeys,\n      {\n        scriptId: { chain: unspent.chain, index: unspent.index },\n        signPath,\n      }\n    );\n  });\n}\n\n/**\n * Add an output to a wasm-utxo BitGoPsbt.\n *\n * @param wasmPsbt - The wasm-utxo BitGoPsbt to add the output to\n * @param address - The destination address\n * @param value - The output value in satoshis\n * @param network - The network (used to convert address to script)\n * @returns The output index\n */\nexport function addOutputToWasmPsbt(\n  wasmPsbt: fixedScriptWallet.BitGoPsbt,\n  address: string,\n  value: bigint,\n  network: utxolib.Network\n): number {\n  const script = utxolib.address.toOutputScript(address, network);\n  return wasmPsbt.addOutput({ script: new Uint8Array(script), value });\n}\n\n/**\n * Convert a wasm-utxo BitGoPsbt to a utxolib UtxoPsbt.\n *\n * @param wasmPsbt - The wasm-utxo BitGoPsbt to convert\n * @param network - The network\n * @returns A utxolib UtxoPsbt\n */\nexport function wasmPsbtToUtxolibPsbt(\n  wasmPsbt: fixedScriptWallet.BitGoPsbt,\n  network: utxolib.Network\n): utxolib.bitgo.UtxoPsbt {\n  return utxolib.bitgo.createPsbtFromBuffer(Buffer.from(wasmPsbt.serialize()), network);\n}\n\n/**\n * Create a backup key recovery PSBT using wasm-utxo\n */\nfunction createBackupKeyRecoveryPsbtWasm(\n  network: utxolib.Network,\n  rootWalletKeys: RootWalletKeys,\n  unspents: WalletUnspent<bigint>[],\n  options: CreateBackupKeyRecoveryPsbtOptions\n): utxolib.bitgo.UtxoPsbt {\n  const { feeRateSatVB, recoveryDestination, keyRecoveryServiceFee, keyRecoveryServiceFeeAddress } = options;\n\n  // Create PSBT with wasm-utxo and add wallet inputs using shared utilities\n  const wasmPsbt = createEmptyWasmPsbt(network, rootWalletKeys, { blockHeight: options.blockHeight });\n  addWalletInputsToWasmPsbt(wasmPsbt, unspents, rootWalletKeys);\n\n  // Convert to utxolib PSBT temporarily for dimension calculation\n  const tempPsbt = wasmPsbtToUtxolibPsbt(wasmPsbt, network);\n  let dimensions = Dimensions.fromPsbt(tempPsbt).plus(\n    Dimensions.fromOutput({ script: utxolib.address.toOutputScript(recoveryDestination, network) })\n  );\n\n  if (keyRecoveryServiceFeeAddress) {\n    dimensions = dimensions.plus(\n      Dimensions.fromOutput({\n        script: utxolib.address.toOutputScript(keyRecoveryServiceFeeAddress, network),\n      })\n    );\n  }\n\n  const approximateFee = BigInt(dimensions.getVSize() * feeRateSatVB);\n  const totalInputAmount = utxolib.bitgo.unspentSum(unspents, 'bigint');\n  const recoveryAmount = totalInputAmount - approximateFee - keyRecoveryServiceFee;\n\n  if (recoveryAmount < BigInt(0)) {\n    throw new InsufficientFundsError(totalInputAmount, approximateFee, keyRecoveryServiceFee, recoveryAmount);\n  }\n\n  // Add outputs to wasm PSBT\n  addOutputToWasmPsbt(wasmPsbt, recoveryDestination, recoveryAmount, network);\n\n  if (keyRecoveryServiceFeeAddress) {\n    addOutputToWasmPsbt(wasmPsbt, keyRecoveryServiceFeeAddress, keyRecoveryServiceFee, network);\n  }\n\n  // Convert to utxolib PSBT for signing and return\n  return wasmPsbtToUtxolibPsbt(wasmPsbt, network);\n}\n\n/**\n * Create a backup key recovery PSBT.\n *\n * @param network - The network for the PSBT\n * @param rootWalletKeys - The wallet keys\n * @param unspents - The unspents to include in the PSBT\n * @param options - Options for creating the PSBT\n * @param backend - Which backend to use for PSBT creation (default: 'wasm-utxo')\n */\nexport function createBackupKeyRecoveryPsbt(\n  network: utxolib.Network,\n  rootWalletKeys: RootWalletKeys,\n  unspents: WalletUnspent<bigint>[],\n  options: CreateBackupKeyRecoveryPsbtOptions,\n  backend: PsbtBackend = 'wasm-utxo'\n): utxolib.bitgo.UtxoPsbt {\n  if (options.keyRecoveryServiceFee > 0 && !options.keyRecoveryServiceFeeAddress) {\n    throw new Error('keyRecoveryServiceFeeAddress is required when keyRecoveryServiceFee is provided');\n  }\n\n  if (backend === 'wasm-utxo') {\n    return createBackupKeyRecoveryPsbtWasm(network, rootWalletKeys, unspents, options);\n  } else {\n    return createBackupKeyRecoveryPsbtUtxolib(network, rootWalletKeys, unspents, options);\n  }\n}\n\nexport function getRecoveryAmount(psbt: utxolib.bitgo.UtxoPsbt, address: string): bigint {\n  const recoveryOutputScript = utxolib.address.toOutputScript(address, psbt.network);\n  const output = psbt.txOutputs.find((o) => o.script.equals(recoveryOutputScript));\n  if (!output) {\n    throw new Error(`Recovery destination output not found in PSBT: ${address}`);\n  }\n  return output.value;\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitgo/abstract-utxo",
-  "version": "10.11.1",
+  "version": "10.13.0",
   "description": "BitGo SDK coin library for UTXO base implementation",
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/index.js",
@@ -60,15 +60,15 @@
     ]
   },
   "dependencies": {
-    "@bitgo/blockapis": "^1.12.10",
-    "@bitgo/sdk-api": "^1.72.1",
-    "@bitgo/sdk-core": "^36.24.0",
-    "@bitgo/secp256k1": "^1.7.0",
-    "@bitgo/unspents": "^0.50.12",
-    "@bitgo/utxo-core": "^1.27.0",
-    "@bitgo/utxo-lib": "^11.18.0",
-    "@bitgo/utxo-ord": "^1.22.19",
-    "@bitgo/wasm-utxo": "1.11.0",
+    "@bitgo/blockapis": "^1.12.11",
+    "@bitgo/sdk-api": "^1.73.0",
+    "@bitgo/sdk-core": "^36.26.0",
+    "@bitgo/secp256k1": "^1.8.0",
+    "@bitgo/unspents": "^0.50.13",
+    "@bitgo/utxo-core": "^1.29.0",
+    "@bitgo/utxo-lib": "^11.19.0",
+    "@bitgo/utxo-ord": "^1.22.21",
+    "@bitgo/wasm-utxo": "1.19.0",
     "@types/lodash": "^4.14.121",
     "@types/superagent": "4.1.15",
     "bignumber.js": "^9.0.2",
@@ -79,8 +79,8 @@
     "superagent": "^9.0.1"
   },
   "devDependencies": {
-    "@bitgo/sdk-test": "^9.1.19",
+    "@bitgo/sdk-test": "^9.1.21",
     "mocha": "^10.2.0"
   },
-  "gitHead": "4c13f557fde52722de42102733b2da6a088ded47"
+  "gitHead": "49bd3d66d60a62e7c460af03a60f8627e815e3c7"
 }