@caravan/psbt 1.3.2 → 1.4.1

package/dist/index.d.ts

@@ -371,6 +371,22 @@ declare const addGlobalXpubs: (psbt: Psbt, inputs: PsbtInput[], network: Network
  * to support a newer API and be more PSBT-native.
  */
 declare const validateMultisigPsbtSignature: (raw: string | Buffer, inputIndex: number, inputSignature: Buffer, inputAmount?: string) => boolean | string;
+/***
+ * These should be deprecated eventually once we have better typescript support
+ * and a more api for handling PSBT saga.
+ * They are ports over from the legacy psbt code in caravan/bitcoin
+ */
+/**
+ * Translates a PSBT into inputs/outputs consumable by supported non-PSBT devices in the
+ * `@caravan/wallets` library.
+ *
+ * FIXME - Have only confirmed this is working for P2SH addresses on Ledger on regtest
+ */
+declare function translatePSBT(network: any, addressType: any, psbt: string, signingKeyDetails: any): {
+    unchainedInputs: any;
+    unchainedOutputs: any;
+    bip32Derivations: any;
+} | null;
 
 /**
  * @file This file primarily contains utility functions migrated from the
@@ -419,9 +435,13 @@ interface LegacyOutput {
 }
 declare const convertLegacyInput: (input: LegacyInput) => PsbtInput;
 declare const convertLegacyOutput: (output: LegacyOutput) => PsbtOutput;
+/**
+ * Given a string, try to create a Psbt object based on MAGIC (hex or Base64)
+ */
+declare function autoLoadPSBT(psbtFromFile: any, options?: any): Psbt | null;
 
 declare const PSBT_MAGIC_HEX = "70736274ff";
 declare const PSBT_MAGIC_B64 = "cHNidP8";
 declare const PSBT_MAGIC_BYTES: Buffer;
 
-export { LegacyInput, LegacyMultisig, LegacyOutput, PSBT_MAGIC_B64, PSBT_MAGIC_BYTES, PSBT_MAGIC_HEX, PsbtInput, PsbtOutput, PsbtV2, addGlobalXpubs, convertLegacyInput, convertLegacyOutput, getPsbtVersionNumber, getUnsignedMultisigPsbtV0, validateMultisigPsbtSignature };
+export { LegacyInput, LegacyMultisig, LegacyOutput, PSBT_MAGIC_B64, PSBT_MAGIC_BYTES, PSBT_MAGIC_HEX, PsbtInput, PsbtOutput, PsbtV2, addGlobalXpubs, autoLoadPSBT, convertLegacyInput, convertLegacyOutput, getPsbtVersionNumber, getUnsignedMultisigPsbtV0, translatePSBT, validateMultisigPsbtSignature };

package/dist/index.js

@@ -35,10 +35,12 @@ __export(src_exports, {
   PSBT_MAGIC_HEX: () => PSBT_MAGIC_HEX,
   PsbtV2: () => PsbtV2,
   addGlobalXpubs: () => addGlobalXpubs,
+  autoLoadPSBT: () => autoLoadPSBT,
   convertLegacyInput: () => convertLegacyInput,
   convertLegacyOutput: () => convertLegacyOutput,
   getPsbtVersionNumber: () => getPsbtVersionNumber,
   getUnsignedMultisigPsbtV0: () => getUnsignedMultisigPsbtV0,
+  translatePSBT: () => translatePSBT,
   validateMultisigPsbtSignature: () => validateMultisigPsbtSignature
 });
 module.exports = __toCommonJS(src_exports);
@@ -1197,9 +1199,9 @@ var PsbtV2 = class _PsbtV2 extends PsbtV2Maps {
 };
 
 // src/psbtv0/psbt.ts
-var import_bitcoin3 = require("@caravan/bitcoin");
-var import_bitcoinjs_lib_v62 = require("bitcoinjs-lib-v6");
-var import_address = require("bitcoinjs-lib-v6/src/address");
+var import_bitcoin4 = require("@caravan/bitcoin");
+var import_bitcoinjs_lib_v63 = require("bitcoinjs-lib-v6");
+var import_address = require("bitcoinjs-lib-v6/src/address.js");
 
 // vendor/tiny-secp256k1-asmjs/lib/index.js
 var lib_exports = {};
@@ -93703,7 +93705,114 @@ function verifySchnorr2(h6, Q3, signature) {
 
 // src/psbtv0/psbt.ts
 var bitcoin = __toESM(require("bitcoinjs-lib-v6"));
+var import_bignumber2 = __toESM(require("bignumber.js"));
+var import_bufferutils = require("bitcoinjs-lib-v6/src/bufferutils.js");
+
+// src/psbtv0/utils.ts
+var import_bitcoin3 = require("@caravan/bitcoin");
+
+// ../multisig/dist/index.mjs
+var braidDetailsToWalletConfig = (braidDetails) => {
+  return {
+    network: braidDetails.network,
+    extendedPublicKeys: braidDetails.extendedPublicKeys.map((key) => ({
+      xpub: key.base58String,
+      bip32Path: key.path,
+      xfp: key.rootFingerprint
+    })),
+    quorum: {
+      requiredSigners: braidDetails.requiredSigners,
+      totalSigners: braidDetails.extendedPublicKeys.length
+    },
+    name: `${braidDetails.requiredSigners}-of-${braidDetails.extendedPublicKeys.length} ${braidDetails.addressType} ${braidDetails.network} wallet`,
+    addressType: braidDetails.addressType
+  };
+};
+
+// src/psbtv0/utils.ts
 var import_bignumber = __toESM(require("bignumber.js"));
+var import_bitcoinjs_lib_v62 = require("bitcoinjs-lib-v6");
+var import_bufio4 = require("bufio");
+var idToHash = (txid) => {
+  return import_buffer.Buffer.from(txid, "hex").reverse();
+};
+function psbtMultisigLock(multisig) {
+  if (!multisig) {
+    return {};
+  }
+  const multisigLock = {};
+  switch ((0, import_bitcoin3.multisigAddressType)(multisig)) {
+    case import_bitcoin3.P2SH:
+      multisigLock.redeemScript = (0, import_bitcoin3.multisigRedeemScript)(multisig).output;
+      break;
+    case import_bitcoin3.P2WSH:
+      multisigLock.witnessScript = (0, import_bitcoin3.multisigWitnessScript)(multisig).output;
+      break;
+    case import_bitcoin3.P2SH_P2WSH:
+      multisigLock.witnessScript = (0, import_bitcoin3.multisigWitnessScript)(multisig).output;
+      multisigLock.redeemScript = (0, import_bitcoin3.multisigRedeemScript)(multisig).output;
+      break;
+  }
+  return multisigLock;
+}
+function getBip32Derivation(multisig, index = 0) {
+  if (!multisig) {
+    return;
+  }
+  if (multisig.bip32Derivation) {
+    return multisig.bip32Derivation;
+  }
+  const config = JSON.parse((0, import_bitcoin3.multisigBraidDetails)(multisig));
+  const braid = (0, import_bitcoin3.generateBraid)(
+    config.network,
+    config.addressType,
+    config.extendedPublicKeys,
+    config.requiredSigners,
+    config.index
+  );
+  return (0, import_bitcoin3.generateBip32DerivationByIndex)(braid, index);
+}
+var convertLegacyInput = (input) => {
+  return {
+    hash: idToHash(input.txid),
+    index: input.index,
+    transactionHex: input.transactionHex,
+    bip32Derivation: input.multisig.bip32Derivation || getBip32Derivation(input.multisig),
+    ...psbtMultisigLock(input.multisig),
+    spendingWallet: getWalletConfigFromInput(input)
+  };
+};
+var convertLegacyOutput = (output) => {
+  return {
+    address: output.address,
+    value: new import_bignumber.default(output.amountSats).toNumber(),
+    bip32Derivation: output.bip32Derivation || getBip32Derivation(output.multisig),
+    witnessScript: output.witnessScript,
+    redeemScript: output.redeemScript
+  };
+};
+var getWalletConfigFromInput = (input) => {
+  return braidDetailsToWalletConfig(JSON.parse(input.multisig.braidDetails));
+};
+function autoLoadPSBT(psbtFromFile, options) {
+  let psbtBuff;
+  try {
+    psbtBuff = bufferize(psbtFromFile);
+  } catch (e8) {
+    return null;
+  }
+  try {
+    const br = new import_bufio4.BufferReader(psbtBuff);
+    if (!br.readBytes(PSBT_MAGIC_BYTES.length, true).equals(PSBT_MAGIC_BYTES)) {
+      return null;
+    }
+  } catch (e8) {
+    return null;
+  }
+  return import_bitcoinjs_lib_v62.Psbt.fromBuffer(psbtBuff, options);
+}
+
+// src/psbtv0/psbt.ts
 bitcoin.initEccLib(lib_exports);
 var getUnsignedMultisigPsbtV0 = ({
   network,
@@ -93711,7 +93820,7 @@ var getUnsignedMultisigPsbtV0 = ({
   outputs,
   includeGlobalXpubs = false
 }) => {
-  const psbt = new import_bitcoinjs_lib_v62.Psbt({ network: (0, import_bitcoin3.networkData)(network) });
+  const psbt = new import_bitcoinjs_lib_v63.Psbt({ network: (0, import_bitcoin4.networkData)(network) });
   psbt.setVersion(1);
   for (const input of inputs) {
     const inputData = psbtInputFormatter(
@@ -93730,9 +93839,9 @@ var getUnsignedMultisigPsbtV0 = ({
   return psbt;
 };
 var psbtInputFormatter = (input, addressType) => {
-  const tx = import_bitcoinjs_lib_v62.Transaction.fromHex(input.transactionHex);
+  const tx = import_bitcoinjs_lib_v63.Transaction.fromHex(input.transactionHex);
   const inputData = { ...input };
-  if (addressType === import_bitcoin3.P2SH) {
+  if (addressType === import_bitcoin4.P2SH) {
     const nonWitnessUtxo = tx.toBuffer();
     inputData.nonWitnessUtxo = nonWitnessUtxo;
   } else {
@@ -93746,7 +93855,7 @@ var psbtInputFormatter = (input, addressType) => {
   return inputData;
 };
 var psbtOutputFormatter = (output, network) => {
-  const script = (0, import_address.toOutputScript)(output.address, (0, import_bitcoin3.networkData)(network));
+  const script = (0, import_address.toOutputScript)(output.address, (0, import_bitcoin4.networkData)(network));
   const outputData = {
     ...output,
     script,
@@ -93767,7 +93876,7 @@ var addGlobalXpubs = (psbt, inputs, network) => {
         if (!key.bip32Path) {
           return;
         }
-        const extendedPublicKey = import_bitcoin3.ExtendedPublicKey.fromBase58(key.xpub);
+        const extendedPublicKey = import_bitcoin4.ExtendedPublicKey.fromBase58(key.xpub);
         extendedPublicKey.network = network;
         extendedPublicKey.path = key.bip32Path;
         extendedPublicKey.rootFingerprint = key.xfp;
@@ -93794,7 +93903,7 @@ var formatGlobalXpub = (extendedPublicKey) => {
     );
   } else if (extendedPublicKey.parentFingerprint) {
     global2.masterFingerprint = import_buffer.Buffer.from(
-      (0, import_bitcoin3.fingerprintToFixedLengthHex)(extendedPublicKey.parentFingerprint),
+      (0, import_bitcoin4.fingerprintToFixedLengthHex)(extendedPublicKey.parentFingerprint),
       "hex"
     );
   } else {
@@ -93804,24 +93913,24 @@ var formatGlobalXpub = (extendedPublicKey) => {
   return global2;
 };
 var validateMultisigPsbtSignature = (raw, inputIndex, inputSignature, inputAmount) => {
-  const psbt = import_bitcoinjs_lib_v62.Psbt.fromBuffer(bufferize(raw));
+  const psbt = import_bitcoinjs_lib_v63.Psbt.fromBuffer(bufferize(raw));
   if (psbt.inputCount === 0 || psbt.inputCount < inputIndex + 1) {
     throw new Error("Input index is out of range.");
   }
-  const signatureBuffer = (0, import_bitcoin3.multisigSignatureBuffer)(
-    (0, import_bitcoin3.signatureNoSighashType)(inputSignature.toString("hex"))
+  const signatureBuffer = (0, import_bitcoin4.multisigSignatureBuffer)(
+    (0, import_bitcoin4.signatureNoSighashType)(inputSignature.toString("hex"))
   );
   const input = psbt.data.inputs[inputIndex];
   const msgHash = getHashForSignature(psbt, inputIndex, inputAmount);
   for (const { pubkey } of input.bip32Derivation ?? []) {
-    if ((0, import_bitcoin3.isValidSignature)(pubkey, msgHash, signatureBuffer)) {
+    if ((0, import_bitcoin4.isValidSignature)(pubkey, msgHash, signatureBuffer)) {
       return pubkey.toString("hex");
     }
   }
   return false;
 };
-var getHashForSignature = (psbt, inputIndex, inputAmount, sigHashFlag = import_bitcoinjs_lib_v62.Transaction.SIGHASH_ALL) => {
-  const tx = import_bitcoinjs_lib_v62.Transaction.fromBuffer(psbt.data.globalMap.unsignedTx.toBuffer());
+var getHashForSignature = (psbt, inputIndex, inputAmount, sigHashFlag = import_bitcoinjs_lib_v63.Transaction.SIGHASH_ALL) => {
+  const tx = import_bitcoinjs_lib_v63.Transaction.fromBuffer(psbt.data.globalMap.unsignedTx.toBuffer());
   const input = psbt.data.inputs[inputIndex];
   if (!input.witnessScript && input.redeemScript) {
     return tx.hashForSignature(inputIndex, input.redeemScript, sigHashFlag);
@@ -93829,7 +93938,7 @@ var getHashForSignature = (psbt, inputIndex, inputAmount, sigHashFlag = import_b
     if (!inputAmount) {
       throw new Error("Input amount is required for segwit inputs.");
     }
-    const amountSats = new import_bignumber.default(inputAmount).toNumber();
+    const amountSats = new import_bignumber2.default(inputAmount).toNumber();
     return tx.hashForWitnessV0(
       inputIndex,
       input.witnessScript,
@@ -93839,91 +93948,67 @@ var getHashForSignature = (psbt, inputIndex, inputAmount, sigHashFlag = import_b
   }
   throw new Error("No redeem or witness script found for input.");
 };
-
-// src/psbtv0/utils.ts
-var import_bitcoin4 = require("@caravan/bitcoin");
-
-// ../multisig/dist/index.mjs
-var braidDetailsToWalletConfig = (braidDetails) => {
-  return {
-    network: braidDetails.network,
-    extendedPublicKeys: braidDetails.extendedPublicKeys.map((key) => ({
-      xpub: key.base58String,
-      bip32Path: key.path,
-      xfp: key.rootFingerprint
-    })),
-    quorum: {
-      requiredSigners: braidDetails.requiredSigners,
-      totalSigners: braidDetails.extendedPublicKeys.length
-    },
-    name: `${braidDetails.requiredSigners}-of-${braidDetails.extendedPublicKeys.length} ${braidDetails.addressType} ${braidDetails.network} wallet`,
-    addressType: braidDetails.addressType
-  };
-};
-
-// src/psbtv0/utils.ts
-var import_bignumber2 = __toESM(require("bignumber.js"));
-var idToHash = (txid) => {
-  return import_buffer.Buffer.from(txid, "hex").reverse();
-};
-function psbtMultisigLock(multisig) {
-  if (!multisig) {
-    return {};
-  }
-  const multisigLock = {};
-  switch ((0, import_bitcoin4.multisigAddressType)(multisig)) {
-    case import_bitcoin4.P2SH:
-      multisigLock.redeemScript = (0, import_bitcoin4.multisigRedeemScript)(multisig).output;
-      break;
-    case import_bitcoin4.P2WSH:
-      multisigLock.witnessScript = (0, import_bitcoin4.multisigWitnessScript)(multisig).output;
-      break;
-    case import_bitcoin4.P2SH_P2WSH:
-      multisigLock.witnessScript = (0, import_bitcoin4.multisigWitnessScript)(multisig).output;
-      multisigLock.redeemScript = (0, import_bitcoin4.multisigRedeemScript)(multisig).output;
-      break;
-  }
-  return multisigLock;
-}
-function getBip32Derivation(multisig, index = 0) {
-  if (!multisig) {
-    return;
-  }
-  if (multisig.bip32Derivation) {
-    return multisig.bip32Derivation;
+function translatePSBT(network, addressType, psbt, signingKeyDetails) {
+  if (addressType !== import_bitcoin4.P2SH) {
+    throw new Error(
+      "Unsupported addressType -- only P2SH is supported right now"
+    );
   }
-  const config = JSON.parse((0, import_bitcoin4.multisigBraidDetails)(multisig));
-  const braid = (0, import_bitcoin4.generateBraid)(
-    config.network,
-    config.addressType,
-    config.extendedPublicKeys,
-    config.requiredSigners,
-    config.index
+  const localPSBT = autoLoadPSBT(psbt, { network: (0, import_bitcoin4.networkData)(network) });
+  if (localPSBT === null)
+    return null;
+  const bip32Derivations = filterRelevantBip32Derivations(
+    localPSBT,
+    signingKeyDetails
   );
-  return (0, import_bitcoin4.generateBip32DerivationByIndex)(braid, index);
-}
-var convertLegacyInput = (input) => {
-  return {
-    hash: idToHash(input.txid),
-    index: input.index,
-    transactionHex: input.transactionHex,
-    bip32Derivation: input.multisig.bip32Derivation || getBip32Derivation(input.multisig),
-    ...psbtMultisigLock(input.multisig),
-    spendingWallet: getWalletConfigFromInput(input)
-  };
-};
-var convertLegacyOutput = (output) => {
+  const unchainedInputs = getUnchainedInputsFromPSBT(
+    network,
+    addressType,
+    localPSBT
+  );
+  const unchainedOutputs = getUnchainedOutputsFromPSBT(localPSBT);
   return {
+    unchainedInputs,
+    unchainedOutputs,
+    bip32Derivations
+  };
+}
+function getUnchainedInputsFromPSBT(network, addressType, psbt) {
+  return psbt.txInputs.map((input, index) => {
+    const dataInput = psbt.data.inputs[index];
+    const fundingTxHex = dataInput.nonWitnessUtxo.toString("hex");
+    const fundingTx = import_bitcoinjs_lib_v63.Transaction.fromHex(fundingTxHex);
+    const multisig = (0, import_bitcoin4.generateMultisigFromHex)(
+      network,
+      addressType,
+      dataInput.redeemScript.toString("hex")
+    );
+    return {
+      amountSats: fundingTx.outs[input.index].value,
+      index: input.index,
+      transactionHex: fundingTxHex,
+      txid: (0, import_bufferutils.reverseBuffer)(input.hash).toString("hex"),
+      multisig
+    };
+  });
+}
+function getUnchainedOutputsFromPSBT(psbt) {
+  return psbt.txOutputs.map((output) => ({
     address: output.address,
-    value: new import_bignumber2.default(output.amountSats).toNumber(),
-    bip32Derivation: output.bip32Derivation || getBip32Derivation(output.multisig),
-    witnessScript: output.witnessScript,
-    redeemScript: output.redeemScript
-  };
-};
-var getWalletConfigFromInput = (input) => {
-  return braidDetailsToWalletConfig(JSON.parse(input.multisig.braidDetails));
-};
+    amountSats: output.value
+  }));
+}
+function filterRelevantBip32Derivations(psbt, signingKeyDetails) {
+  return psbt.data.inputs.map((input) => {
+    const bip32Derivation = input.bip32Derivation.filter(
+      (b32d) => b32d.path.startsWith(signingKeyDetails.path) && b32d.masterFingerprint.toString("hex") === signingKeyDetails.xfp
+    );
+    if (!bip32Derivation.length) {
+      throw new Error("Signing key details not included in PSBT");
+    }
+    return bip32Derivation[0];
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PSBT_MAGIC_B64,
@@ -93931,10 +94016,12 @@ var getWalletConfigFromInput = (input) => {
   PSBT_MAGIC_HEX,
   PsbtV2,
   addGlobalXpubs,
+  autoLoadPSBT,
   convertLegacyInput,
   convertLegacyOutput,
   getPsbtVersionNumber,
   getUnsignedMultisigPsbtV0,
+  translatePSBT,
   validateMultisigPsbtSignature
 });
 /*! Bundled license information:

package/dist/index.mjs

@@ -1161,14 +1161,15 @@ var PsbtV2 = class _PsbtV2 extends PsbtV2Maps {
 import {
   ExtendedPublicKey,
   fingerprintToFixedLengthHex,
+  generateMultisigFromHex,
   isValidSignature,
   multisigSignatureBuffer,
   networkData,
-  P2SH,
+  P2SH as P2SH2,
   signatureNoSighashType
 } from "@caravan/bitcoin";
-import { Psbt as Psbt2, Transaction } from "bitcoinjs-lib-v6";
-import { toOutputScript } from "bitcoinjs-lib-v6/src/address";
+import { Psbt as Psbt3, Transaction } from "bitcoinjs-lib-v6";
+import { toOutputScript } from "bitcoinjs-lib-v6/src/address.js";
 
 // vendor/tiny-secp256k1-asmjs/lib/index.js
 var lib_exports = {};
@@ -93672,7 +93673,124 @@ function verifySchnorr2(h6, Q3, signature) {
 
 // src/psbtv0/psbt.ts
 import * as bitcoin from "bitcoinjs-lib-v6";
+import BigNumber2 from "bignumber.js";
+import { reverseBuffer } from "bitcoinjs-lib-v6/src/bufferutils.js";
+
+// src/psbtv0/utils.ts
+import {
+  generateBip32DerivationByIndex,
+  generateBraid,
+  multisigAddressType,
+  multisigBraidDetails,
+  multisigRedeemScript,
+  multisigWitnessScript,
+  P2SH,
+  P2SH_P2WSH,
+  P2WSH
+} from "@caravan/bitcoin";
+
+// ../multisig/dist/index.mjs
+var braidDetailsToWalletConfig = (braidDetails) => {
+  return {
+    network: braidDetails.network,
+    extendedPublicKeys: braidDetails.extendedPublicKeys.map((key) => ({
+      xpub: key.base58String,
+      bip32Path: key.path,
+      xfp: key.rootFingerprint
+    })),
+    quorum: {
+      requiredSigners: braidDetails.requiredSigners,
+      totalSigners: braidDetails.extendedPublicKeys.length
+    },
+    name: `${braidDetails.requiredSigners}-of-${braidDetails.extendedPublicKeys.length} ${braidDetails.addressType} ${braidDetails.network} wallet`,
+    addressType: braidDetails.addressType
+  };
+};
+
+// src/psbtv0/utils.ts
 import BigNumber from "bignumber.js";
+import { Psbt as Psbt2 } from "bitcoinjs-lib-v6";
+import { BufferReader as BufferReader4 } from "bufio";
+var idToHash = (txid) => {
+  return Buffer2.from(txid, "hex").reverse();
+};
+function psbtMultisigLock(multisig) {
+  if (!multisig) {
+    return {};
+  }
+  const multisigLock = {};
+  switch (multisigAddressType(multisig)) {
+    case P2SH:
+      multisigLock.redeemScript = multisigRedeemScript(multisig).output;
+      break;
+    case P2WSH:
+      multisigLock.witnessScript = multisigWitnessScript(multisig).output;
+      break;
+    case P2SH_P2WSH:
+      multisigLock.witnessScript = multisigWitnessScript(multisig).output;
+      multisigLock.redeemScript = multisigRedeemScript(multisig).output;
+      break;
+  }
+  return multisigLock;
+}
+function getBip32Derivation(multisig, index = 0) {
+  if (!multisig) {
+    return;
+  }
+  if (multisig.bip32Derivation) {
+    return multisig.bip32Derivation;
+  }
+  const config = JSON.parse(multisigBraidDetails(multisig));
+  const braid = generateBraid(
+    config.network,
+    config.addressType,
+    config.extendedPublicKeys,
+    config.requiredSigners,
+    config.index
+  );
+  return generateBip32DerivationByIndex(braid, index);
+}
+var convertLegacyInput = (input) => {
+  return {
+    hash: idToHash(input.txid),
+    index: input.index,
+    transactionHex: input.transactionHex,
+    bip32Derivation: input.multisig.bip32Derivation || getBip32Derivation(input.multisig),
+    ...psbtMultisigLock(input.multisig),
+    spendingWallet: getWalletConfigFromInput(input)
+  };
+};
+var convertLegacyOutput = (output) => {
+  return {
+    address: output.address,
+    value: new BigNumber(output.amountSats).toNumber(),
+    bip32Derivation: output.bip32Derivation || getBip32Derivation(output.multisig),
+    witnessScript: output.witnessScript,
+    redeemScript: output.redeemScript
+  };
+};
+var getWalletConfigFromInput = (input) => {
+  return braidDetailsToWalletConfig(JSON.parse(input.multisig.braidDetails));
+};
+function autoLoadPSBT(psbtFromFile, options) {
+  let psbtBuff;
+  try {
+    psbtBuff = bufferize(psbtFromFile);
+  } catch (e8) {
+    return null;
+  }
+  try {
+    const br = new BufferReader4(psbtBuff);
+    if (!br.readBytes(PSBT_MAGIC_BYTES.length, true).equals(PSBT_MAGIC_BYTES)) {
+      return null;
+    }
+  } catch (e8) {
+    return null;
+  }
+  return Psbt2.fromBuffer(psbtBuff, options);
+}
+
+// src/psbtv0/psbt.ts
 bitcoin.initEccLib(lib_exports);
 var getUnsignedMultisigPsbtV0 = ({
   network,
@@ -93680,7 +93798,7 @@ var getUnsignedMultisigPsbtV0 = ({
   outputs,
   includeGlobalXpubs = false
 }) => {
-  const psbt = new Psbt2({ network: networkData(network) });
+  const psbt = new Psbt3({ network: networkData(network) });
   psbt.setVersion(1);
   for (const input of inputs) {
     const inputData = psbtInputFormatter(
@@ -93701,7 +93819,7 @@ var getUnsignedMultisigPsbtV0 = ({
 var psbtInputFormatter = (input, addressType) => {
   const tx = Transaction.fromHex(input.transactionHex);
   const inputData = { ...input };
-  if (addressType === P2SH) {
+  if (addressType === P2SH2) {
     const nonWitnessUtxo = tx.toBuffer();
     inputData.nonWitnessUtxo = nonWitnessUtxo;
   } else {
@@ -93773,7 +93891,7 @@ var formatGlobalXpub = (extendedPublicKey) => {
   return global2;
 };
 var validateMultisigPsbtSignature = (raw, inputIndex, inputSignature, inputAmount) => {
-  const psbt = Psbt2.fromBuffer(bufferize(raw));
+  const psbt = Psbt3.fromBuffer(bufferize(raw));
   if (psbt.inputCount === 0 || psbt.inputCount < inputIndex + 1) {
     throw new Error("Input index is out of range.");
   }
@@ -93798,7 +93916,7 @@ var getHashForSignature = (psbt, inputIndex, inputAmount, sigHashFlag = Transact
     if (!inputAmount) {
       throw new Error("Input amount is required for segwit inputs.");
     }
-    const amountSats = new BigNumber(inputAmount).toNumber();
+    const amountSats = new BigNumber2(inputAmount).toNumber();
     return tx.hashForWitnessV0(
       inputIndex,
       input.witnessScript,
@@ -93808,111 +93926,79 @@ var getHashForSignature = (psbt, inputIndex, inputAmount, sigHashFlag = Transact
   }
   throw new Error("No redeem or witness script found for input.");
 };
-
-// src/psbtv0/utils.ts
-import {
-  generateBip32DerivationByIndex,
-  generateBraid,
-  multisigAddressType,
-  multisigBraidDetails,
-  multisigRedeemScript,
-  multisigWitnessScript,
-  P2SH as P2SH2,
-  P2SH_P2WSH,
-  P2WSH
-} from "@caravan/bitcoin";
-
-// ../multisig/dist/index.mjs
-var braidDetailsToWalletConfig = (braidDetails) => {
-  return {
-    network: braidDetails.network,
-    extendedPublicKeys: braidDetails.extendedPublicKeys.map((key) => ({
-      xpub: key.base58String,
-      bip32Path: key.path,
-      xfp: key.rootFingerprint
-    })),
-    quorum: {
-      requiredSigners: braidDetails.requiredSigners,
-      totalSigners: braidDetails.extendedPublicKeys.length
-    },
-    name: `${braidDetails.requiredSigners}-of-${braidDetails.extendedPublicKeys.length} ${braidDetails.addressType} ${braidDetails.network} wallet`,
-    addressType: braidDetails.addressType
-  };
-};
-
-// src/psbtv0/utils.ts
-import BigNumber2 from "bignumber.js";
-var idToHash = (txid) => {
-  return Buffer2.from(txid, "hex").reverse();
-};
-function psbtMultisigLock(multisig) {
-  if (!multisig) {
-    return {};
-  }
-  const multisigLock = {};
-  switch (multisigAddressType(multisig)) {
-    case P2SH2:
-      multisigLock.redeemScript = multisigRedeemScript(multisig).output;
-      break;
-    case P2WSH:
-      multisigLock.witnessScript = multisigWitnessScript(multisig).output;
-      break;
-    case P2SH_P2WSH:
-      multisigLock.witnessScript = multisigWitnessScript(multisig).output;
-      multisigLock.redeemScript = multisigRedeemScript(multisig).output;
-      break;
-  }
-  return multisigLock;
-}
-function getBip32Derivation(multisig, index = 0) {
-  if (!multisig) {
-    return;
-  }
-  if (multisig.bip32Derivation) {
-    return multisig.bip32Derivation;
+function translatePSBT(network, addressType, psbt, signingKeyDetails) {
+  if (addressType !== P2SH2) {
+    throw new Error(
+      "Unsupported addressType -- only P2SH is supported right now"
+    );
   }
-  const config = JSON.parse(multisigBraidDetails(multisig));
-  const braid = generateBraid(
-    config.network,
-    config.addressType,
-    config.extendedPublicKeys,
-    config.requiredSigners,
-    config.index
+  const localPSBT = autoLoadPSBT(psbt, { network: networkData(network) });
+  if (localPSBT === null)
+    return null;
+  const bip32Derivations = filterRelevantBip32Derivations(
+    localPSBT,
+    signingKeyDetails
   );
-  return generateBip32DerivationByIndex(braid, index);
-}
-var convertLegacyInput = (input) => {
-  return {
-    hash: idToHash(input.txid),
-    index: input.index,
-    transactionHex: input.transactionHex,
-    bip32Derivation: input.multisig.bip32Derivation || getBip32Derivation(input.multisig),
-    ...psbtMultisigLock(input.multisig),
-    spendingWallet: getWalletConfigFromInput(input)
-  };
-};
-var convertLegacyOutput = (output) => {
+  const unchainedInputs = getUnchainedInputsFromPSBT(
+    network,
+    addressType,
+    localPSBT
+  );
+  const unchainedOutputs = getUnchainedOutputsFromPSBT(localPSBT);
   return {
+    unchainedInputs,
+    unchainedOutputs,
+    bip32Derivations
+  };
+}
+function getUnchainedInputsFromPSBT(network, addressType, psbt) {
+  return psbt.txInputs.map((input, index) => {
+    const dataInput = psbt.data.inputs[index];
+    const fundingTxHex = dataInput.nonWitnessUtxo.toString("hex");
+    const fundingTx = Transaction.fromHex(fundingTxHex);
+    const multisig = generateMultisigFromHex(
+      network,
+      addressType,
+      dataInput.redeemScript.toString("hex")
+    );
+    return {
+      amountSats: fundingTx.outs[input.index].value,
+      index: input.index,
+      transactionHex: fundingTxHex,
+      txid: reverseBuffer(input.hash).toString("hex"),
+      multisig
+    };
+  });
+}
+function getUnchainedOutputsFromPSBT(psbt) {
+  return psbt.txOutputs.map((output) => ({
     address: output.address,
-    value: new BigNumber2(output.amountSats).toNumber(),
-    bip32Derivation: output.bip32Derivation || getBip32Derivation(output.multisig),
-    witnessScript: output.witnessScript,
-    redeemScript: output.redeemScript
-  };
-};
-var getWalletConfigFromInput = (input) => {
-  return braidDetailsToWalletConfig(JSON.parse(input.multisig.braidDetails));
-};
+    amountSats: output.value
+  }));
+}
+function filterRelevantBip32Derivations(psbt, signingKeyDetails) {
+  return psbt.data.inputs.map((input) => {
+    const bip32Derivation = input.bip32Derivation.filter(
+      (b32d) => b32d.path.startsWith(signingKeyDetails.path) && b32d.masterFingerprint.toString("hex") === signingKeyDetails.xfp
+    );
+    if (!bip32Derivation.length) {
+      throw new Error("Signing key details not included in PSBT");
+    }
+    return bip32Derivation[0];
+  });
+}
 export {
   PSBT_MAGIC_B64,
   PSBT_MAGIC_BYTES,
   PSBT_MAGIC_HEX,
   PsbtV2,
   addGlobalXpubs,
+  autoLoadPSBT,
   convertLegacyInput,
   convertLegacyOutput,
   getPsbtVersionNumber,
   getUnsignedMultisigPsbtV0,
+  translatePSBT,
   validateMultisigPsbtSignature
 };
 /*! Bundled license information:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caravan/psbt",
-  "version": "1.3.2",
+  "version": "1.4.1",
   "description": "typescript library for working with PSBTs",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -51,8 +51,8 @@
   "author": "unchained capital",
   "license": "ISC",
   "devDependencies": {
-    "@caravan/multisig": "*",
     "@caravan/eslint-config": "*",
+    "@caravan/multisig": "*",
     "@caravan/typescript-config": "*",
     "@inrupt/jest-jsdom-polyfills": "^3.2.1",
     "@jest/globals": "^29.7.0",
@@ -61,6 +61,7 @@
     "jest": "^29.4.1",
     "jsdom": "24.0.0",
     "jsdom-global": "3.0.2",
+    "lodash": "^4.17.21",
     "react-silence": "^1.0.4",
     "ts-jest": "^29.1.2",
     "ts-node": "^10.9.2",