@btc-vision/bitcoin 7.0.0-alpha.2 → 7.0.0-alpha.4

package/src/psbt.ts

@@ -10,7 +10,6 @@ import type {
 import { checkForInput, checkForOutput, Psbt as PsbtBase } from 'bip174';
 import { clone, equals, fromBase64, fromHex, toHex } from './io/index.js';
 
-import type { BIP32Interface } from '@btc-vision/bip32';
 import { fromOutputScript, toOutputScript } from './address.js';
 import { bitcoin as btcNetwork } from './networks.js';
 import * as payments from './payments/index.js';
@@ -41,7 +40,6 @@ import type {
     PsbtTxInput,
     PsbtTxOutput,
     Signer,
-    SignerAlternative,
     SignerAsync,
     TaprootHashCheckSigner,
     ValidateSigFunction,
@@ -67,7 +65,6 @@ import {
 } from './psbt/validation.js';
 import { checkInvalidP2WSH, classifyScript, getMeaningfulScript, range } from './psbt/utils.js';
 import { witnessStackToScriptWitness } from './psbt/psbtutils.js';
-import type { UniversalSigner } from '@btc-vision/ecpair';
 
 // Re-export types from the types module
 export type {
@@ -84,7 +81,6 @@ export type {
     PsbtOutputExtendedScript,
     HDSigner,
     HDSignerAsync,
-    SignerAlternative,
     Signer,
     SignerAsync,
     TaprootHashCheckSigner,
@@ -649,7 +645,7 @@ export class Psbt {
     }
 
     public signAllInputs(
-        keyPair: Signer | SignerAlternative | BIP32Interface | UniversalSigner,
+        keyPair: Signer | HDSigner,
         sighashTypes?: number[],
     ): this {
         if (!keyPair || !keyPair.publicKey) throw new Error('Need Signer to sign input');
@@ -670,7 +666,7 @@ export class Psbt {
     }
 
     public async signAllInputsAsync(
-        keyPair: Signer | SignerAlternative | SignerAsync | BIP32Interface | UniversalSigner,
+        keyPair: Signer | SignerAsync | HDSigner | HDSignerAsync,
         sighashTypes?: number[],
     ): Promise<void> {
         if (!keyPair || !keyPair.publicKey) throw new Error('Need Signer to sign input');
@@ -697,7 +693,7 @@ export class Psbt {
 
     public signInput(
         inputIndex: number,
-        keyPair: Signer | SignerAlternative | HDSigner | BIP32Interface | UniversalSigner,
+        keyPair: Signer | HDSigner,
         sighashTypes?: number[],
     ): this {
         if (!keyPair || !keyPair.publicKey) {
@@ -714,7 +710,7 @@ export class Psbt {
 
     public signTaprootInput(
         inputIndex: number,
-        keyPair: Signer | SignerAlternative | HDSigner | BIP32Interface | UniversalSigner,
+        keyPair: Signer | HDSigner,
         tapLeafHashToSign?: Uint8Array,
         sighashTypes?: number[],
     ): this {
@@ -736,63 +732,45 @@ export class Psbt {
         throw new Error(`Input #${inputIndex} is not of type Taproot.`);
     }
 
-    public signInputAsync(
+    public async signInputAsync(
         inputIndex: number,
-        keyPair:
-            | Signer
-            | SignerAlternative
-            | SignerAsync
-            | HDSigner
-            | HDSignerAsync
-            | BIP32Interface
-            | UniversalSigner,
+        keyPair: Signer | SignerAsync | HDSigner | HDSignerAsync,
         sighashTypes?: number[],
     ): Promise<void> {
-        return Promise.resolve().then(() => {
-            if (!keyPair || !keyPair.publicKey) throw new Error('Need Signer to sign input');
-
-            const input = checkForInput(this.data.inputs, inputIndex);
-            if (isTaprootInput(input))
-                return this.#signTaprootInputAsync(
-                    inputIndex,
-                    input,
-                    keyPair,
-                    undefined,
-                    sighashTypes,
-                );
-
-            return this.#signInputAsync(inputIndex, keyPair, sighashTypes);
-        });
+        if (!keyPair || !keyPair.publicKey) throw new Error('Need Signer to sign input');
+
+        const input = checkForInput(this.data.inputs, inputIndex);
+        if (isTaprootInput(input))
+            return this.#signTaprootInputAsync(
+                inputIndex,
+                input,
+                keyPair,
+                undefined,
+                sighashTypes,
+            );
+
+        return this.#signInputAsync(inputIndex, keyPair, sighashTypes);
     }
 
-    public signTaprootInputAsync(
+    public async signTaprootInputAsync(
         inputIndex: number,
-        keyPair:
-            | Signer
-            | SignerAlternative
-            | SignerAsync
-            | HDSigner
-            | HDSignerAsync
-            | BIP32Interface
-            | UniversalSigner,
+        keyPair: Signer | SignerAsync | HDSigner | HDSignerAsync,
         tapLeafHash?: Uint8Array,
         sighashTypes?: number[],
     ): Promise<void> {
-        return Promise.resolve().then(() => {
-            if (!keyPair || !keyPair.publicKey) throw new Error('Need Signer to sign input');
-
-            const input = checkForInput(this.data.inputs, inputIndex);
-            if (isTaprootInput(input))
-                return this.#signTaprootInputAsync(
-                    inputIndex,
-                    input,
-                    keyPair,
-                    tapLeafHash,
-                    sighashTypes,
-                );
-
-            throw new Error(`Input #${inputIndex} is not of type Taproot.`);
-        });
+        if (!keyPair || !keyPair.publicKey) throw new Error('Need Signer to sign input');
+
+        const input = checkForInput(this.data.inputs, inputIndex);
+        if (isTaprootInput(input))
+            return this.#signTaprootInputAsync(
+                inputIndex,
+                input,
+                keyPair,
+                tapLeafHash,
+                sighashTypes,
+            );
+
+        throw new Error(`Input #${inputIndex} is not of type Taproot.`);
     }
 
     public toBuffer(): Uint8Array {
@@ -872,15 +850,7 @@ export class Psbt {
     public checkTaprootHashesForSig(
         inputIndex: number,
         input: PsbtInput,
-        keyPair:
-            | Signer
-            | SignerAlternative
-            | SignerAsync
-            | HDSigner
-            | HDSignerAsync
-            | TaprootHashCheckSigner
-            | BIP32Interface
-            | UniversalSigner,
+        keyPair: Signer | SignerAsync | HDSigner | HDSignerAsync | TaprootHashCheckSigner,
         tapLeafHashToSign?: Uint8Array,
         allowedSighashTypes?: number[],
     ): { hash: MessageHash; leafHash?: Bytes32 }[] {
@@ -1064,7 +1034,7 @@ export class Psbt {
 
     #signInput(
         inputIndex: number,
-        keyPair: Signer | SignerAlternative | HDSigner | BIP32Interface | UniversalSigner,
+        keyPair: Signer | HDSigner,
         sighashTypes: number[] = [Transaction.SIGHASH_ALL],
     ): this {
         const pubkey =
@@ -1098,7 +1068,7 @@ export class Psbt {
     #signTaprootInput(
         inputIndex: number,
         input: PsbtInput,
-        keyPair: Signer | SignerAlternative | HDSigner | BIP32Interface | UniversalSigner,
+        keyPair: Signer | HDSigner,
         tapLeafHashToSign?: Uint8Array,
         allowedSighashTypes: number[] = [Transaction.SIGHASH_DEFAULT],
     ): this {
@@ -1153,16 +1123,9 @@ export class Psbt {
         return this;
     }
 
-    #signInputAsync(
+    async #signInputAsync(
         inputIndex: number,
-        keyPair:
-            | Signer
-            | SignerAlternative
-            | SignerAsync
-            | HDSigner
-            | HDSignerAsync
-            | BIP32Interface
-            | UniversalSigner,
+        keyPair: Signer | SignerAsync | HDSigner | HDSignerAsync,
         sighashTypes: number[] = [Transaction.SIGHASH_ALL],
     ): Promise<void> {
         const pubkey =
@@ -1177,31 +1140,23 @@ export class Psbt {
             sighashTypes,
         );
 
-        return Promise.resolve(keyPair.sign(hash)).then((signature) => {
-            const sig = signature instanceof Uint8Array ? signature : new Uint8Array(signature);
-            const partialSig = [
-                {
-                    pubkey,
-                    signature: bscript.signature.encode(sig, sighashType),
-                },
-            ];
+        const signature = await keyPair.sign(hash);
+        const sig = signature instanceof Uint8Array ? signature : new Uint8Array(signature);
+        const partialSig = [
+            {
+                pubkey,
+                signature: bscript.signature.encode(sig, sighashType),
+            },
+        ];
 
-            this.data.updateInput(inputIndex, { partialSig });
-            this.#cache.hasSignatures = true;
-        });
+        this.data.updateInput(inputIndex, { partialSig });
+        this.#cache.hasSignatures = true;
     }
 
     async #signTaprootInputAsync(
         inputIndex: number,
         input: PsbtInput,
-        keyPair:
-            | Signer
-            | SignerAlternative
-            | SignerAsync
-            | HDSigner
-            | HDSignerAsync
-            | BIP32Interface
-            | UniversalSigner,
+        keyPair: Signer | SignerAsync | HDSigner | HDSignerAsync,
         tapLeafHash?: Uint8Array,
         sighashTypes: number[] = [Transaction.SIGHASH_DEFAULT],
     ): Promise<void> {
@@ -1225,42 +1180,29 @@ export class Psbt {
             keyPair.signSchnorr as (hash: MessageHash) => SchnorrSignature | Promise<SchnorrSignature>
         ).bind(keyPair);
 
-        type TapSignatureResult = { tapKeySig: Uint8Array } | { tapScriptSig: TapScriptSig[] };
-        const signaturePromises: Promise<TapSignatureResult>[] = [];
-
-        const tapKeyHash = hashesForSig.filter((h) => !h.leafHash)[0];
+        const tapKeyHash = hashesForSig.find((h) => !h.leafHash);
         if (tapKeyHash) {
-            const tapKeySigPromise = Promise.resolve(signSchnorr(tapKeyHash.hash)).then((sig) => {
-                return {
-                    tapKeySig: serializeTaprootSignature(sig, input.sighashType),
-                };
-            });
-            signaturePromises.push(tapKeySigPromise);
+            const sig = await signSchnorr(tapKeyHash.hash);
+            const tapKeySig = serializeTaprootSignature(sig, input.sighashType);
+            this.data.updateInput(inputIndex, { tapKeySig });
+            this.#cache.hasSignatures = true;
         }
 
         const tapScriptHashes = hashesForSig.filter(
             (h): h is typeof h & { leafHash: Bytes32 } => !!h.leafHash,
         );
         if (tapScriptHashes.length) {
-            const tapScriptSigPromises = tapScriptHashes.map(async (tsh) => {
-                const signature = await signSchnorr(tsh.hash);
-
-                const tapScriptSig: TapScriptSig[] = [
-                    {
+            const tapScriptSigs = await Promise.all(
+                tapScriptHashes.map(async (tsh) => {
+                    const signature = await signSchnorr(tsh.hash);
+                    return {
                         pubkey: toXOnly(pubkey),
                         signature: serializeTaprootSignature(signature, input.sighashType),
                         leafHash: tsh.leafHash,
-                    },
-                ];
-
-                return { tapScriptSig };
-            });
-            signaturePromises.push(...tapScriptSigPromises);
-        }
-
-        const results = await Promise.all(signaturePromises);
-        for (const v of results) {
-            this.data.updateInput(inputIndex, v as PsbtInputUpdate);
+                    } as TapScriptSig;
+                }),
+            );
+            this.data.updateInput(inputIndex, { tapScriptSig: tapScriptSigs });
             this.#cache.hasSignatures = true;
         }
     }

package/src/types.ts

@@ -17,10 +17,6 @@ import type {
     XOnlyPublicKey,
 } from './branded.js';
 
-// ============================================================================
-// Branded Types (re-exported from branded.ts to avoid circular dependencies)
-// ============================================================================
-
 export type {
     Bytes32,
     Bytes20,
@@ -34,22 +30,15 @@ export type {
     Script,
 } from './branded.js';
 
-// ============================================================================
-// Constants
-// ============================================================================
-
 /** @internal Do not mutate */
 const EC_P = fromHex('fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f');
+
 /** @internal Do not mutate — secp256k1 curve order */
 const EC_N = fromHex('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141');
 
 export const SATOSHI_MAX = 21n * 10n ** 14n;
 export const TAPLEAF_VERSION_MASK = 0xfe;
 
-// ============================================================================
-// Type Guards
-// ============================================================================
-
 export function isUInt8(value: unknown): value is number {
     return typeof value === 'number' && Number.isInteger(value) && value >= 0 && value <= 0xff;
 }
@@ -96,8 +85,7 @@ export function isBytes20(value: unknown): value is Bytes20 {
 export function isXOnlyPublicKey(value: unknown): value is XOnlyPublicKey {
     if (!(value instanceof Uint8Array) || value.length !== 32) return false;
     if (isZero(value)) return false;
-    if (compare(value, EC_P) >= 0) return false;
-    return true;
+    return compare(value, EC_P) < 0;
 }
 
 export function isPoint(value: unknown): value is PublicKey {
@@ -130,8 +118,7 @@ export function isSatoshi(value: unknown): value is Satoshi {
 export function isPrivateKey(value: unknown): value is PrivateKey {
     if (!(value instanceof Uint8Array) || value.length !== 32) return false;
     if (isZero(value)) return false;
-    if (compare(value, EC_N) >= 0) return false;
-    return true;
+    return compare(value, EC_N) < 0;
 }
 
 export function isSchnorrSignature(value: unknown): value is SchnorrSignature {
@@ -146,9 +133,7 @@ export function isScript(value: unknown): value is Script {
     return value instanceof Uint8Array;
 }
 
-// ============================================================================
 // Taproot Types
-// ============================================================================
 
 export interface Tapleaf {
     readonly output: Uint8Array;
@@ -178,23 +163,17 @@ export function isTaptree(value: unknown): value is Taptree {
     return value.every((node: unknown) => isTaptree(node));
 }
 
-// ============================================================================
-// ECC Interface (re-exported from ecc/types.ts for backward compatibility)
-// ============================================================================
+// ECC Interface
 
-export type { XOnlyPointAddTweakResult, EccLib, Parity } from './ecc/types.js';
+export type { CryptoBackend, XOnlyPointAddTweakResult, EccLib, Parity } from './ecc/types.js';
 
-// ============================================================================
 // Stack Types
-// ============================================================================
 
 export type StackElement = Uint8Array | number;
 export type Stack = readonly StackElement[];
 export type StackFunction = () => Stack;
 
-// ============================================================================
 // Utility Functions
-// ============================================================================
 
 export function stacksEqual(a: Uint8Array[], b: Uint8Array[]): boolean {
     if (a.length !== b.length) return false;
@@ -236,9 +215,7 @@ export function toSatoshi(value: bigint): Satoshi {
     return value as Satoshi;
 }
 
-// ============================================================================
 // Assertion Helpers
-// ============================================================================
 
 export function assertXOnlyPublicKey(
     value: unknown,

package/src/workers/WorkerSigningPool.node.ts

@@ -353,6 +353,15 @@ export class NodeWorkerSigningPool {
         }
     }
 
+    /**
+     * Disposes of the pool by shutting down all workers.
+     *
+     * Enables `await using pool = ...` syntax for automatic cleanup.
+     */
+    public async [Symbol.asyncDispose](): Promise<void> {
+        await this.shutdown();
+    }
+
     /**
      * Shuts down the pool and terminates all workers.
      *
@@ -384,7 +393,7 @@ export class NodeWorkerSigningPool {
      */
     #createWorkerScript(): string {
         // Node.js worker_threads can directly require/import modules
-        const workerCode = `
+        return `
 const { parentPort } = require('worker_threads');
 
 /**
@@ -649,7 +658,6 @@ function handleSignBatch(msg) {
     });
 }
 `;
-        return workerCode;
     }
 
     /**

package/src/workers/WorkerSigningPool.sequential.ts

@@ -0,0 +1,190 @@
+/**
+ * Sequential signing pool for environments without worker support (React Native).
+ *
+ * Signs inputs one-by-one on the main thread using the CryptoBackend
+ * from EccContext. Same API shape as WorkerSigningPool so consumers
+ * can swap transparently.
+ *
+ * @packageDocumentation
+ */
+
+import type {
+    ParallelSignerKeyPair,
+    ParallelSigningResult,
+    SigningResultMessage,
+    SigningTask,
+    WorkerPoolConfig,
+} from './types.js';
+import { SignatureType } from './types.js';
+import { EccContext } from '../ecc/context.js';
+import type { MessageHash, PrivateKey } from '@btc-vision/ecpair';
+
+/**
+ * Sequential signing pool — signs inputs one-by-one on the main thread.
+ *
+ * Provides the same public API as WorkerSigningPool but without any
+ * threading. Intended for React Native or other environments where
+ * Web Workers and worker_threads are unavailable.
+ *
+ * @example
+ * ```typescript
+ * import { SequentialSigningPool } from '@btc-vision/bitcoin/workers';
+ *
+ * const pool = SequentialSigningPool.getInstance();
+ * const result = await pool.signBatch(tasks, keyPair);
+ * ```
+ */
+export class SequentialSigningPool {
+    static #instance: SequentialSigningPool | null = null;
+
+    private constructor(_config: WorkerPoolConfig = {}) {
+        // Config accepted for API compatibility but not used —
+        // sequential pool has no workers to configure.
+    }
+
+    /**
+     * Number of workers — always 0 for sequential pool.
+     */
+    public get workerCount(): number {
+        return 0;
+    }
+
+    /**
+     * Idle workers — always 0.
+     */
+    public get idleWorkerCount(): number {
+        return 0;
+    }
+
+    /**
+     * Busy workers — always 0.
+     */
+    public get busyWorkerCount(): number {
+        return 0;
+    }
+
+    /**
+     * Whether workers are preserved — always false (no workers to preserve).
+     */
+    public get isPreservingWorkers(): boolean {
+        return false;
+    }
+
+    /**
+     * Gets the singleton instance.
+     */
+    public static getInstance(config?: WorkerPoolConfig): SequentialSigningPool {
+        if (!SequentialSigningPool.#instance) {
+            SequentialSigningPool.#instance = new SequentialSigningPool(config);
+        }
+        return SequentialSigningPool.#instance;
+    }
+
+    /**
+     * Resets the singleton instance (for testing).
+     */
+    public static resetInstance(): void {
+        SequentialSigningPool.#instance = null;
+    }
+
+    /**
+     * No-op — no workers to preserve.
+     */
+    public preserveWorkers(): void {
+        // No-op: no workers to preserve
+    }
+
+    /**
+     * No-op — no workers to release.
+     */
+    public releaseWorkers(): void {
+        // No-op
+    }
+
+    /**
+     * No-op — no initialization required.
+     */
+    public async initialize(): Promise<void> {
+        // No-op: nothing to initialize
+    }
+
+    /**
+     * Signs tasks sequentially on the main thread.
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    public async signBatch(
+        tasks: readonly SigningTask[],
+        keyPair: ParallelSignerKeyPair,
+    ): Promise<ParallelSigningResult> {
+        const startTime = performance.now();
+
+        if (tasks.length === 0) {
+            return {
+                success: true,
+                signatures: new Map(),
+                errors: new Map(),
+                durationMs: performance.now() - startTime,
+            };
+        }
+
+        const ecc = EccContext.get().lib;
+        const privateKey = keyPair.getPrivateKey();
+
+        const signatures = new Map<number, SigningResultMessage>();
+        const errors = new Map<number, string>();
+
+        try {
+            for (const task of tasks) {
+                try {
+                    let signature: Uint8Array;
+
+                    const hash = task.hash as MessageHash;
+                    const key = privateKey as PrivateKey;
+
+                    if (task.signatureType === SignatureType.Schnorr) {
+                        signature = ecc.signSchnorr!(hash, key);
+                    } else {
+                        signature = ecc.sign(hash, key);
+                    }
+
+                    signatures.set(task.inputIndex, {
+                        type: 'result',
+                        taskId: task.taskId,
+                        signature,
+                        inputIndex: task.inputIndex,
+                        publicKey: keyPair.publicKey,
+                        signatureType: task.signatureType,
+                        leafHash: task.leafHash,
+                    });
+                } catch (err: unknown) {
+                    const message = err instanceof Error ? err.message : 'Signing failed';
+                    errors.set(task.inputIndex, message);
+                }
+            }
+        } finally {
+            // SECURITY: Zero the private key
+            privateKey.fill(0);
+        }
+
+        return {
+            success: errors.size === 0,
+            signatures,
+            errors,
+            durationMs: performance.now() - startTime,
+        };
+    }
+
+    /**
+     * No-op — no workers to shut down.
+     */
+    public async shutdown(): Promise<void> {
+        // No-op: nothing to shut down
+    }
+
+    /**
+     * Enables `await using pool = ...` syntax.
+     */
+    public async [Symbol.asyncDispose](): Promise<void> {
+        await this.shutdown();
+    }
+}

package/src/workers/WorkerSigningPool.ts

@@ -389,6 +389,15 @@ export class WorkerSigningPool {
         }
     }
 
+    /**
+     * Disposes of the pool by shutting down all workers.
+     *
+     * Enables `await using pool = ...` syntax for automatic cleanup.
+     */
+    public async [Symbol.asyncDispose](): Promise<void> {
+        await this.shutdown();
+    }
+
     /**
      * Shuts down the pool and terminates all workers.
      *