@caravan/psbt 1.0.0 → 1.1.0

package/src/{psbtv2.ts → psbtv2/psbtv2.ts}

@@ -1,3 +1,23 @@
+import { BufferReader, BufferWriter } from "bufio";
+import { Psbt } from "bitcoinjs-lib";
+
+import {
+  Key,
+  Value,
+  NonUniqueKeyTypeValue,
+  KeyType,
+  PsbtGlobalTxModifiableBits,
+  SighashType,
+} from "./types";
+import {
+  bufferize,
+  getNonUniqueKeyTypeValues,
+  getOptionalMappedBytesAsHex,
+  getOptionalMappedBytesAsUInt,
+  parseDerivationPathNodesToBytes,
+} from "./functions";
+import { PsbtV2Maps } from "./psbtv2maps";
+
 /**
  * The PsbtV2 class is intended to represent an easily modifiable and
  * serializable psbt of version 2 conforming to BIP0174. Getters exist for all
@@ -8,370 +28,6 @@
  * https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki
  * https://github.com/bitcoin/bips/blob/master/bip-0370.mediawiki
  */
-
-import { BufferReader, BufferWriter } from "bufio";
-import { Psbt } from "bitcoinjs-lib";
-
-import { validateHex, validBase64, validateBIP32Path } from "@caravan/bitcoin";
-import { PSBT_MAGIC_BYTES } from "./psbt";
-
-/**
- * Global Types
- */
-
-/**
- * Hex encoded string containing `<keytype><keydata>`. A string is needed for
- * Map.get() since it matches by identity. Most commonly, a `Key` only contains a
- * keytype byte, however, some with keydata can allow for multiple unique keys
- * of the same type.
- */
-type Key = string;
-
-/**
- * Values can be of various different types or formats. Here we leave them as
- * Buffers so that getters can decide how they should be formatted.
- */
-type Value = Buffer;
-
-type NonUniqueKeyTypeValue = { key: string; value: string | null };
-
-/**
- * KeyTypes are hex bytes, but within this module are used as string enums to
- * assist in Map lookups. See type `Key` for more info.
- */
-//eslint-disable-next-line no-shadow
-enum KeyType {
-  PSBT_GLOBAL_XPUB = "01",
-  PSBT_GLOBAL_TX_VERSION = "02",
-  PSBT_GLOBAL_FALLBACK_LOCKTIME = "03",
-  PSBT_GLOBAL_INPUT_COUNT = "04",
-  PSBT_GLOBAL_OUTPUT_COUNT = "05",
-  PSBT_GLOBAL_TX_MODIFIABLE = "06",
-  PSBT_GLOBAL_VERSION = "fb",
-  PSBT_GLOBAL_PROPRIETARY = "fc",
-
-  PSBT_IN_NON_WITNESS_UTXO = "00",
-  PSBT_IN_WITNESS_UTXO = "01",
-  PSBT_IN_PARTIAL_SIG = "02",
-  PSBT_IN_SIGHASH_TYPE = "03",
-  PSBT_IN_REDEEM_SCRIPT = "04",
-  PSBT_IN_WITNESS_SCRIPT = "05",
-  PSBT_IN_BIP32_DERIVATION = "06",
-  PSBT_IN_FINAL_SCRIPTSIG = "07",
-  PSBT_IN_FINAL_SCRIPTWITNESS = "08",
-  PSBT_IN_POR_COMMITMENT = "09",
-  PSBT_IN_RIPEMD160 = "0a",
-  PSBT_IN_SHA256 = "0b",
-  PSBT_IN_HASH160 = "0c",
-  PSBT_IN_HASH256 = "0d",
-  PSBT_IN_PREVIOUS_TXID = "0e",
-  PSBT_IN_OUTPUT_INDEX = "0f",
-  PSBT_IN_SEQUENCE = "10",
-  PSBT_IN_REQUIRED_TIME_LOCKTIME = "11",
-  PSBT_IN_REQUIRED_HEIGHT_LOCKTIME = "12",
-  PSBT_IN_TAP_KEY_SIG = "13",
-  PSBT_IN_TAP_SCRIPT_SIG = "14",
-  PSBT_IN_TAP_LEAF_SCRIPT = "15",
-  PSBT_IN_TAP_BIP32_DERIVATION = "16",
-  PSBT_IN_TAP_INTERNAL_KEY = "17",
-  PSBT_IN_TAP_MERKLE_ROOT = "18",
-  PSBT_IN_PROPRIETARY = "fc",
-
-  PSBT_OUT_REDEEM_SCRIPT = "00",
-  PSBT_OUT_WITNESS_SCRIPT = "01",
-  PSBT_OUT_BIP32_DERIVATION = "02",
-  PSBT_OUT_AMOUNT = "03",
-  PSBT_OUT_SCRIPT = "04",
-  PSBT_OUT_TAP_INTERNAL_KEY = "05",
-  PSBT_OUT_TAP_TREE = "06",
-  PSBT_OUT_TAP_BIP32_DERIVATION = "07",
-  PSBT_OUT_PROPRIETARY = "fc",
-}
-
-/**
- * Provided to friendly-format the `PSBT_GLOBAL_TX_MODIFIABLE` bitmask from
- * `PsbtV2.PSBT_GLOBAL_TX_MODIFIABLE` which returns
- * `PsbtGlobalTxModifiableBits[]`.
- */
-// eslint-disable-next-line no-shadow
-enum PsbtGlobalTxModifiableBits {
-  INPUTS = "INPUTS", // 0b00000001
-  OUTPUTS = "OUTPUTS", // 0b00000010
-  SIGHASH_SINGLE = "SIGHASH_SINGLE", // 0b00000100
-}
-
-// eslint-disable-next-line no-shadow
-enum SighashType {
-  SIGHASH_ALL = 0x01,
-  SIGHASH_NONE = 0x02,
-  SIGHASH_SINGLE = 0x03,
-  SIGHASH_ANYONECANPAY = 0x80,
-}
-
-/**
- * Global Constants
- */
-
-const PSBT_MAP_SEPARATOR = Buffer.from([0x00]);
-const BIP_32_NODE_REGEX = /(\/[0-9]+'?)/gi;
-const BIP_32_HARDENING_OFFSET = 0x80000000;
-
-/**
- * Helper Functions
- */
-
-/**
- * Ensure base64 and hex strings are a buffer. No-op if already a buffer.
- */
-function bufferize(psbt: string | Buffer): Buffer {
-  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.");
-}
-
-/**
- * Some keytypes have keydata which allows for multiple unique keys of the same
- * keytype. Getters which return values from these keys should search and return
- * values from all keys of that keytype. This function matches on the first byte
- * of each key string (hex encoded) and returns all values associated with those
- * keys as an array of string (hex encoded) values.
- */
-function getNonUniqueKeyTypeValues(
-  maps: Map<Key, Value> | Map<Key, Value>[],
-  keytype: KeyType,
-) {
-  if (Array.isArray(maps)) {
-    // It's a set of input or output maps, so recursively check each map and set
-    // values.
-    const values: NonUniqueKeyTypeValue[][] = maps.map(
-      (map) =>
-        // TODO: Figure out a better way to type this
-        getNonUniqueKeyTypeValues(map, keytype) as NonUniqueKeyTypeValue[],
-    );
-
-    return values;
-  }
-
-  const map = maps; // Not an array
-  const values: NonUniqueKeyTypeValue[] = [];
-
-  for (const [key, value] of map.entries()) {
-    if (key.startsWith(keytype)) {
-      values.push({ key, value: value?.toString("hex") || null });
-    }
-  }
-
-  return values;
-}
-
-/**
- * A getter helper for optional keytypes which returns lists of values as hex
- * strings.
- */
-function getOptionalMappedBytesAsHex(
-  maps: Map<Key, Value>[],
-  keytype: KeyType,
-) {
-  return maps.map((map) => map.get(keytype)?.toString("hex") ?? null);
-}
-
-/**
- * A getter helper for optional keytypes which returns lists of values as
- * numbers.
- */
-function getOptionalMappedBytesAsUInt(
-  maps: Map<Key, Value>[],
-  keytype: KeyType,
-) {
-  return maps.map((map) => map.get(keytype)?.readUInt32LE(0) ?? null);
-}
-
-/**
- * Accepts a BIP0032 path as a string and returns a Buffer containing uint32
- * values for each path node.
- */
-function parseDerivationPathNodesToBytes(path: string): Buffer {
-  const validationMessage = validateBIP32Path(path);
-  if (validationMessage !== "") {
-    throw Error(validationMessage);
-  }
-
-  const bw = new BufferWriter();
-
-  for (const node of path.match(BIP_32_NODE_REGEX) ?? []) {
-    // Skip slash and parse int
-    let num = parseInt(node.slice(1), 10);
-
-    if (node.indexOf("'") > -1) {
-      // Hardened node needs hardening
-      num += BIP_32_HARDENING_OFFSET;
-    }
-
-    bw.writeU32(num);
-  }
-
-  return bw.render();
-}
-
-/**
- * Takes a BufferReader and a Map then reads keypairs until it gets to a map
- * separator (keyLen 0x00 byte).
- */
-function readAndSetKeyPairs(map: Map<Key, Buffer>, br: BufferReader) {
-  const nextByte: Buffer = 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);
-}
-
-/**
- * Serializes a Map containing keypairs, includes keylen, and writes to the
- * BufferWriter.
- */
-function serializeMap(map: Map<Key, Value>, bw: BufferWriter): void {
-  map.forEach((value, key) => {
-    // Add <keylen><keytype><keydata>
-    const keyBuf = Buffer.from(key, "hex");
-    const keyLen = keyBuf.length;
-    bw.writeVarint(keyLen);
-    bw.writeString(key, "hex");
-
-    // Add <valuelen><valuedata>
-    bw.writeVarint(value.length);
-    bw.writeBytes(value);
-  });
-
-  bw.writeBytes(PSBT_MAP_SEPARATOR);
-}
-
-/**
- * This abstract class is provided for utility to allow for mapping, map
- * copying, and serialization operations for psbts. This does almost no
- * validation, so do not rely on it for ensuring a valid psbt.
- */
-export abstract class PsbtV2Maps {
-  // These maps directly correspond to the maps defined in BIP0174
-  protected globalMap: Map<Key, Value> = new Map();
-  protected inputMaps: Map<Key, Value>[] = [];
-  protected outputMaps: Map<Key, Value>[] = [];
-
-  constructor(psbt?: Buffer | string) {
-    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.");
-    }
-    // Build globalMap
-    readAndSetKeyPairs(this.globalMap, br);
-    if (
-      // Assuming that psbt being passed in is a valid psbtv2
-      !this.globalMap.has(KeyType.PSBT_GLOBAL_VERSION) ||
-      !this.globalMap.has(KeyType.PSBT_GLOBAL_TX_VERSION) ||
-      !this.globalMap.has(KeyType.PSBT_GLOBAL_INPUT_COUNT) ||
-      !this.globalMap.has(KeyType.PSBT_GLOBAL_OUTPUT_COUNT) ||
-      this.globalMap.has("00") // PsbtV2 must exclude key 0x00
-    ) {
-      throw Error("Provided PsbtV2 not valid. Missing required global keys.");
-    }
-
-    // Build inputMaps
-    const inputCount =
-      this.globalMap.get(KeyType.PSBT_GLOBAL_INPUT_COUNT)?.readUInt8(0) ?? 0;
-    for (let i = 0; i < inputCount; i++) {
-      const map = new Map<Key, Value>();
-      readAndSetKeyPairs(map, br);
-      this.inputMaps.push(map);
-    }
-
-    // Build outputMaps
-    const outputCount =
-      this.globalMap.get(KeyType.PSBT_GLOBAL_OUTPUT_COUNT)?.readUInt8(0) ?? 0;
-    for (let i = 0; i < outputCount; i++) {
-      const map = new Map<Key, Value>();
-      readAndSetKeyPairs(map, br);
-      this.outputMaps.push(map);
-    }
-  }
-
-  /**
-   * Return the current state of the psbt as a string in the specified format.
-   */
-  public serialize(format: "base64" | "hex" = "base64"): string {
-    // Build hex string from maps
-    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);
-  }
-
-  /**
-   * Copies the maps in this PsbtV2 object to another PsbtV2 object.
-   *
-   * NOTE: This copy method 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 state. PsbtV2.serialize is preferable whenever possible.
-   */
-  public copy(to: PsbtV2) {
-    this.copyMap(this.globalMap, to.globalMap);
-    this.copyMaps(this.inputMaps, to.inputMaps);
-    this.copyMaps(this.outputMaps, to.outputMaps);
-  }
-
-  private copyMaps(
-    from: readonly ReadonlyMap<string, Buffer>[],
-    to: Map<string, Buffer>[],
-  ) {
-    from.forEach((m, index) => {
-      const to_index = new Map<Key, Value>();
-      this.copyMap(m, to_index);
-      to[index] = to_index;
-    });
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  private copyMap(from: ReadonlyMap<string, Buffer>, to: Map<string, Buffer>) {
-    from.forEach((v, k) => to.set(k, Buffer.from(v)));
-  }
-}
-
-/**
- * Provides utilities for working with v2 PSBTs and tranlations or conversions
- * between v0 and v2.
- */
 export class PsbtV2 extends PsbtV2Maps {
   constructor(psbt?: Buffer | string) {
     super(psbt);
@@ -388,7 +44,10 @@ export class PsbtV2 extends PsbtV2Maps {
    */
 
   get PSBT_GLOBAL_XPUB() {
-    return getNonUniqueKeyTypeValues(this.globalMap, KeyType.PSBT_GLOBAL_XPUB);
+    return getNonUniqueKeyTypeValues(
+      this.globalMap,
+      KeyType.PSBT_GLOBAL_XPUB,
+    ) as NonUniqueKeyTypeValue[];
   }
 
   get PSBT_GLOBAL_TX_VERSION() {
@@ -533,7 +192,7 @@ export class PsbtV2 extends PsbtV2Maps {
     return getNonUniqueKeyTypeValues(
       this.globalMap,
       KeyType.PSBT_GLOBAL_PROPRIETARY,
-    );
+    ) as NonUniqueKeyTypeValue[];
   }
 
   /**
@@ -554,7 +213,7 @@ export class PsbtV2 extends PsbtV2Maps {
     );
   }
 
-  get PSBT_IN_PARTIAL_SIG(): NonUniqueKeyTypeValue[][] {
+  get PSBT_IN_PARTIAL_SIG() {
     return getNonUniqueKeyTypeValues(
       this.inputMaps,
       KeyType.PSBT_IN_PARTIAL_SIG,
@@ -586,7 +245,7 @@ export class PsbtV2 extends PsbtV2Maps {
     return getNonUniqueKeyTypeValues(
       this.inputMaps,
       KeyType.PSBT_IN_BIP32_DERIVATION,
-    );
+    ) as NonUniqueKeyTypeValue[][];
   }
 
   get PSBT_IN_FINAL_SCRIPTSIG() {
@@ -611,19 +270,31 @@ export class PsbtV2 extends PsbtV2Maps {
   }
 
   get PSBT_IN_RIPEMD160() {
-    return getNonUniqueKeyTypeValues(this.inputMaps, KeyType.PSBT_IN_RIPEMD160);
+    return getNonUniqueKeyTypeValues(
+      this.inputMaps,
+      KeyType.PSBT_IN_RIPEMD160,
+    ) as NonUniqueKeyTypeValue[][];
   }
 
   get PSBT_IN_SHA256() {
-    return getNonUniqueKeyTypeValues(this.inputMaps, KeyType.PSBT_IN_SHA256);
+    return getNonUniqueKeyTypeValues(
+      this.inputMaps,
+      KeyType.PSBT_IN_SHA256,
+    ) as NonUniqueKeyTypeValue[][];
   }
 
   get PSBT_IN_HASH160() {
-    return getNonUniqueKeyTypeValues(this.inputMaps, KeyType.PSBT_IN_HASH160);
+    return getNonUniqueKeyTypeValues(
+      this.inputMaps,
+      KeyType.PSBT_IN_HASH160,
+    ) as NonUniqueKeyTypeValue[][];
   }
 
   get PSBT_IN_HASH256() {
-    return getNonUniqueKeyTypeValues(this.inputMaps, KeyType.PSBT_IN_HASH256);
+    return getNonUniqueKeyTypeValues(
+      this.inputMaps,
+      KeyType.PSBT_IN_HASH256,
+    ) as NonUniqueKeyTypeValue[][];
   }
 
   get PSBT_IN_PREVIOUS_TXID() {
@@ -682,21 +353,21 @@ export class PsbtV2 extends PsbtV2Maps {
     return getNonUniqueKeyTypeValues(
       this.inputMaps,
       KeyType.PSBT_IN_TAP_SCRIPT_SIG,
-    );
+    ) as NonUniqueKeyTypeValue[][];
   }
 
   get PSBT_IN_TAP_LEAF_SCRIPT() {
     return getNonUniqueKeyTypeValues(
       this.inputMaps,
       KeyType.PSBT_IN_TAP_LEAF_SCRIPT,
-    );
+    ) as NonUniqueKeyTypeValue[][];
   }
 
   get PSBT_IN_TAP_BIP32_DERIVATION() {
     return getNonUniqueKeyTypeValues(
       this.inputMaps,
       KeyType.PSBT_IN_TAP_BIP32_DERIVATION,
-    );
+    ) as NonUniqueKeyTypeValue[][];
   }
 
   get PSBT_IN_TAP_INTERNAL_KEY() {
@@ -799,6 +470,191 @@ export class PsbtV2 extends PsbtV2Maps {
     );
   }
 
+  /**
+   * Operator Role Validation Getters
+   */
+
+  /**
+   * Returns true if the PsbtV2 is ready for an operator taking the Constructor
+   * role.
+   *
+   * This check assumes that the Creator used this class's constructor method to
+   * initialize the PsbtV2 without passing a psbt (constructor  defaults were
+   * set).
+   */
+  get isReadyForConstructor() {
+    // The Creator role (likely via the class constructor) must ensure at least
+    // the following value has been initialized. The psbt cannot be passed to
+    // the Constructor until it is set.
+    if (this.PSBT_GLOBAL_FALLBACK_LOCKTIME === null) {
+      return false;
+    }
+
+    // At least inputs or outputs must still be modifiable.
+    if (
+      !this.isModifiable([PsbtGlobalTxModifiableBits.INPUTS]) &&
+      !this.isModifiable([PsbtGlobalTxModifiableBits.OUTPUTS])
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Returns true if the PsbtV2 is ready for an operator taking the Updater
+   * role.
+   *
+   * Before signatures are added, but after an input is added, a PsbtV2 is
+   * likely to be ready for Constructor, ready for Updater, and ready for Signer
+   * simultaneously.
+   *
+   * According to BIP370, the Updater can modify the sequence number, but it is
+   * unclear if the Updater retains permissions provided in psbtv0 (BIP174). It
+   * is likely not the case that the Updater has the same permissions as
+   * previously because it seems to now be the realm of the Constructor to add
+   * inputs and outputs.
+   */
+  get isReadyForUpdater() {
+    // In psbtv2, the Updater can set the sequence number, but an input must
+    // exist for this to be set.
+    if (this.PSBT_GLOBAL_INPUT_COUNT === 0) {
+      return false;
+    }
+
+    // Inputs must still be modifiable
+    if (!this.isModifiable([PsbtGlobalTxModifiableBits.INPUTS])) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Returns true if the PsbtV2 is ready for an operator taking the Signer role.
+   */
+  get isReadyForSigner() {
+    // An input must exist before it can be signed.
+    if (this.PSBT_GLOBAL_INPUT_COUNT === 0) {
+      return false;
+    }
+
+    // TODO: Maybe it makes sense to more granularly check if the psbt is fully
+    // signed or has minimum signatures. Until then, just check that sigs have
+    // not been finalized.
+    if (this.isReadyForTransactionExtractor) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Returns true if the PsbtV2 is ready for an operator taking the Combiner
+   * role.
+   */
+  get isReadyForCombiner() {
+    // The combiner can potentially provide everything that's missing when
+    // merging another psbt. If it's at least ready for updates from the
+    // following roles, then it's ready for a Combiner.
+    return (
+      this.isReadyForConstructor ||
+      this.isReadyForUpdater ||
+      this.isReadyForSigner
+    );
+  }
+
+  /**
+   * Unimplemented. Returns false.
+   */
+  get isReadyForInputFinalizer() {
+    // Checks to see if the psbt contains everything needed to finalize inputs.
+    // This can become quite complicated considering multisig and taproot.
+    console.warn(
+      "PsbtV2.isReadyForInputFinalizer has been called, however, this getter is unimplemented and shouldn't be used.",
+    );
+    return false;
+  }
+
+  /**
+   * Returns true if the PsbtV2 is ready for an operator taking the Transaction
+   * Extractor role.
+   *
+   * If all the inputs have been finalized, then the psbt is ready for the
+   * Transaction Extractor. According to BIP 174, it's the responsibility of the
+   * Input Finalizer to add scriptSigs or scriptWitnesses and then remove other
+   * details besides the UTXO. This getter checks that the Input Finalizer has
+   * finished its job.
+   */
+  get isReadyForTransactionExtractor() {
+    // Iterate over all inputs
+
+    for (let i = 0; i < this.PSBT_GLOBAL_INPUT_COUNT; i++) {
+      // Check for finalized script
+      if (
+        !this.PSBT_IN_FINAL_SCRIPTSIG[i] &&
+        !this.PSBT_IN_FINAL_SCRIPTWITNESS[i]
+      ) {
+        return false;
+      }
+
+      // Check that the corresponding UTXO is still available
+      if (
+        (this.PSBT_IN_FINAL_SCRIPTSIG[i] &&
+          !this.PSBT_IN_NON_WITNESS_UTXO[i]) ||
+        (this.PSBT_IN_FINAL_SCRIPTWITNESS[i] && !this.PSBT_IN_WITNESS_UTXO[i])
+      ) {
+        return false;
+      }
+
+      // Check that Input Finalizer removed other values from the input.
+      //
+      // Test vectors from BIP 370 indicate that a missing PSBT_IN_OUTPUT_INDEX
+      // or PSBT_IN_PREVIOUS_TXID should be an invalid psbt, so the getters for
+      // these keys will throw unless the values are set. However, the BIP also
+      // requires that the Input Finalizer removes all other values from the
+      // input map except for the finalized scripts and UTXOs. Since removal of
+      // the above mentioned keys will result in an invalid psbt, it's decided
+      // here that it's safe to ignore the fact that those keys have not been
+      // removed.
+      if (
+        // Strings
+        this.PSBT_IN_REDEEM_SCRIPT[i] ||
+        this.PSBT_IN_WITNESS_SCRIPT[i] ||
+        this.PSBT_IN_POR_COMMITMENT[i] ||
+        this.PSBT_IN_TAP_KEY_SIG[i] ||
+        this.PSBT_IN_TAP_INTERNAL_KEY[i] ||
+        this.PSBT_IN_TAP_MERKLE_ROOT[i] ||
+        // Numbers
+        this.PSBT_IN_SIGHASH_TYPE[i] !== null ||
+        this.PSBT_IN_SEQUENCE[i] !== null ||
+        this.PSBT_IN_REQUIRED_TIME_LOCKTIME[i] !== null ||
+        this.PSBT_IN_REQUIRED_HEIGHT_LOCKTIME[i] !== null ||
+        // Arrays of non-unique keytype values
+        this.PSBT_IN_PARTIAL_SIG[i].filter((el) => el !== null).length > 0 ||
+        this.PSBT_IN_BIP32_DERIVATION[i].filter((el) => el !== null).length >
+          0 ||
+        this.PSBT_IN_RIPEMD160[i].filter((el) => el !== null).length > 0 ||
+        this.PSBT_IN_SHA256[i].filter((el) => el !== null).length > 0 ||
+        this.PSBT_IN_HASH160[i].filter((el) => el !== null).length > 0 ||
+        this.PSBT_IN_HASH256[i].filter((el) => el !== null).length > 0 ||
+        this.PSBT_IN_TAP_SCRIPT_SIG[i].filter((el) => el !== null).length > 0 ||
+        this.PSBT_IN_TAP_LEAF_SCRIPT[i].filter((el) => el !== null).length >
+          0 ||
+        this.PSBT_IN_TAP_BIP32_DERIVATION[i].filter((el) => el !== null)
+          .length > 0
+      ) {
+        return false;
+      }
+
+      // This input has been finalized. Continue checking the next one.
+    }
+
+    // All inputs have been finalized, so this psbt is ready for transaction
+    // extraction.
+    return true;
+  }
+
   /**
    * Other Getters/Setters
    */
@@ -874,7 +730,15 @@ export class PsbtV2 extends PsbtV2Maps {
     this.PSBT_GLOBAL_TX_VERSION = 2;
     this.PSBT_GLOBAL_INPUT_COUNT = 0;
     this.PSBT_GLOBAL_OUTPUT_COUNT = 0;
+
+    // TODO: Right now these values are setting a default. How can it be made to
+    // accept values on the constructor method? The Creator role should be
+    // allowed to configure these.
     this.PSBT_GLOBAL_FALLBACK_LOCKTIME = 0;
+    this.PSBT_GLOBAL_TX_MODIFIABLE = [
+      PsbtGlobalTxModifiableBits.INPUTS,
+      PsbtGlobalTxModifiableBits.OUTPUTS,
+    ];
   }
 
   /**
@@ -935,13 +799,18 @@ export class PsbtV2 extends PsbtV2Maps {
    * defined for PsbtV2.
    */
   public dangerouslySetGlobalTxVersion1() {
+    if (!this.isReadyForConstructor) {
+      throw Error(
+        "The PsbtV2 is not ready for a Constructor. The PSBT_GLOBAL_TX_VERSION should not be forced to version 1.",
+      );
+    }
     console.warn("Dangerously setting PsbtV2.PSBT_GLOBAL_TX_VERSION to 1!");
     const bw = new BufferWriter();
     bw.writeI32(1);
     this.globalMap.set(KeyType.PSBT_GLOBAL_TX_VERSION, bw.render());
   }
 
-  // Is this a Creator/Constructor role action, or something else. BIPs don't
+  // Is this a Creator/Constructor role action, or something else? BIPs don't
   // define it well.
   public addGlobalXpub(xpub: Buffer, fingerprint: Buffer, path: string) {
     const bw = new BufferWriter();
@@ -982,6 +851,17 @@ export class PsbtV2 extends PsbtV2Maps {
     // significant validation concerning this step detailed in the BIP0370
     // Constructor role:
     // https://github.com/bitcoin/bips/blob/master/bip-0370.mediawiki#constructor
+    //
+    // TODO: This method must properly handle the SIGHASH_SINGLE flag. If the
+    // `PSBT_GLOBAL_TX_MODIFIABLE` flag `SIGHASH_SINGLE` is present and a
+    // signature is present, then adding or removing  inputs or outputs before a
+    // signature with sighash_single must happen atomically in pairs.
+
+    if (!this.isReadyForConstructor) {
+      throw Error(
+        "The PsbtV2 is not ready for a Constructor. Inputs cannot be added.",
+      );
+    }
     if (!this.isModifiable([PsbtGlobalTxModifiableBits.INPUTS])) {
       throw Error(
         "PsbtV2.PSBT_GLOBAL_TX_MODIFIABLE inputs cannot be modified.",
@@ -1048,6 +928,11 @@ export class PsbtV2 extends PsbtV2Maps {
       path: string;
     }[];
   }) {
+    if (!this.isReadyForConstructor) {
+      throw Error(
+        "The PsbtV2 is not ready for a Constructor. Outputs cannot be added.",
+      );
+    }
     if (!this.isModifiable([PsbtGlobalTxModifiableBits.OUTPUTS])) {
       throw Error(
         "PsbtV2.PSBT_GLOBAL_TX_MODIFIABLE outputs cannot be modified.",
@@ -1091,6 +976,11 @@ export class PsbtV2 extends PsbtV2Maps {
    * Removes an input-map from inputMaps.
    */
   public deleteInput(index: number) {
+    if (!this.isReadyForConstructor) {
+      throw Error(
+        "The PsbtV2 is not ready for a Constructor. Inputs cannot be removed.",
+      );
+    }
     if (!this.isModifiable([PsbtGlobalTxModifiableBits.INPUTS])) {
       throw Error(
         "PsbtV2.PSBT_GLOBAL_TX_MODIFIABLE inputs cannot be modified.",
@@ -1105,6 +995,11 @@ export class PsbtV2 extends PsbtV2Maps {
    * Removes an output-map from outputMaps.
    */
   public deleteOutput(index: number) {
+    if (!this.isReadyForConstructor) {
+      throw Error(
+        "The PsbtV2 is not ready for a Constructor. Outputs cannot be removed.",
+      );
+    }
     if (!this.isModifiable([PsbtGlobalTxModifiableBits.OUTPUTS])) {
       throw Error(
         "PsbtV2.PSBT_GLOBAL_TX_MODIFIABLE outputs cannot be modified.",
@@ -1126,7 +1021,7 @@ export class PsbtV2 extends PsbtV2Maps {
   }
 
   /**
-   * Checks that provided flags are present in PSBT_GLOBAL_TX_MODIFIABLE.
+   * Checks that all provided flags are present in PSBT_GLOBAL_TX_MODIFIABLE.
    */
   private isModifiable(flags: PsbtGlobalTxModifiableBits[]) {
     for (const flag of flags) {
@@ -1152,6 +1047,11 @@ export class PsbtV2 extends PsbtV2Maps {
    * https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki#signer
    */
   public addPartialSig(inputIndex: number, pubkey: Buffer, sig: Buffer) {
+    if (!this.isReadyForSigner) {
+      throw Error(
+        "The PsbtV2 is not ready for a Signer. Partial sigs cannot be added.",
+      );
+    }
     if (!this.inputMaps[inputIndex]) {
       throw Error(`PsbtV2 has no input at ${inputIndex}`);
     }
@@ -1189,6 +1089,8 @@ export class PsbtV2 extends PsbtV2Maps {
    * the pubkey exists.
    */
   public removePartialSig(inputIndex: number, pubkey?: Buffer) {
+    // TODO: What role is allowed to remove a partial sig? Perform that
+    // role-check validation here.
     const input = this.inputMaps[inputIndex];
 
     if (!input) {
@@ -1253,7 +1155,11 @@ export class PsbtV2 extends PsbtV2Maps {
   }
 
   /**
-   * Attempts to return a PsbtV2 by converting from a PsbtV0 string or Buffer
+   * Attempts to return a PsbtV2 by converting from a PsbtV0 string or Buffer.
+   *
+   * This method first starts with a fresh PsbtV2 having just been created. It
+   * then takes the PsbtV2 through its operator saga through the Signer role. In
+   * this sense validation for each operator role will be performed.
    */
   static FromV0(psbt: string | Buffer, allowTxnVersion1 = false): PsbtV2 {
     const psbtv0Buf = bufferize(psbt);
@@ -1262,11 +1168,6 @@ export class PsbtV2 extends PsbtV2Maps {
 
     // Creator Role
     const psbtv2 = new PsbtV2();
-    // Set it fully modifiable so that we can add the v0 inputs and outputs.
-    psbtv2.PSBT_GLOBAL_TX_MODIFIABLE = [
-      PsbtGlobalTxModifiableBits.INPUTS,
-      PsbtGlobalTxModifiableBits.OUTPUTS,
-    ];
     const txVersion = psbtv0.data.getTransaction().readInt32LE(0);
     if (txVersion === 1 && allowTxnVersion1) {
       psbtv2.dangerouslySetGlobalTxVersion1();
@@ -1276,7 +1177,7 @@ export class PsbtV2 extends PsbtV2Maps {
         .readInt32LE(0);
     }
 
-    // Is this also a Creator role step? Unknown.
+    // Constructor Role
     for (const globalXpub of psbtv0GlobalMap.globalXpub ?? []) {
       psbtv2.addGlobalXpub(
         globalXpub.extendedPubkey,
@@ -1285,8 +1186,7 @@ export class PsbtV2 extends PsbtV2Maps {
       );
     }
 
-    // Constructor Role
-    let txInputs: any = [];
+    const txInputs: any = [];
     for (const [index, txInput] of psbtv0.txInputs.entries()) {
       txInputs[index] = txInput;
     }
@@ -1308,7 +1208,7 @@ export class PsbtV2 extends PsbtV2Maps {
       });
     }
 
-    let txOutputs: any = [];
+    const txOutputs: any = [];
     for (const [index, txOutput] of psbtv0.txOutputs.entries()) {
       txOutputs[index] = txOutput;
     }
@@ -1324,6 +1224,8 @@ export class PsbtV2 extends PsbtV2Maps {
       });
     }
 
+    // Signer Role
+
     // Finally, add partialSigs to inputs. This has to be performed last since
     // it may change PSBT_GLOBAL_TX_MODIFIABLE preventing inputs or outputs from
     // being added.
@@ -1336,17 +1238,3 @@ export class PsbtV2 extends PsbtV2Maps {
     return psbtv2;
   }
 }
-
-/**
- * Attempts to extract the version number as uint32LE from raw psbt regardless
- * of psbt validity.
- * @param {string | Buffer} psbt - hex, base64 or buffer of psbt
- * @returns {number} version number
- */
-export function getPsbtVersionNumber(psbt: string | Buffer): number {
-  const map = new Map<Key, Value>();
-  const buf = bufferize(psbt);
-  const br = new BufferReader(buf.slice(PSBT_MAGIC_BYTES.length));
-  readAndSetKeyPairs(map, br);
-  return map.get(KeyType.PSBT_GLOBAL_VERSION)?.readUInt32LE(0) || 0;
-}