ecash-lib 4.10.0 → 4.12.0

package/src/script.ts

@@ -216,6 +216,29 @@ export class Script {
         return Script.fromOps(ops);
     }
 
+    /**
+     * Return true iff this script has the shape of a standard multisig output script
+     * `OP_m pubkey_1 ... pubkey_N OP_N OP_CHECKMULTISIG` (fixed size: `N + 3` ops).
+     */
+    public isMultisig(): boolean {
+        const ops: Op[] = [];
+        const iter = this.ops();
+        let op: Op | undefined;
+        while ((op = iter.next()) !== undefined) {
+            ops.push(op);
+        }
+        if (ops.length < 4 || ops[ops.length - 1] !== OP_CHECKMULTISIG) {
+            return false;
+        }
+        try {
+            parseNumberFromOp(ops[0]!);
+            const numPubkeys = Number(parseNumberFromOp(ops[ops.length - 2]!));
+            return ops.length === numPubkeys + 3;
+        } catch {
+            return false;
+        }
+    }
+
     /**
      * Build scriptSig for multisig: <dummy> sig1 sig2 ... sig_m [redeemScript].
      * Omit redeemScript for bare multisig; include for P2SH-wrapped.
@@ -346,7 +369,8 @@ export class Script {
         return Script.parseMultisigScriptSig(ops, outputScript);
     }
 
-    private parseMultisigRedeemScript(): {
+    /** Parse an OP_m ... OP_CHECKMULTISIG redeem script (used by multisig PSBT flows). */
+    public parseMultisigRedeemScript(): {
         numSignatures: number;
         numPubkeys: number;
         pubkeys: Uint8Array[];

package/src/signatories.ts

@@ -0,0 +1,296 @@
+// Copyright (c) 2024-2026 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+/**
+ * Signatories and signing helpers used with `TxBuilder` (`TxBuilderInput.signatory`).
+ */
+
+import { Ecc, EccDummy } from './ecc.js';
+import {
+    ECDSA_SIG_ESTIMATE_BYTES,
+    SCHNORR_SIG_ESTIMATE_BYTES,
+} from './consts.js';
+import { sha256d } from './hash.js';
+import { WriterBytes } from './io/writerbytes.js';
+import { pushBytesOp } from './op.js';
+import { Script } from './script.js';
+import { SigHashType, SigHashTypeVariant } from './sigHashType.js';
+import { UnsignedTxInput } from './unsignedTx.js';
+
+/**
+ * Function that contains all the required data to sign a given `input` and
+ * return the scriptSig.
+ *
+ * Use it by attaching a `Signatory` to a TxBuilderInput, e.g. like this for a
+ * P2PKH input:
+ * ```ts
+ * new TxBuilder({
+ *     inputs: [{
+ *         input: { prevOut: ... },
+ *         signatory: P2PKHSignatory(sk, pk, ALL_BIP143),
+ *     }],
+ *     ...
+ * })
+ * ```
+ **/
+export type Signatory = (ecc: Ecc, input: UnsignedTxInput) => Script;
+
+/** Append the sighash flags to the signature */
+export function flagSignature(
+    sig: Uint8Array,
+    sigHashFlags: SigHashType,
+): Uint8Array {
+    const writer = new WriterBytes(sig.length + 1);
+    writer.putBytes(sig);
+    writer.putU8(sigHashFlags.toInt() & 0xff);
+    return writer.data;
+}
+
+/**
+ * Sign the sighash using Schnorr for BIP143 signatures and ECDSA for Legacy
+ * signatures, and then flags the signature correctly
+ **/
+export function signWithSigHash(
+    ecc: Ecc,
+    sk: Uint8Array,
+    sigHash: Uint8Array,
+    sigHashType: SigHashType,
+): Uint8Array {
+    const sig =
+        sigHashType.variant == SigHashTypeVariant.LEGACY
+            ? ecc.ecdsaSign(sk, sigHash)
+            : ecc.schnorrSign(sk, sigHash);
+    return flagSignature(sig, sigHashType);
+}
+
+/** Signatory for a P2PKH input. Always uses Schnorr signatures */
+export const P2PKHSignatory = (
+    sk: Uint8Array,
+    pk: Uint8Array,
+    sigHashType: SigHashType,
+): Signatory => {
+    return (ecc: Ecc, input: UnsignedTxInput): Script => {
+        const preimage = input.sigHashPreimage(sigHashType);
+        const sighash = sha256d(preimage.bytes);
+        const sigFlagged = signWithSigHash(ecc, sk, sighash, sigHashType);
+        return Script.p2pkhSpend(pk, sigFlagged);
+    };
+};
+
+/** Signatory for bare m-of-n multisig (output script is the multisig script itself). */
+export const BareMultisigSignatory = (
+    m: number,
+    pubkeys: Uint8Array[],
+    sk: Uint8Array,
+    myPk: Uint8Array,
+    sigHashType: SigHashType,
+): Signatory => {
+    return (ecc: Ecc, input: UnsignedTxInput): Script => {
+        if (ecc instanceof EccDummy) {
+            const dummySig = new Uint8Array(ECDSA_SIG_ESTIMATE_BYTES);
+            const signatures = Array(m)
+                .fill(undefined)
+                .map(() => dummySig);
+            return Script.multisigSpend({ signatures });
+        }
+        const preimage = input.sigHashPreimage(sigHashType);
+        const sighash = sha256d(preimage.bytes);
+        const sig = ecc.ecdsaSign(sk, sighash);
+        const sigFlagged = flagSignature(sig, sigHashType);
+        const myIndex = pubkeys.findIndex(
+            pk =>
+                pk.length === myPk.length && pk.every((b, i) => b === myPk[i]),
+        );
+        if (myIndex < 0) {
+            throw new Error('Signer pubkey not found in multisig pubkeys');
+        }
+        const n = pubkeys.length;
+        const signatures: (Uint8Array | undefined)[] = Array(n).fill(undefined);
+        signatures[myIndex] = sigFlagged;
+        const nonNull = signatures.filter(
+            (s): s is Uint8Array => s !== undefined,
+        );
+        const sigsForScript: (Uint8Array | undefined)[] = [
+            ...nonNull,
+            ...Array(m - nonNull.length).fill(undefined),
+        ];
+        return Script.multisigSpend({ signatures: sigsForScript });
+    };
+};
+
+/** Signatory for bare m-of-n multisig using Schnorr signatures (BIP143 Schnorr multisig). */
+export const BareMultisigSignatorySchnorr = (
+    m: number,
+    pubkeys: Uint8Array[],
+    sk: Uint8Array,
+    myPk: Uint8Array,
+    signerIndices: Set<number>,
+    sigHashType: SigHashType,
+): Signatory => {
+    return (ecc: Ecc, input: UnsignedTxInput): Script => {
+        const n = pubkeys.length;
+        if (signerIndices.size !== m) {
+            throw new Error(
+                `signerIndices must have ${m} elements for ${m}-of-${n} multisig`,
+            );
+        }
+        if (ecc instanceof EccDummy) {
+            const dummySig = new Uint8Array(SCHNORR_SIG_ESTIMATE_BYTES);
+            const signatures = Array(m)
+                .fill(undefined)
+                .map(() => dummySig);
+            return Script.multisigSpend({
+                signatures,
+                pubkeyIndices: signerIndices,
+                numPubkeys: n,
+            });
+        }
+        const preimage = input.sigHashPreimage(sigHashType);
+        const sighash = sha256d(preimage.bytes);
+        const sig = ecc.schnorrSign(sk, sighash);
+        const sigFlagged = flagSignature(sig, sigHashType);
+        const myIndex = pubkeys.findIndex(
+            pk =>
+                pk.length === myPk.length && pk.every((b, i) => b === myPk[i]),
+        );
+        if (myIndex < 0) {
+            throw new Error('Signer pubkey not found in multisig pubkeys');
+        }
+        if (!signerIndices.has(myIndex)) {
+            throw new Error(
+                `Signer index ${myIndex} not in signerIndices ${[
+                    ...signerIndices,
+                ].join(',')}`,
+            );
+        }
+        const sortedIndices = [...signerIndices].sort((a, b) => a - b);
+        const signatures: (Uint8Array | undefined)[] = sortedIndices.map(idx =>
+            idx === myIndex ? sigFlagged : undefined,
+        );
+        return Script.multisigSpend({
+            signatures,
+            pubkeyIndices: signerIndices,
+            numPubkeys: n,
+        });
+    };
+};
+
+/** Signatory for P2SH m-of-n multisig. */
+export const P2SHMultisigSignatory = (
+    m: number,
+    pubkeys: Uint8Array[],
+    sk: Uint8Array,
+    myPk: Uint8Array,
+    sigHashType: SigHashType,
+): Signatory => {
+    return (ecc: Ecc, input: UnsignedTxInput): Script => {
+        const redeemScript = Script.multisig(m, pubkeys);
+        if (ecc instanceof EccDummy) {
+            const dummySig = new Uint8Array(ECDSA_SIG_ESTIMATE_BYTES);
+            const signatures = Array(m)
+                .fill(undefined)
+                .map(() => dummySig);
+            return Script.multisigSpend({
+                signatures,
+                redeemScript,
+            });
+        }
+        const preimage = input.sigHashPreimage(sigHashType);
+        const sighash = sha256d(preimage.bytes);
+        const sig = ecc.ecdsaSign(sk, sighash);
+        const sigFlagged = flagSignature(sig, sigHashType);
+        const myIndex = pubkeys.findIndex(
+            pk =>
+                pk.length === myPk.length && pk.every((b, i) => b === myPk[i]),
+        );
+        if (myIndex < 0) {
+            throw new Error('Signer pubkey not found in multisig pubkeys');
+        }
+        const n = pubkeys.length;
+        const signatures: (Uint8Array | undefined)[] = Array(n).fill(undefined);
+        signatures[myIndex] = sigFlagged;
+        const nonNull = signatures.filter(
+            (s): s is Uint8Array => s !== undefined,
+        );
+        const sigsForScript: (Uint8Array | undefined)[] = [
+            ...nonNull,
+            ...Array(m - nonNull.length).fill(undefined),
+        ];
+        return Script.multisigSpend({
+            signatures: sigsForScript,
+            redeemScript,
+        });
+    };
+};
+
+/** Signatory for P2SH m-of-n multisig using Schnorr signatures. */
+export const P2SHMultisigSignatorySchnorr = (
+    m: number,
+    pubkeys: Uint8Array[],
+    sk: Uint8Array,
+    myPk: Uint8Array,
+    signerIndices: Set<number>,
+    sigHashType: SigHashType,
+): Signatory => {
+    return (ecc: Ecc, input: UnsignedTxInput): Script => {
+        const redeemScript = Script.multisig(m, pubkeys);
+        const n = pubkeys.length;
+        if (signerIndices.size !== m) {
+            throw new Error(
+                `signerIndices must have ${m} elements for ${m}-of-${n} multisig`,
+            );
+        }
+        if (ecc instanceof EccDummy) {
+            const dummySig = new Uint8Array(SCHNORR_SIG_ESTIMATE_BYTES);
+            const signatures = Array(m)
+                .fill(undefined)
+                .map(() => dummySig);
+            return Script.multisigSpend({
+                signatures,
+                redeemScript,
+                pubkeyIndices: signerIndices,
+            });
+        }
+        const preimage = input.sigHashPreimage(sigHashType);
+        const sighash = sha256d(preimage.bytes);
+        const sig = ecc.schnorrSign(sk, sighash);
+        const sigFlagged = flagSignature(sig, sigHashType);
+        const myIndex = pubkeys.findIndex(
+            pk =>
+                pk.length === myPk.length && pk.every((b, i) => b === myPk[i]),
+        );
+        if (myIndex < 0) {
+            throw new Error('Signer pubkey not found in multisig pubkeys');
+        }
+        if (!signerIndices.has(myIndex)) {
+            throw new Error(
+                `Signer index ${myIndex} not in signerIndices ${[
+                    ...signerIndices,
+                ].join(',')}`,
+            );
+        }
+        const sortedIndices = [...signerIndices].sort((a, b) => a - b);
+        const signatures: (Uint8Array | undefined)[] = sortedIndices.map(idx =>
+            idx === myIndex ? sigFlagged : undefined,
+        );
+        return Script.multisigSpend({
+            signatures,
+            redeemScript,
+            pubkeyIndices: signerIndices,
+        });
+    };
+};
+
+/** Signatory for a P2PK input. Always uses Schnorr signatures */
+export const P2PKSignatory = (
+    sk: Uint8Array,
+    sigHashType: SigHashType,
+): Signatory => {
+    return (ecc: Ecc, input: UnsignedTxInput): Script => {
+        const preimage = input.sigHashPreimage(sigHashType);
+        const sighash = sha256d(preimage.bytes);
+        const sigFlagged = signWithSigHash(ecc, sk, sighash, sigHashType);
+        return Script.fromOps([pushBytesOp(sigFlagged)]);
+    };
+};

package/src/tx.ts

@@ -8,8 +8,12 @@ import { writeVarSize, readVarSize } from './io/varsize.js';
 import { Writer } from './io/writer.js';
 import { WriterBytes } from './io/writerbytes.js';
 import { WriterLength } from './io/writerlength.js';
+import { Ecc } from './ecc.js';
 import { Script } from './script.js';
 import { sha256d } from './hash.js';
+import { flagSignature } from './signatories.js';
+import { ALL_BIP143, SigHashType } from './sigHashType.js';
+import { UnsignedTx } from './unsignedTx.js';
 
 /**
  * Default value for nSequence of inputs if left undefined; this opts out of
@@ -175,6 +179,332 @@ export class Tx {
     public txid(): string {
         return toHexRev(sha256d(this.ser()));
     }
+
+    /**
+     * Attempt to parse a **non-SegWit** serialized transaction from `data` — the same
+     * encoding as {@link Tx.deser} / `Tx.ser()` (version, inputs, outputs, locktime;
+     * no witness marker or witness stacks). eCash does not use SegWit transactions,
+     * so this is the full-transaction wire format on-chain here. Returns a `Tx` only
+     * when `data` is **exactly** one such transaction: the parse must consume the
+     * **entire** buffer (no trailing bytes). Returns `undefined` on malformed input
+     * or if any bytes remain after `locktime`.
+     *
+     * **PSBT-only motivation:** Bitcoin ABC’s PSBT input key `0x00` (`PSBT_IN_UTXO`)
+     * stores **either** a full previous transaction (BIP 174 “non-witness UTXO”) **or**
+     * a compact `CTxOut` (amount + `scriptPubKey`). Callers must disambiguate. Plain
+     * {@link Tx.deser} reads a tx from the start of `data` but **does not** require
+     * `data.length` to match the serialized length — leftover bytes are ignored, so
+     * you cannot use it to prove “this blob is solely a full tx.” This helper is
+     * used from PSBT (`resolveWitnessFromKey00` in `psbt.ts`): if `tryDeserExact`
+     * succeeds (and the txid matches), treat as non-witness UTXO; otherwise decode as
+     * `CTxOut`-shaped bytes.
+     */
+    public static tryDeserExact(data: Uint8Array): Tx | undefined {
+        try {
+            const bytes = new Bytes(data);
+            const version = bytes.readU32();
+            const numInputs = readVarSize(bytes);
+            const inputs: TxInput[] = [];
+            for (let i = 0; i < numInputs; ++i) {
+                const txid = bytes.readBytes(32);
+                const outIdx = bytes.readU32();
+                const script = Script.readWithSize(bytes);
+                const sequence = bytes.readU32();
+                inputs.push({
+                    prevOut: { txid, outIdx },
+                    script,
+                    sequence,
+                });
+            }
+            const numOutputs = readVarSize(bytes);
+            const outputs: TxOutput[] = [];
+            for (let i = 0; i < numOutputs; ++i) {
+                outputs.push(readTxOutput(bytes));
+            }
+            const locktime = bytes.readU32();
+            if (bytes.idx !== data.length) {
+                return undefined;
+            }
+            return new Tx({ version, inputs, outputs, locktime });
+        } catch {
+            return undefined;
+        }
+    }
+
+    /**
+     * Add a signature to a partially-signed multisig input.
+     * Verifies the signature against the sighash for each pubkey in the
+     * redeem/output script and merges with existing signatures (which pubkey
+     * signed is inferred from verification).
+     */
+    public addMultisigSignature(params: {
+        inputIdx: number;
+        signature: Uint8Array;
+        signData: SignData;
+        ecc?: Ecc;
+    }): Tx {
+        const { inputIdx, signature, signData } = params;
+        const ecc = params.ecc ?? new Ecc();
+        const input = this.inputs[inputIdx];
+        if (!input.script || input.script.bytecode.length === 0) {
+            throw new Error(
+                `Input ${inputIdx} has no scriptSig to add signature to`,
+            );
+        }
+        const isBare =
+            signData.outputScript !== undefined &&
+            signData.redeemScript === undefined;
+        const parsed = isBare
+            ? input.script.parseBareMultisigSpend(signData.outputScript!)
+            : input.script.parseP2shMultisigSpend();
+        const txWithSignData = new Tx({
+            version: this.version,
+            inputs: this.inputs.map((inp, i) =>
+                i === inputIdx
+                    ? { ...copyTxInput(inp), signData }
+                    : copyTxInput(inp),
+            ),
+            outputs: this.outputs,
+            locktime: this.locktime,
+        });
+        const unsignedTx = UnsignedTx.fromTx(txWithSignData);
+        const inputAt = unsignedTx.inputAt(inputIdx);
+        const sigHashType =
+            SigHashType.fromInt(
+                (signature[signature.length - 1] ?? 0) & 0xff,
+            ) ?? ALL_BIP143;
+        const preimage = inputAt.sigHashPreimage(sigHashType);
+        const sighash = sha256d(preimage.bytes);
+        const sigWithoutFlag = signature.slice(0, -1);
+
+        let pubkeyIndex = -1;
+        if (parsed.isSchnorr) {
+            for (let i = 0; i < parsed.pubkeys.length; i++) {
+                try {
+                    ecc.schnorrVerify(
+                        sigWithoutFlag,
+                        sighash,
+                        parsed.pubkeys[i]!,
+                    );
+                    pubkeyIndex = i;
+                    break;
+                } catch {
+                    /* try next pubkey */
+                }
+            }
+            if (pubkeyIndex < 0) {
+                throw new Error(
+                    'Schnorr signature does not verify for any pubkey in the multisig script',
+                );
+            }
+        } else {
+            for (let i = 0; i < parsed.pubkeys.length; i++) {
+                try {
+                    ecc.ecdsaVerify(
+                        sigWithoutFlag,
+                        sighash,
+                        parsed.pubkeys[i]!,
+                    );
+                    pubkeyIndex = i;
+                    break;
+                } catch {
+                    /* try next pubkey */
+                }
+            }
+            if (pubkeyIndex < 0) {
+                throw new Error(
+                    'ECDSA signature does not verify for any pubkey in the multisig script',
+                );
+            }
+        }
+
+        const sigsByPubkey: (Uint8Array | undefined)[] = Array(
+            parsed.pubkeys.length,
+        ).fill(undefined);
+
+        if (parsed.isSchnorr) {
+            const indices = parsed.pubkeyIndices!;
+            const sortedIndices = [...indices].sort((a, b) => a - b);
+            for (let i = 0; i < parsed.signatures.length; i++) {
+                const sig = parsed.signatures[i];
+                if (sig !== undefined && i < sortedIndices.length) {
+                    sigsByPubkey[sortedIndices[i]!] = sig;
+                }
+            }
+        } else {
+            for (const sig of parsed.signatures) {
+                if (sig === undefined) continue;
+                const sigNoFlag = sig.slice(0, -1);
+                for (let i = 0; i < parsed.pubkeys.length; i++) {
+                    try {
+                        ecc.ecdsaVerify(sigNoFlag, sighash, parsed.pubkeys[i]!);
+                        sigsByPubkey[i] = sig;
+                        break;
+                    } catch {
+                        /* try next pubkey */
+                    }
+                }
+            }
+        }
+        sigsByPubkey[pubkeyIndex] = signature;
+
+        const nonNullSigs = sigsByPubkey.filter(
+            (s): s is Uint8Array => s !== undefined,
+        );
+        const sigsForScript =
+            nonNullSigs.length >= parsed.numSignatures
+                ? nonNullSigs.slice(0, parsed.numSignatures)
+                : [
+                      ...nonNullSigs,
+                      ...Array(parsed.numSignatures - nonNullSigs.length).fill(
+                          undefined,
+                      ),
+                  ];
+
+        const redeemScript: Script | undefined =
+            !isBare && 'redeemScript' in parsed
+                ? (parsed as { redeemScript: Script }).redeemScript
+                : undefined;
+        const newScriptSig = parsed.isSchnorr
+            ? (() => {
+                  const signerIndices = new Set<number>();
+                  for (
+                      let i = 0;
+                      i < parsed.pubkeys.length &&
+                      signerIndices.size < parsed.numSignatures;
+                      i++
+                  ) {
+                      if (sigsByPubkey[i] !== undefined) signerIndices.add(i);
+                  }
+                  return isBare
+                      ? Script.multisigSpend({
+                            signatures: sigsForScript,
+                            pubkeyIndices: signerIndices,
+                            numPubkeys: parsed.numPubkeys,
+                        })
+                      : Script.multisigSpend({
+                            signatures: sigsForScript,
+                            redeemScript,
+                            pubkeyIndices: signerIndices,
+                        });
+              })()
+            : Script.multisigSpend({
+                  signatures: sigsForScript,
+                  redeemScript,
+              });
+
+        const newInputs = this.inputs.map((inp, i) =>
+            i === inputIdx
+                ? { ...copyTxInput(inp), script: newScriptSig }
+                : copyTxInput(inp),
+        );
+        return new Tx({
+            version: this.version,
+            inputs: newInputs,
+            outputs: this.outputs,
+            locktime: this.locktime,
+        });
+    }
+
+    /**
+     * Like {@link addMultisigSignature}, but computes the signature from a
+     * secret key: BIP143 preimage (or legacy if `sigHashType` is legacy),
+     * Schnorr for Schnorr-format multisig spends and ECDSA otherwise.
+     */
+    public addMultisigSignatureFromKey(params: {
+        inputIdx: number;
+        sk: Uint8Array;
+        signData: SignData;
+        /** Defaults to {@link ALL_BIP143}. */
+        sigHashType?: SigHashType;
+        ecc?: Ecc;
+    }): Tx {
+        const sigHashType = params.sigHashType ?? ALL_BIP143;
+        const ecc = params.ecc ?? new Ecc();
+        const { inputIdx, sk, signData } = params;
+        const input = this.inputs[inputIdx];
+        if (!input.script || input.script.bytecode.length === 0) {
+            throw new Error(
+                `Input ${inputIdx} has no scriptSig to add signature to`,
+            );
+        }
+        const isBare =
+            signData.outputScript !== undefined &&
+            signData.redeemScript === undefined;
+        const parsed = isBare
+            ? input.script.parseBareMultisigSpend(signData.outputScript!)
+            : input.script.parseP2shMultisigSpend();
+        const txWithSignData = new Tx({
+            version: this.version,
+            inputs: this.inputs.map((inp, i) =>
+                i === inputIdx
+                    ? { ...copyTxInput(inp), signData }
+                    : copyTxInput(inp),
+            ),
+            outputs: this.outputs,
+            locktime: this.locktime,
+        });
+        const unsignedTx = UnsignedTx.fromTx(txWithSignData);
+        const preimage = unsignedTx
+            .inputAt(inputIdx)
+            .sigHashPreimage(sigHashType);
+        const sighash = sha256d(preimage.bytes);
+        const sig = parsed.isSchnorr
+            ? ecc.schnorrSign(sk, sighash)
+            : ecc.ecdsaSign(sk, sighash);
+        const signature = flagSignature(sig, sigHashType);
+        return this.addMultisigSignature({
+            inputIdx,
+            signature,
+            signData,
+            ecc,
+        });
+    }
+
+    /**
+     * Whether every **multisig** input (identified from `signData`) has enough
+     * signatures in its scriptSig. Non-multisig inputs are ignored.
+     *
+     * If the transaction has **no** multisig inputs, this returns `true` (there
+     * is nothing multisig-specific left to satisfy). That can look surprising on
+     * a non-multisig or otherwise incomplete tx; this helper is **not** a
+     * broadcast-readiness check. Call sites are expected to use it only in
+     * multisig / PSBT flows where the question is specifically whether multisig
+     * inputs still need more signatures (including mixed txs: non-multisig
+     * inputs are finalized elsewhere).
+     */
+    public isFullySignedMultisig(): boolean {
+        for (let i = 0; i < this.inputs.length; i++) {
+            const input = this.inputs[i];
+            const multisigScript =
+                input.signData?.redeemScript !== undefined
+                    ? input.signData.redeemScript
+                    : input.signData?.outputScript?.isMultisig()
+                      ? input.signData!.outputScript
+                      : undefined;
+            if (multisigScript === undefined) {
+                continue;
+            }
+            if (!input.script || input.script.bytecode.length === 0) {
+                return false;
+            }
+            try {
+                const parsed =
+                    input.signData?.redeemScript === undefined
+                        ? input.script.parseBareMultisigSpend(multisigScript)
+                        : input.script.parseP2shMultisigSpend();
+                const sigCount = parsed.signatures.filter(
+                    s => s !== undefined,
+                ).length;
+                if (sigCount < parsed.numSignatures) {
+                    return false;
+                }
+            } catch {
+                return false;
+            }
+        }
+        return true;
+    }
 }
 
 export function readTxOutput(bytes: Bytes): TxOutput {