@caravan/psbt 1.0.0

package/dist/index.mjs

@@ -0,0 +1,924 @@
+// ../../node_modules/esbuild-plugin-polyfill-node/polyfills/buffer.js
+import { Buffer } from "buffer";
+
+// src/psbtv2.ts
+import { BufferReader, BufferWriter } from "bufio";
+import { Psbt as Psbt2 } from "bitcoinjs-lib";
+import { validateHex, validBase64, validateBIP32Path } from "@caravan/bitcoin";
+
+// src/psbt.ts
+import { Psbt, Transaction } from "bitcoinjs-lib";
+import { reverseBuffer } from "bitcoinjs-lib/src/bufferutils.js";
+import { toHexString } from "@caravan/bitcoin";
+import {
+  generateMultisigFromHex,
+  multisigAddressType,
+  multisigBraidDetails,
+  multisigRedeemScript,
+  multisigWitnessScript,
+  bip32PathToSequence,
+  P2SH,
+  P2WSH,
+  P2SH_P2WSH,
+  generateBip32DerivationByIndex,
+  generateBraid,
+  networkData
+} from "@caravan/bitcoin";
+import BigNumber from "bignumber.js";
+var PSBT_MAGIC_BYTES = Buffer.from([112, 115, 98, 116, 255]);
+
+// src/psbtv2.ts
+var PSBT_MAP_SEPARATOR = Buffer.from([0]);
+var BIP_32_NODE_REGEX = /(\/[0-9]+'?)/gi;
+var BIP_32_HARDENING_OFFSET = 2147483648;
+function bufferize(psbt) {
+  if (Buffer.isBuffer(psbt)) {
+    return psbt;
+  }
+  if (typeof psbt === "string") {
+    if (validateHex(psbt) === "") {
+      return Buffer.from(psbt, "hex");
+    }
+    if (validBase64(psbt)) {
+      return Buffer.from(psbt, "base64");
+    }
+  }
+  throw Error("Input cannot be bufferized.");
+}
+function getNonUniqueKeyTypeValues(maps, keytype) {
+  if (Array.isArray(maps)) {
+    const values2 = maps.map(
+      (map2) => (
+        // TODO: Figure out a better way to type this
+        getNonUniqueKeyTypeValues(map2, keytype)
+      )
+    );
+    return values2;
+  }
+  const map = maps;
+  const values = [];
+  for (const [key, value] of map.entries()) {
+    if (key.startsWith(keytype)) {
+      values.push({ key, value: value?.toString("hex") || null });
+    }
+  }
+  return values;
+}
+function getOptionalMappedBytesAsHex(maps, keytype) {
+  return maps.map((map) => map.get(keytype)?.toString("hex") ?? null);
+}
+function getOptionalMappedBytesAsUInt(maps, keytype) {
+  return maps.map((map) => map.get(keytype)?.readUInt32LE(0) ?? null);
+}
+function parseDerivationPathNodesToBytes(path) {
+  const validationMessage = validateBIP32Path(path);
+  if (validationMessage !== "") {
+    throw Error(validationMessage);
+  }
+  const bw = new BufferWriter();
+  for (const node of path.match(BIP_32_NODE_REGEX) ?? []) {
+    let num = parseInt(node.slice(1), 10);
+    if (node.indexOf("'") > -1) {
+      num += BIP_32_HARDENING_OFFSET;
+    }
+    bw.writeU32(num);
+  }
+  return bw.render();
+}
+function readAndSetKeyPairs(map, br) {
+  const nextByte = br.readBytes(1);
+  if (nextByte.equals(PSBT_MAP_SEPARATOR)) {
+    return;
+  }
+  const keyLen = nextByte.readUInt8(0);
+  const key = br.readBytes(keyLen);
+  const value = br.readVarBytes();
+  map.set(key.toString("hex"), value);
+  readAndSetKeyPairs(map, br);
+}
+function serializeMap(map, bw) {
+  map.forEach((value, key) => {
+    const keyBuf = Buffer.from(key, "hex");
+    const keyLen = keyBuf.length;
+    bw.writeVarint(keyLen);
+    bw.writeString(key, "hex");
+    bw.writeVarint(value.length);
+    bw.writeBytes(value);
+  });
+  bw.writeBytes(PSBT_MAP_SEPARATOR);
+}
+var PsbtV2Maps = class {
+  // These maps directly correspond to the maps defined in BIP0174
+  globalMap = /* @__PURE__ */ new Map();
+  inputMaps = [];
+  outputMaps = [];
+  constructor(psbt) {
+    if (!psbt) {
+      return;
+    }
+    const buf = bufferize(psbt);
+    const br = new BufferReader(buf);
+    if (!br.readBytes(PSBT_MAGIC_BYTES.length, true).equals(PSBT_MAGIC_BYTES)) {
+      throw Error("PsbtV2 magic bytes are incorrect.");
+    }
+    readAndSetKeyPairs(this.globalMap, br);
+    if (
+      // Assuming that psbt being passed in is a valid psbtv2
+      !this.globalMap.has("fb" /* PSBT_GLOBAL_VERSION */) || !this.globalMap.has("02" /* PSBT_GLOBAL_TX_VERSION */) || !this.globalMap.has("04" /* PSBT_GLOBAL_INPUT_COUNT */) || !this.globalMap.has("05" /* PSBT_GLOBAL_OUTPUT_COUNT */) || this.globalMap.has("00")
+    ) {
+      throw Error("Provided PsbtV2 not valid. Missing required global keys.");
+    }
+    const inputCount = this.globalMap.get("04" /* PSBT_GLOBAL_INPUT_COUNT */)?.readUInt8(0) ?? 0;
+    for (let i = 0; i < inputCount; i++) {
+      const map = /* @__PURE__ */ new Map();
+      readAndSetKeyPairs(map, br);
+      this.inputMaps.push(map);
+    }
+    const outputCount = this.globalMap.get("05" /* PSBT_GLOBAL_OUTPUT_COUNT */)?.readUInt8(0) ?? 0;
+    for (let i = 0; i < outputCount; i++) {
+      const map = /* @__PURE__ */ new Map();
+      readAndSetKeyPairs(map, br);
+      this.outputMaps.push(map);
+    }
+  }
+  // Return the current state of the psbt as a string in the specified format.
+  serialize(format = "base64") {
+    let bw = new BufferWriter();
+    bw.writeBytes(PSBT_MAGIC_BYTES);
+    serializeMap(this.globalMap, bw);
+    for (const map of this.inputMaps) {
+      serializeMap(map, bw);
+    }
+    for (const map of this.outputMaps) {
+      serializeMap(map, bw);
+    }
+    return bw.render().toString(format);
+  }
+  // NOTE: This set of copy methods is made available to
+  // achieve parity with the PSBT api required by ledger-bitcoin
+  // for creating merklized PSBTs. HOWEVER, it is not recommended
+  // to use this when avoidable as copying maps bypasses the validation
+  // defined in the constructor, so it could create a psbtv2 in an invalid psbt status.
+  // PsbtV2.serialize is preferable whenever possible.
+  copy(to) {
+    this.copyMap(this.globalMap, to.globalMap);
+    this.copyMaps(this.inputMaps, to.inputMaps);
+    this.copyMaps(this.outputMaps, to.outputMaps);
+  }
+  copyMaps(from, to) {
+    from.forEach((m, index) => {
+      const to_index = /* @__PURE__ */ new Map();
+      this.copyMap(m, to_index);
+      to[index] = to_index;
+    });
+  }
+  // eslint-disable-next-line class-methods-use-this
+  copyMap(from, to) {
+    from.forEach((v, k) => to.set(k, Buffer.from(v)));
+  }
+};
+var PsbtV2 = class _PsbtV2 extends PsbtV2Maps {
+  constructor(psbt) {
+    super(psbt);
+    if (!psbt) {
+      this.create();
+    }
+    this.validate();
+  }
+  /**
+   * Globals Getters/Setters
+   */
+  get PSBT_GLOBAL_XPUB() {
+    return getNonUniqueKeyTypeValues(this.globalMap, "01" /* PSBT_GLOBAL_XPUB */);
+  }
+  get PSBT_GLOBAL_TX_VERSION() {
+    const val = this.globalMap.get("02" /* PSBT_GLOBAL_TX_VERSION */);
+    if (val === void 0) {
+      throw Error("PSBT_GLOBAL_TX_VERSION not set");
+    }
+    return val.readInt32LE(0);
+  }
+  set PSBT_GLOBAL_TX_VERSION(version) {
+    if (version < 2) {
+      throw Error(
+        `PsbtV2 cannot have a global tx version less than 2. Version ${version} specified.`
+      );
+    }
+    const bw = new BufferWriter();
+    bw.writeI32(version);
+    this.globalMap.set("02" /* PSBT_GLOBAL_TX_VERSION */, bw.render());
+  }
+  get PSBT_GLOBAL_FALLBACK_LOCKTIME() {
+    return this.globalMap.get("03" /* PSBT_GLOBAL_FALLBACK_LOCKTIME */)?.readUInt32LE(0) ?? null;
+  }
+  set PSBT_GLOBAL_FALLBACK_LOCKTIME(locktime) {
+    if (locktime === null) {
+      this.globalMap.delete("03" /* PSBT_GLOBAL_FALLBACK_LOCKTIME */);
+    } else {
+      const bw = new BufferWriter();
+      bw.writeI32(locktime);
+      this.globalMap.set("03" /* PSBT_GLOBAL_FALLBACK_LOCKTIME */, bw.render());
+    }
+  }
+  get PSBT_GLOBAL_INPUT_COUNT() {
+    const val = this.globalMap.get("04" /* PSBT_GLOBAL_INPUT_COUNT */);
+    if (val === void 0) {
+      throw Error("PSBT_GLOBAL_INPUT_COUNT not set");
+    }
+    return val.readUInt8(0);
+  }
+  set PSBT_GLOBAL_INPUT_COUNT(count) {
+    const bw = new BufferWriter();
+    bw.writeU8(count);
+    this.globalMap.set("04" /* PSBT_GLOBAL_INPUT_COUNT */, bw.render());
+  }
+  get PSBT_GLOBAL_OUTPUT_COUNT() {
+    const val = this.globalMap.get("05" /* PSBT_GLOBAL_OUTPUT_COUNT */);
+    if (val === void 0) {
+      throw Error("PSBT_GLOBAL_OUTPUT_COUNT not set");
+    }
+    return val.readUInt8(0);
+  }
+  set PSBT_GLOBAL_OUTPUT_COUNT(count) {
+    const bw = new BufferWriter();
+    bw.writeU8(count);
+    this.globalMap.set("05" /* PSBT_GLOBAL_OUTPUT_COUNT */, bw.render());
+  }
+  get PSBT_GLOBAL_TX_MODIFIABLE() {
+    const val = this.globalMap.get("06" /* PSBT_GLOBAL_TX_MODIFIABLE */)?.readUInt8(0) || 0;
+    let modifiable = [];
+    if (val & 1) {
+      modifiable.push("INPUTS" /* INPUTS */);
+    }
+    if (val & 2) {
+      modifiable.push("OUTPUTS" /* OUTPUTS */);
+    }
+    if (val & 4) {
+      modifiable.push("SIGHASH_SINGLE" /* SIGHASH_SINGLE */);
+    }
+    return modifiable;
+  }
+  set PSBT_GLOBAL_TX_MODIFIABLE(modifiable) {
+    let val = 0;
+    if (modifiable.includes("INPUTS" /* INPUTS */)) {
+      val |= 1;
+    }
+    if (modifiable.includes("OUTPUTS" /* OUTPUTS */)) {
+      val |= 2;
+    }
+    if (modifiable.includes("SIGHASH_SINGLE" /* SIGHASH_SINGLE */)) {
+      val |= 4;
+    }
+    const br = new BufferWriter();
+    br.writeU8(val);
+    this.globalMap.set("06" /* PSBT_GLOBAL_TX_MODIFIABLE */, br.render());
+  }
+  get PSBT_GLOBAL_VERSION() {
+    const version = this.globalMap.get("fb" /* PSBT_GLOBAL_VERSION */)?.readUInt32LE(0);
+    if (version === void 0) {
+      console.warn("PSBT_GLOBAL_VERSION key is missing! Setting to version 2.");
+      this.PSBT_GLOBAL_VERSION = 2;
+    }
+    return version ?? 2;
+  }
+  set PSBT_GLOBAL_VERSION(version) {
+    let workingVersion = version;
+    if (workingVersion < 2) {
+      console.warn(
+        `PsbtV2 cannot have a global version less than 2. Version ${workingVersion} specified. Setting to version 2.`
+      );
+      workingVersion = 2;
+    }
+    const bw = new BufferWriter();
+    bw.writeU32(workingVersion);
+    this.globalMap.set("fb" /* PSBT_GLOBAL_VERSION */, bw.render());
+  }
+  get PSBT_GLOBAL_PROPRIETARY() {
+    return getNonUniqueKeyTypeValues(
+      this.globalMap,
+      "fc" /* PSBT_GLOBAL_PROPRIETARY */
+    );
+  }
+  /**
+   * Input Getters/Setters
+   */
+  get PSBT_IN_NON_WITNESS_UTXO() {
+    return getOptionalMappedBytesAsHex(
+      this.inputMaps,
+      "00" /* PSBT_IN_NON_WITNESS_UTXO */
+    );
+  }
+  get PSBT_IN_WITNESS_UTXO() {
+    return getOptionalMappedBytesAsHex(
+      this.inputMaps,
+      "01" /* PSBT_IN_WITNESS_UTXO */
+    );
+  }
+  get PSBT_IN_PARTIAL_SIG() {
+    return getNonUniqueKeyTypeValues(
+      this.inputMaps,
+      "02" /* PSBT_IN_PARTIAL_SIG */
+    );
+  }
+  get PSBT_IN_SIGHASH_TYPE() {
+    return getOptionalMappedBytesAsUInt(
+      this.inputMaps,
+      "03" /* PSBT_IN_SIGHASH_TYPE */
+    );
+  }
+  get PSBT_IN_REDEEM_SCRIPT() {
+    return getOptionalMappedBytesAsHex(
+      this.inputMaps,
+      "04" /* PSBT_IN_REDEEM_SCRIPT */
+    );
+  }
+  get PSBT_IN_WITNESS_SCRIPT() {
+    return getOptionalMappedBytesAsHex(
+      this.inputMaps,
+      "05" /* PSBT_IN_WITNESS_SCRIPT */
+    );
+  }
+  get PSBT_IN_BIP32_DERIVATION() {
+    return getNonUniqueKeyTypeValues(
+      this.inputMaps,
+      "06" /* PSBT_IN_BIP32_DERIVATION */
+    );
+  }
+  get PSBT_IN_FINAL_SCRIPTSIG() {
+    return getOptionalMappedBytesAsHex(
+      this.inputMaps,
+      "07" /* PSBT_IN_FINAL_SCRIPTSIG */
+    );
+  }
+  get PSBT_IN_FINAL_SCRIPTWITNESS() {
+    return getOptionalMappedBytesAsHex(
+      this.inputMaps,
+      "08" /* PSBT_IN_FINAL_SCRIPTWITNESS */
+    );
+  }
+  get PSBT_IN_POR_COMMITMENT() {
+    return getOptionalMappedBytesAsHex(
+      this.inputMaps,
+      "09" /* PSBT_IN_POR_COMMITMENT */
+    );
+  }
+  get PSBT_IN_RIPEMD160() {
+    return getNonUniqueKeyTypeValues(this.inputMaps, "0a" /* PSBT_IN_RIPEMD160 */);
+  }
+  get PSBT_IN_SHA256() {
+    return getNonUniqueKeyTypeValues(this.inputMaps, "0b" /* PSBT_IN_SHA256 */);
+  }
+  get PSBT_IN_HASH160() {
+    return getNonUniqueKeyTypeValues(this.inputMaps, "0c" /* PSBT_IN_HASH160 */);
+  }
+  get PSBT_IN_HASH256() {
+    return getNonUniqueKeyTypeValues(this.inputMaps, "0d" /* PSBT_IN_HASH256 */);
+  }
+  get PSBT_IN_PREVIOUS_TXID() {
+    const indices = [];
+    for (const map of this.inputMaps) {
+      const value = map.get("0e" /* PSBT_IN_PREVIOUS_TXID */);
+      if (!value) {
+        throw Error("PSBT_IN_PREVIOUS_TXID not set for an input");
+      }
+      indices.push(value.toString("hex"));
+    }
+    return indices;
+  }
+  get PSBT_IN_OUTPUT_INDEX() {
+    const indices = [];
+    for (const map of this.inputMaps) {
+      const value = map.get("0f" /* PSBT_IN_OUTPUT_INDEX */);
+      if (!value) {
+        throw Error("PSBT_IN_OUTPUT_INDEX not set for an input");
+      }
+      indices.push(value.readUInt32LE(0));
+    }
+    return indices;
+  }
+  get PSBT_IN_SEQUENCE() {
+    return getOptionalMappedBytesAsUInt(
+      this.inputMaps,
+      "10" /* PSBT_IN_SEQUENCE */
+    );
+  }
+  get PSBT_IN_REQUIRED_TIME_LOCKTIME() {
+    return getOptionalMappedBytesAsUInt(
+      this.inputMaps,
+      "11" /* PSBT_IN_REQUIRED_TIME_LOCKTIME */
+    );
+  }
+  get PSBT_IN_REQUIRED_HEIGHT_LOCKTIME() {
+    return getOptionalMappedBytesAsUInt(
+      this.inputMaps,
+      "12" /* PSBT_IN_REQUIRED_HEIGHT_LOCKTIME */
+    );
+  }
+  get PSBT_IN_TAP_KEY_SIG() {
+    return getOptionalMappedBytesAsHex(
+      this.inputMaps,
+      "13" /* PSBT_IN_TAP_KEY_SIG */
+    );
+  }
+  get PSBT_IN_TAP_SCRIPT_SIG() {
+    return getNonUniqueKeyTypeValues(
+      this.inputMaps,
+      "14" /* PSBT_IN_TAP_SCRIPT_SIG */
+    );
+  }
+  get PSBT_IN_TAP_LEAF_SCRIPT() {
+    return getNonUniqueKeyTypeValues(
+      this.inputMaps,
+      "15" /* PSBT_IN_TAP_LEAF_SCRIPT */
+    );
+  }
+  get PSBT_IN_TAP_BIP32_DERIVATION() {
+    return getNonUniqueKeyTypeValues(
+      this.inputMaps,
+      "16" /* PSBT_IN_TAP_BIP32_DERIVATION */
+    );
+  }
+  get PSBT_IN_TAP_INTERNAL_KEY() {
+    return getOptionalMappedBytesAsHex(
+      this.inputMaps,
+      "17" /* PSBT_IN_TAP_INTERNAL_KEY */
+    );
+  }
+  get PSBT_IN_TAP_MERKLE_ROOT() {
+    return getOptionalMappedBytesAsHex(
+      this.inputMaps,
+      "18" /* PSBT_IN_TAP_MERKLE_ROOT */
+    );
+  }
+  get PSBT_IN_PROPRIETARY() {
+    return getNonUniqueKeyTypeValues(
+      this.inputMaps,
+      "fc" /* PSBT_IN_PROPRIETARY */
+    );
+  }
+  /**
+   * Output Getters/Setters
+   */
+  get PSBT_OUT_REDEEM_SCRIPT() {
+    return getOptionalMappedBytesAsHex(
+      this.outputMaps,
+      "00" /* PSBT_OUT_REDEEM_SCRIPT */
+    );
+  }
+  get PSBT_OUT_WITNESS_SCRIPT() {
+    return getOptionalMappedBytesAsHex(
+      this.outputMaps,
+      "01" /* PSBT_OUT_WITNESS_SCRIPT */
+    );
+  }
+  get PSBT_OUT_BIP32_DERIVATION() {
+    return getNonUniqueKeyTypeValues(
+      this.outputMaps,
+      "02" /* PSBT_OUT_BIP32_DERIVATION */
+    );
+  }
+  get PSBT_OUT_AMOUNT() {
+    const indices = [];
+    for (const map of this.outputMaps) {
+      const value = map.get("03" /* PSBT_OUT_AMOUNT */);
+      if (!value) {
+        throw Error("PSBT_OUT_AMOUNT not set for an output");
+      }
+      const br = new BufferReader(value);
+      indices.push(br.readBigI64(value));
+    }
+    return indices;
+  }
+  get PSBT_OUT_SCRIPT() {
+    const indices = [];
+    for (const map of this.outputMaps) {
+      const value = map.get("04" /* PSBT_OUT_SCRIPT */);
+      if (!value) {
+        throw Error("PSBT_OUT_SCRIPT not set for an output");
+      }
+      indices.push(value.toString("hex"));
+    }
+    return indices;
+  }
+  get PSBT_OUT_TAP_INTERNAL_KEY() {
+    return getOptionalMappedBytesAsHex(
+      this.outputMaps,
+      "05" /* PSBT_OUT_TAP_INTERNAL_KEY */
+    );
+  }
+  get PSBT_OUT_TAP_TREE() {
+    return getOptionalMappedBytesAsHex(
+      this.outputMaps,
+      "06" /* PSBT_OUT_TAP_TREE */
+    );
+  }
+  get PSBT_OUT_TAP_BIP32_DERIVATION() {
+    return getNonUniqueKeyTypeValues(
+      this.outputMaps,
+      "07" /* PSBT_OUT_TAP_BIP32_DERIVATION */
+    );
+  }
+  get PSBT_OUT_PROPRIETARY() {
+    return getNonUniqueKeyTypeValues(
+      this.outputMaps,
+      "fc" /* PSBT_OUT_PROPRIETARY */
+    );
+  }
+  /**
+   * Other Getters/Setters
+   */
+  get nLockTime() {
+    const inputCount = this.PSBT_GLOBAL_INPUT_COUNT;
+    const heightLocks = this.PSBT_IN_REQUIRED_HEIGHT_LOCKTIME;
+    const timeLocks = this.PSBT_IN_REQUIRED_TIME_LOCKTIME;
+    let heights = [];
+    let times = [];
+    for (let i = 0; i < this.PSBT_GLOBAL_INPUT_COUNT; i++) {
+      if (heightLocks[i] !== null) {
+        heights.push(heightLocks[i]);
+      }
+      if (timeLocks[i] !== null) {
+        times.push(timeLocks[i]);
+      }
+    }
+    if (heights.length === 0 && times.length === 0) {
+      return this.PSBT_GLOBAL_FALLBACK_LOCKTIME || 0;
+    }
+    if (heights.length === inputCount || heights.length > times.length) {
+      return Math.max(...heights);
+    }
+    if (times.length > heights.length) {
+      return Math.max(...times);
+    }
+    return null;
+  }
+  /**
+   * Creator/Constructor Methods
+   */
+  // This method ensures that global fields have initial values required by a
+  // PsbtV2 Creator. It is called by the constructor if constructed without a
+  // psbt.
+  create() {
+    this.PSBT_GLOBAL_VERSION = 2;
+    this.PSBT_GLOBAL_TX_VERSION = 2;
+    this.PSBT_GLOBAL_INPUT_COUNT = 0;
+    this.PSBT_GLOBAL_OUTPUT_COUNT = 0;
+    this.PSBT_GLOBAL_FALLBACK_LOCKTIME = 0;
+  }
+  // This method should check initial construction of any valid PsbtV2. It is
+  // called when a psbt is passed to the constructor or when a new psbt is being
+  // created. If constructed with a psbt, this method acts outside of the
+  // Creator role to validate the current state of the psbt.
+  validate() {
+    if (this.PSBT_GLOBAL_VERSION < 2) {
+      throw Error("PsbtV2 has a version field set less than 2");
+    }
+    if (this.PSBT_GLOBAL_TX_VERSION < 2) {
+      throw Error("PsbtV2 has a tx version field set less than 2");
+    }
+    for (const prevInTxid of this.PSBT_IN_PREVIOUS_TXID) {
+      if (!prevInTxid) {
+        throw Error("PsbtV2 input is missing PSBT_IN_PREVIOUS_TXID");
+      }
+    }
+    for (const prevInVOut of this.PSBT_IN_OUTPUT_INDEX) {
+      if (prevInVOut === void 0) {
+        throw Error("PsbtV2 input is missing PSBT_IN_OUTPUT_INDEX");
+      }
+    }
+    for (const amount of this.PSBT_OUT_AMOUNT) {
+      if (!amount) {
+        throw Error("PsbtV2 input is missing PSBT_OUT_AMOUNT");
+      }
+    }
+    for (const script of this.PSBT_OUT_SCRIPT) {
+      if (!script) {
+        throw Error("PsbtV2 input is missing PSBT_OUT_SCRIPT");
+      }
+    }
+    for (const locktime of this.PSBT_IN_REQUIRED_TIME_LOCKTIME) {
+      if (locktime && locktime < 5e8) {
+        throw Error("PsbtV2 input time locktime is less than 500000000.");
+      }
+    }
+    for (const locktime of this.PSBT_IN_REQUIRED_HEIGHT_LOCKTIME) {
+      if (locktime && locktime >= 5e8) {
+        throw Error("PsbtV2 input hight locktime is gte 500000000.");
+      }
+    }
+  }
+  // This method is provided for compatibility issues and probably shouldn't be
+  // used since a PsbtV2 with PSBT_GLOBAL_TX_VERSION = 1 is BIP0370
+  // non-compliant. No guarantees can be made here that a serialized PsbtV2
+  // which used this method will be compatible with outside consumers.
+  //
+  // One may wish to instance this class from a partially signed
+  // PSBTv0 with a txn version 1 by using the static PsbtV2.FromV0. This method
+  // provides a way to override validation logic for the txn version and roles
+  // lifecycle defined for PsbtV2.
+  dangerouslySetGlobalTxVersion1() {
+    console.warn("Dangerously setting PsbtV2.PSBT_GLOBAL_TX_VERSION to 1!");
+    const bw = new BufferWriter();
+    bw.writeI32(1);
+    this.globalMap.set("02" /* PSBT_GLOBAL_TX_VERSION */, bw.render());
+  }
+  // Is this a Creator/Constructor role action, or something else. BIPs don't
+  // define it well.
+  addGlobalXpub(xpub, fingerprint, path) {
+    const bw = new BufferWriter();
+    bw.writeBytes(Buffer.from("01" /* PSBT_GLOBAL_XPUB */, "hex"));
+    bw.writeBytes(xpub);
+    const key = bw.render().toString("hex");
+    bw.writeBytes(fingerprint);
+    const pathBytes = parseDerivationPathNodesToBytes(path);
+    bw.writeBytes(pathBytes);
+    const value = bw.render();
+    this.globalMap.set(key, value);
+  }
+  addInput({
+    previousTxId,
+    outputIndex,
+    sequence,
+    nonWitnessUtxo,
+    witnessUtxo,
+    redeemScript,
+    witnessScript,
+    bip32Derivation
+  }) {
+    if (!this.isModifiable(["INPUTS" /* INPUTS */])) {
+      throw Error(
+        "PsbtV2.PSBT_GLOBAL_TX_MODIFIABLE inputs cannot be modified."
+      );
+    }
+    const map = /* @__PURE__ */ new Map();
+    const bw = new BufferWriter();
+    const prevTxIdBuf = bufferize(previousTxId);
+    bw.writeBytes(prevTxIdBuf);
+    map.set("0e" /* PSBT_IN_PREVIOUS_TXID */, bw.render());
+    bw.writeI32(outputIndex);
+    map.set("0f" /* PSBT_IN_OUTPUT_INDEX */, bw.render());
+    if (sequence) {
+      bw.writeI32(sequence);
+      map.set("10" /* PSBT_IN_SEQUENCE */, bw.render());
+    }
+    if (nonWitnessUtxo) {
+      bw.writeBytes(nonWitnessUtxo);
+      map.set("00" /* PSBT_IN_NON_WITNESS_UTXO */, bw.render());
+    }
+    if (witnessUtxo) {
+      bw.writeI64(witnessUtxo.amount);
+      bw.writeU8(witnessUtxo.script.length);
+      bw.writeBytes(witnessUtxo.script);
+      map.set("01" /* PSBT_IN_WITNESS_UTXO */, bw.render());
+    }
+    if (redeemScript) {
+      bw.writeBytes(redeemScript);
+      map.set("04" /* PSBT_IN_REDEEM_SCRIPT */, bw.render());
+    }
+    if (witnessScript) {
+      bw.writeBytes(witnessScript);
+      map.set("05" /* PSBT_IN_WITNESS_SCRIPT */, bw.render());
+    }
+    if (bip32Derivation) {
+      for (const bip32 of bip32Derivation) {
+        bw.writeString("06" /* PSBT_IN_BIP32_DERIVATION */, "hex");
+        bw.writeBytes(bip32.pubkey);
+        const key = bw.render().toString("hex");
+        bw.writeBytes(bip32.masterFingerprint);
+        bw.writeBytes(parseDerivationPathNodesToBytes(bip32.path));
+        map.set(key, bw.render());
+      }
+    }
+    this.PSBT_GLOBAL_INPUT_COUNT = this.inputMaps.push(map);
+  }
+  addOutput({
+    amount,
+    script,
+    redeemScript,
+    witnessScript,
+    bip32Derivation
+  }) {
+    if (!this.isModifiable(["OUTPUTS" /* OUTPUTS */])) {
+      throw Error(
+        "PsbtV2.PSBT_GLOBAL_TX_MODIFIABLE outputs cannot be modified."
+      );
+    }
+    const map = /* @__PURE__ */ new Map();
+    const bw = new BufferWriter();
+    bw.writeI64(amount);
+    map.set("03" /* PSBT_OUT_AMOUNT */, bw.render());
+    bw.writeBytes(script);
+    map.set("04" /* PSBT_OUT_SCRIPT */, bw.render());
+    if (redeemScript) {
+      bw.writeBytes(redeemScript);
+      map.set("00" /* PSBT_OUT_REDEEM_SCRIPT */, bw.render());
+    }
+    if (witnessScript) {
+      bw.writeBytes(witnessScript);
+      map.set("01" /* PSBT_OUT_WITNESS_SCRIPT */, bw.render());
+    }
+    if (bip32Derivation) {
+      for (const bip32 of bip32Derivation) {
+        bw.writeString("02" /* PSBT_OUT_BIP32_DERIVATION */, "hex");
+        bw.writeBytes(bip32.pubkey);
+        const key = bw.render().toString("hex");
+        bw.writeBytes(bip32.masterFingerprint);
+        bw.writeBytes(parseDerivationPathNodesToBytes(bip32.path));
+        map.set(key, bw.render());
+      }
+    }
+    this.outputMaps.push(map);
+    this.PSBT_GLOBAL_OUTPUT_COUNT = this.outputMaps.length;
+  }
+  /**
+   * Updater/Signer Methods
+   */
+  // Removes an input-map from inputMaps
+  deleteInput(index) {
+    if (!this.isModifiable(["INPUTS" /* INPUTS */])) {
+      throw Error(
+        "PsbtV2.PSBT_GLOBAL_TX_MODIFIABLE inputs cannot be modified."
+      );
+    }
+    const newInputs = this.inputMaps.filter((_, i) => i !== index);
+    this.inputMaps = newInputs;
+    this.PSBT_GLOBAL_INPUT_COUNT = this.inputMaps.length;
+  }
+  // Removes an output-map from outputMaps
+  deleteOutput(index) {
+    if (!this.isModifiable(["OUTPUTS" /* OUTPUTS */])) {
+      throw Error(
+        "PsbtV2.PSBT_GLOBAL_TX_MODIFIABLE outputs cannot be modified."
+      );
+    }
+    const newOutputs = this.outputMaps.filter((_, i) => i !== index);
+    if (this.isModifiable(["SIGHASH_SINGLE" /* SIGHASH_SINGLE */])) {
+      this.removePartialSig(index);
+    }
+    this.outputMaps = newOutputs;
+    this.PSBT_GLOBAL_OUTPUT_COUNT = this.outputMaps.length;
+  }
+  // Checks that provided flags are present in PSBT_GLOBAL_TX_MODIFIABLE.
+  isModifiable(flags) {
+    for (const flag of flags) {
+      if (!this.PSBT_GLOBAL_TX_MODIFIABLE.includes(flag)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  // The Signer, when it creates a signature, must add the partial sig keypair
+  // to the psbt for the input which it is signing. In the case that a
+  // particular signer does not, this method can be used to add a signature to
+  // the psbt. This method assumes the Signer did the validation outlined in
+  // BIP0174 before creating a signature.
+  // https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki#signer
+  addPartialSig(inputIndex, pubkey, sig) {
+    if (!this.inputMaps[inputIndex]) {
+      throw Error(`PsbtV2 has no input at ${inputIndex}`);
+    }
+    if (!pubkey || !sig) {
+      throw Error(
+        `PsbtV2.addPartialSig() missing argument ${!pubkey && "pubkey" || !sig && "sig"}`
+      );
+    }
+    const key = `${"02" /* PSBT_IN_PARTIAL_SIG */}${pubkey.toString("hex")}`;
+    if (this.inputMaps[inputIndex].has(key)) {
+      throw Error(
+        "PsbtV2 already has a signature for this input with this pubkey"
+      );
+    }
+    const modBackup = this.PSBT_GLOBAL_TX_MODIFIABLE;
+    try {
+      this.inputMaps[inputIndex].set(key, sig);
+      this.handleSighashType(sig);
+    } catch (err) {
+      console.error(err);
+      this.inputMaps[inputIndex].delete(key);
+      this.PSBT_GLOBAL_TX_MODIFIABLE = modBackup;
+    }
+  }
+  // Removes all sigs for an input unless a pubkey is specified.
+  removePartialSig(inputIndex, pubkey) {
+    const input = this.inputMaps[inputIndex];
+    if (!input) {
+      throw Error(`PsbtV2 has no input at ${inputIndex}`);
+    }
+    if (pubkey) {
+      const key = `${"02" /* PSBT_IN_PARTIAL_SIG */}${pubkey.toString("hex")}`;
+      const sig = this.PSBT_IN_PARTIAL_SIG[inputIndex].find(
+        (el) => el.key === key
+      );
+      if (!sig) {
+        throw Error(
+          `PsbtV2 input has no signature from pubkey ${pubkey.toString("hex")}`
+        );
+      }
+      input.delete(key);
+    } else {
+      const sigs = this.PSBT_IN_PARTIAL_SIG[inputIndex];
+      for (const sig of sigs) {
+        input.delete(sig.key);
+      }
+    }
+  }
+  // Used to ensure the PSBT is in the proper state when adding a partial sig
+  // keypair.
+  // https://github.com/bitcoin/bips/blob/master/bip-0370.mediawiki#signer
+  handleSighashType(sig) {
+    const br = new BufferReader(sig.slice(-1));
+    let sighashVal = br.readU8();
+    let modifiable = this.PSBT_GLOBAL_TX_MODIFIABLE;
+    if (!(sighashVal & 128 /* SIGHASH_ANYONECANPAY */)) {
+      modifiable = modifiable.filter(
+        (val) => val !== "INPUTS" /* INPUTS */
+      );
+    } else {
+      sighashVal ^= 128 /* SIGHASH_ANYONECANPAY */;
+    }
+    if (sighashVal !== 2 /* SIGHASH_NONE */) {
+      modifiable = modifiable.filter(
+        (val) => val !== "OUTPUTS" /* OUTPUTS */
+      );
+    }
+    if (sighashVal === 3 /* SIGHASH_SINGLE */ && !modifiable.includes("SIGHASH_SINGLE" /* SIGHASH_SINGLE */)) {
+      modifiable.push("SIGHASH_SINGLE" /* SIGHASH_SINGLE */);
+    }
+    this.PSBT_GLOBAL_TX_MODIFIABLE = modifiable;
+  }
+  // Attempt to return a PsbtV2 by converting from a PsbtV0 string or Buffer
+  static FromV0(psbt, allowTxnVersion1 = false) {
+    const psbtv0Buf = bufferize(psbt);
+    const psbtv0 = Psbt2.fromBuffer(psbtv0Buf);
+    const psbtv0GlobalMap = psbtv0.data.globalMap;
+    const psbtv2 = new _PsbtV2();
+    psbtv2.PSBT_GLOBAL_TX_MODIFIABLE = [
+      "INPUTS" /* INPUTS */,
+      "OUTPUTS" /* OUTPUTS */
+    ];
+    const txVersion = psbtv0.data.getTransaction().readInt32LE(0);
+    if (txVersion === 1 && allowTxnVersion1) {
+      psbtv2.dangerouslySetGlobalTxVersion1();
+    } else {
+      psbtv2.PSBT_GLOBAL_TX_VERSION = psbtv0.data.getTransaction().readInt32LE(0);
+    }
+    for (const globalXpub of psbtv0GlobalMap.globalXpub ?? []) {
+      psbtv2.addGlobalXpub(
+        globalXpub.extendedPubkey,
+        globalXpub.masterFingerprint,
+        globalXpub.path
+      );
+    }
+    let txInputs = [];
+    for (const [index, txInput] of psbtv0.txInputs.entries()) {
+      txInputs[index] = txInput;
+    }
+    for (const [index, input] of psbtv0.data.inputs.entries()) {
+      const txInput = txInputs[index];
+      psbtv2.addInput({
+        previousTxId: txInput.hash,
+        outputIndex: txInput.index,
+        sequence: txInput.sequence,
+        nonWitnessUtxo: input.nonWitnessUtxo,
+        witnessUtxo: input.witnessUtxo && {
+          amount: input.witnessUtxo.value,
+          script: input.witnessUtxo.script
+        },
+        redeemScript: input.redeemScript,
+        witnessScript: input.witnessScript,
+        bip32Derivation: input.bip32Derivation
+      });
+    }
+    let txOutputs = [];
+    for (const [index, txOutput] of psbtv0.txOutputs.entries()) {
+      txOutputs[index] = txOutput;
+    }
+    for (const [index, output] of psbtv0.data.outputs.entries()) {
+      const txOutput = txOutputs[index];
+      psbtv2.addOutput({
+        amount: txOutput.value,
+        script: txOutput.script,
+        redeemScript: output.redeemScript,
+        witnessScript: output.witnessScript,
+        bip32Derivation: output.bip32Derivation
+      });
+    }
+    for (const [index, input] of psbtv0.data.inputs.entries()) {
+      for (const sig of input.partialSig || []) {
+        psbtv2.addPartialSig(index, sig.pubkey, sig.signature);
+      }
+    }
+    return psbtv2;
+  }
+};
+function getPsbtVersionNumber(psbt) {
+  const map = /* @__PURE__ */ new Map();
+  const buf = bufferize(psbt);
+  const br = new BufferReader(buf.slice(PSBT_MAGIC_BYTES.length));
+  readAndSetKeyPairs(map, br);
+  return map.get("fb" /* PSBT_GLOBAL_VERSION */)?.readUInt32LE(0) || 0;
+}
+export {
+  PsbtV2,
+  getPsbtVersionNumber
+};