@btc-vision/bitcoin 7.0.0-alpha.0 → 7.0.0-alpha.1

package/src/psbt.ts

@@ -1,8 +1,3 @@
-import {
-    Psbt as PsbtBase,
-    checkForInput,
-    checkForOutput,
-} from 'bip174';
 import type {
     Bip32Derivation,
     KeyValue,
@@ -17,16 +12,16 @@ import type {
     Transaction as ITransaction,
     TransactionFromBuffer,
 } from 'bip174';
-import { clone, reverse, equals, fromHex, toHex, fromBase64 } from './io/index.js';
+import { checkForInput, checkForOutput, Psbt as PsbtBase } from 'bip174';
+import { clone, equals, fromBase64, fromHex, reverse, toHex } from './io/index.js';
 
 import type { BIP32Interface } from '@btc-vision/bip32';
 import type { ECPairInterface } from 'ecpair';
 import { fromOutputScript, isUnknownSegwitVersion, toOutputScript } from './address.js';
 import { bitcoin as btcNetwork } from './networks.js';
+import type { P2SHPayment, P2WSHPayment } from './payments/index.js';
 import * as payments from './payments/index.js';
-import type { P2WSHPayment } from './payments/index.js';
 import { tapleafHash } from './payments/bip341.js';
-import type { P2SHPayment } from './payments/index.js';
 import {
     checkTaprootInputFields,
     checkTaprootOutputFields,
@@ -35,12 +30,7 @@ import {
     tapScriptFinalizer,
 } from './psbt/bip371.js';
 import { toXOnly } from './pubkey.js';
-import {
-    isP2TR,
-    isP2WPKH,
-    pubkeyInScript,
-    witnessStackToScriptWitness,
-} from './psbt/psbtutils.js';
+import { isP2TR, isP2WPKH, pubkeyInScript, witnessStackToScriptWitness } from './psbt/psbtutils.js';
 import {
     check32Bit,
     checkCache,
@@ -64,51 +54,59 @@ import {
     sighashTypeToString,
 } from './psbt/utils.js';
 import * as bscript from './script.js';
-import { Transaction } from './transaction.js';
 import type { Output } from './transaction.js';
-import type { Bytes20, Bytes32, PublicKey, Satoshi, SchnorrSignature, Signature, Script, XOnlyPublicKey } from './types.js';
-
-// Re-export types from the types module
-export type {
-    TransactionInput,
-    PsbtTxInput,
-    TransactionOutput,
-    PsbtTxOutput,
-    ValidateSigFunction,
+import { Transaction } from './transaction.js';
+import type {
+    Bytes20,
+    Bytes32,
+    PublicKey,
+    Satoshi,
+    SchnorrSignature,
+    Script,
+    Signature,
+    XOnlyPublicKey,
+} from './types.js';
+// Import types for internal use
+import type {
+    AllScriptType,
+    FinalScriptsFunc,
+    FinalTaprootScriptsFunc,
+    GetScriptReturn,
+    HDSigner,
+    HDSignerAsync,
     PsbtBaseExtended,
-    PsbtOptsOptional,
-    PsbtOpts,
+    PsbtCache,
     PsbtInputExtended,
+    PsbtOpts,
+    PsbtOptsOptional,
     PsbtOutputExtended,
     PsbtOutputExtendedAddress,
-    PsbtOutputExtendedScript,
-    HDSigner,
-    HDSignerAsync,
-    SignerAlternative,
+    PsbtTxInput,
+    PsbtTxOutput,
     Signer,
+    SignerAlternative,
     SignerAsync,
     TaprootHashCheckSigner,
-    PsbtCache,
+    TransactionInput,
+    TransactionOutput,
     TxCacheNumberKey,
-    ScriptType,
-    AllScriptType,
-    GetScriptReturn,
-    FinalScriptsFunc,
-    FinalTaprootScriptsFunc,
+    ValidateSigFunction,
 } from './psbt/types.js';
 
-// Import types for internal use
-import type {
+// Re-export types from the types module
+export type {
     TransactionInput,
     PsbtTxInput,
     TransactionOutput,
     PsbtTxOutput,
+    ValidateSigFunction,
     PsbtBaseExtended,
     PsbtOptsOptional,
     PsbtOpts,
     PsbtInputExtended,
     PsbtOutputExtended,
     PsbtOutputExtendedAddress,
+    PsbtOutputExtendedScript,
     HDSigner,
     HDSignerAsync,
     SignerAlternative,
@@ -117,11 +115,11 @@ import type {
     TaprootHashCheckSigner,
     PsbtCache,
     TxCacheNumberKey,
+    ScriptType,
     AllScriptType,
     GetScriptReturn,
     FinalScriptsFunc,
     FinalTaprootScriptsFunc,
-    ValidateSigFunction,
 } from './psbt/types.js';
 
 /**
@@ -405,11 +403,7 @@ export class Psbt {
     addOutput(outputData: PsbtOutputExtended, checkPartialSigs: boolean = true): this {
         const hasAddress = 'address' in outputData;
         const hasScript = 'script' in outputData;
-        if (
-            !outputData ||
-            outputData.value === undefined ||
-            (!hasAddress && !hasScript)
-        ) {
+        if (!outputData || outputData.value === undefined || (!hasAddress && !hasScript)) {
             throw new Error(
                 `Invalid arguments for Psbt.addOutput. ` +
                     `Requires single object with at least [script or address] and [value]`,
@@ -437,7 +431,9 @@ export class Psbt {
 
     extractTransaction(disableFeeCheck?: boolean, disableOutputChecks?: boolean): Transaction {
         if (disableOutputChecks) {
-            (this.data as unknown as { inputs: PsbtInput[] }).inputs = this.data.inputs.filter((i) => !i.partialSig);
+            (this.data as unknown as { inputs: PsbtInput[] }).inputs = this.data.inputs.filter(
+                (i) => !i.partialSig,
+            );
         }
 
         if (!this.data.inputs.every(isFinalized)) throw new Error('Not finalized');
@@ -516,10 +512,8 @@ export class Psbt {
             script,
             inputIndex,
             'input',
-            input.redeemScript ||
-                redeemFromFinalScriptSig(input.finalScriptSig),
-            input.witnessScript ||
-                redeemFromFinalWitnessScript(input.finalScriptWitness),
+            input.redeemScript || redeemFromFinalScriptSig(input.finalScriptSig),
+            input.witnessScript || redeemFromFinalWitnessScript(input.finalScriptWitness),
         );
         const type = result.type === 'raw' ? '' : result.type + '-';
         const mainType = classifyScript(result.meaningfulScript);
@@ -755,7 +749,14 @@ export class Psbt {
 
     signInputAsync(
         inputIndex: number,
-        keyPair: Signer | SignerAlternative | SignerAsync | HDSigner | HDSignerAsync | BIP32Interface | ECPairInterface,
+        keyPair:
+            | Signer
+            | SignerAlternative
+            | SignerAsync
+            | HDSigner
+            | HDSignerAsync
+            | BIP32Interface
+            | ECPairInterface,
         sighashTypes?: number[],
     ): Promise<void> {
         return Promise.resolve().then(() => {
@@ -777,7 +778,14 @@ export class Psbt {
 
     signTaprootInputAsync(
         inputIndex: number,
-        keyPair: Signer | SignerAlternative | SignerAsync | HDSigner | HDSignerAsync | BIP32Interface | ECPairInterface,
+        keyPair:
+            | Signer
+            | SignerAlternative
+            | SignerAsync
+            | HDSigner
+            | HDSignerAsync
+            | BIP32Interface
+            | ECPairInterface,
         tapLeafHash?: Uint8Array,
         sighashTypes?: number[],
     ): Promise<void> {
@@ -872,16 +880,25 @@ export class Psbt {
     checkTaprootHashesForSig(
         inputIndex: number,
         input: PsbtInput,
-        keyPair: Signer | SignerAlternative | SignerAsync | HDSigner | HDSignerAsync | TaprootHashCheckSigner | BIP32Interface | ECPairInterface,
+        keyPair:
+            | Signer
+            | SignerAlternative
+            | SignerAsync
+            | HDSigner
+            | HDSignerAsync
+            | TaprootHashCheckSigner
+            | BIP32Interface
+            | ECPairInterface,
         tapLeafHashToSign?: Uint8Array,
         allowedSighashTypes?: number[],
     ): { hash: Bytes32; leafHash?: Bytes32 }[] {
         if (!('signSchnorr' in keyPair) || typeof keyPair.signSchnorr !== 'function')
             throw new Error(`Need Schnorr Signer to sign taproot input #${inputIndex}.`);
 
-        const pubkey = keyPair.publicKey instanceof Uint8Array
-            ? keyPair.publicKey
-            : new Uint8Array(keyPair.publicKey);
+        const pubkey =
+            keyPair.publicKey instanceof Uint8Array
+                ? keyPair.publicKey
+                : new Uint8Array(keyPair.publicKey);
 
         const hashesForSig = getTaprootHashesForSig(
             inputIndex,
@@ -894,9 +911,7 @@ export class Psbt {
         );
 
         if (!hashesForSig || !hashesForSig.length)
-            throw new Error(
-                `Can not sign for input #${inputIndex} with the key ${toHex(pubkey)}`,
-            );
+            throw new Error(`Can not sign for input #${inputIndex} with the key ${toHex(pubkey)}`);
 
         return hashesForSig;
     }
@@ -978,9 +993,7 @@ export class Psbt {
             throw new Error('No signatures to validate');
         if (typeof validator !== 'function')
             throw new Error('Need validator function to validate signatures');
-        const mySigs = pubkey
-            ? partialSig.filter((sig) => equals(sig.pubkey, pubkey))
-            : partialSig;
+        const mySigs = pubkey ? partialSig.filter((sig) => equals(sig.pubkey, pubkey)) : partialSig;
         if (mySigs.length < 1) throw new Error('No signatures for this pubkey');
         const results: boolean[] = [];
         let hashCache: Bytes32 | undefined;
@@ -1066,9 +1079,10 @@ export class Psbt {
         keyPair: Signer | SignerAlternative | HDSigner | BIP32Interface | ECPairInterface,
         sighashTypes: number[] = [Transaction.SIGHASH_ALL],
     ): this {
-        const pubkey = keyPair.publicKey instanceof Uint8Array
-            ? keyPair.publicKey
-            : new Uint8Array(keyPair.publicKey);
+        const pubkey =
+            keyPair.publicKey instanceof Uint8Array
+                ? keyPair.publicKey
+                : new Uint8Array(keyPair.publicKey);
 
         const { hash, sighashType } = getHashAndSighashType(
             this.data.inputs,
@@ -1155,12 +1169,20 @@ export class Psbt {
 
     #signInputAsync(
         inputIndex: number,
-        keyPair: Signer | SignerAlternative | SignerAsync | HDSigner | HDSignerAsync | BIP32Interface | ECPairInterface,
+        keyPair:
+            | Signer
+            | SignerAlternative
+            | SignerAsync
+            | HDSigner
+            | HDSignerAsync
+            | BIP32Interface
+            | ECPairInterface,
         sighashTypes: number[] = [Transaction.SIGHASH_ALL],
     ): Promise<void> {
-        const pubkey = keyPair.publicKey instanceof Uint8Array
-            ? keyPair.publicKey
-            : new Uint8Array(keyPair.publicKey);
+        const pubkey =
+            keyPair.publicKey instanceof Uint8Array
+                ? keyPair.publicKey
+                : new Uint8Array(keyPair.publicKey);
 
         const { hash, sighashType } = getHashAndSighashType(
             this.data.inputs,
@@ -1187,7 +1209,14 @@ export class Psbt {
     async #signTaprootInputAsync(
         inputIndex: number,
         input: PsbtInput,
-        keyPair: Signer | SignerAlternative | SignerAsync | HDSigner | HDSignerAsync | BIP32Interface | ECPairInterface,
+        keyPair:
+            | Signer
+            | SignerAlternative
+            | SignerAsync
+            | HDSigner
+            | HDSignerAsync
+            | BIP32Interface
+            | ECPairInterface,
         tapLeafHash?: Uint8Array,
         sighashTypes: number[] = [Transaction.SIGHASH_DEFAULT],
     ): Promise<void> {
@@ -1359,12 +1388,14 @@ function hasSigs(neededSigs: number, partialSig?: PartialSig[], pubkeys?: Uint8A
 
 function bip32DerivationIsMine(root: HDSigner): (d: Bip32Derivation) => boolean {
     return (d: Bip32Derivation): boolean => {
-        const fingerprint = root.fingerprint instanceof Uint8Array
-            ? root.fingerprint
-            : new Uint8Array(root.fingerprint);
+        const fingerprint =
+            root.fingerprint instanceof Uint8Array
+                ? root.fingerprint
+                : new Uint8Array(root.fingerprint);
         if (!equals(d.masterFingerprint, fingerprint)) return false;
         const derivedPubkey = root.derivePath(d.path).publicKey;
-        const pubkey = derivedPubkey instanceof Uint8Array ? derivedPubkey : new Uint8Array(derivedPubkey);
+        const pubkey =
+            derivedPubkey instanceof Uint8Array ? derivedPubkey : new Uint8Array(derivedPubkey);
         if (!equals(pubkey, d.pubkey)) return false;
         return true;
     };
@@ -1570,12 +1601,7 @@ function getHashForSig(
     const script = meaningfulScript as Script;
 
     if (['p2sh-p2wsh', 'p2wsh'].indexOf(type) >= 0) {
-        hash = unsignedTx.hashForWitnessV0(
-            inputIndex,
-            script,
-            prevout.value,
-            sighashType,
-        );
+        hash = unsignedTx.hashForWitnessV0(inputIndex, script, prevout.value, sighashType);
     } else if (isP2WPKH(meaningfulScript)) {
         // P2WPKH uses the P2PKH template for prevoutScript when signing
         const p2pkhPayment = payments.p2pkh({
@@ -1647,7 +1673,7 @@ function getPrevoutTaprootKey(
     cache: PsbtCache,
 ): XOnlyPublicKey | null {
     const { script } = getScriptAndAmountFromUtxo(inputIndex, input, cache);
-    return isP2TR(script) ? script.subarray(2, 34) as XOnlyPublicKey : null;
+    return isP2TR(script) ? (script.subarray(2, 34) as XOnlyPublicKey) : null;
 }
 
 function trimTaprootSig(signature: Uint8Array): Uint8Array {
@@ -1669,9 +1695,7 @@ function getTaprootHashesForSig(
     checkSighashTypeAllowed(sighashType, allowedSighashTypes);
 
     if (!cache.prevOuts) {
-        const prevOuts = inputs.map((i, index) =>
-            getScriptAndAmountFromUtxo(index, i, cache),
-        );
+        const prevOuts = inputs.map((i, index) => getScriptAndAmountFromUtxo(index, i, cache));
         cache.prevOuts = prevOuts;
         cache.signingScripts = prevOuts.map((o) => o.script);
         cache.values = prevOuts.map((o) => o.value);

package/src/script.ts

@@ -3,14 +3,15 @@
  * @packageDocumentation
  */
 import * as bip66 from './bip66.js';
-import { toHex, fromHex, alloc } from './io/index.js';
+import { alloc, fromHex, toHex } from './io/index.js';
 import type { Opcodes } from './opcodes.js';
 import { opcodes, REVERSE_OPS } from './opcodes.js';
 import * as pushdata from './push_data.js';
 import * as scriptNumber from './script_number.js';
 import * as scriptSignature from './script_signature.js';
-import * as types from './types.js';
+import { isDefinedHashType } from './script_signature.js';
 import type { Script, Stack } from './types.js';
+import * as types from './types.js';
 
 const OP_INT_BASE = opcodes.OP_RESERVED; // OP_1 - 1
 export { opcodes };
@@ -116,9 +117,7 @@ export function compile(chunks: Uint8Array | Stack): Script {
     return buffer as Script;
 }
 
-export function decompile(
-    buffer: Uint8Array | Stack,
-): Array<number | Uint8Array> | null {
+export function decompile(buffer: Uint8Array | Stack): Array<number | Uint8Array> | null {
     // Already decompiled - return as-is
     if (chunksIsArray(buffer)) return buffer as Array<number | Uint8Array>;
 
@@ -247,8 +246,6 @@ export function isCanonicalPubKey(buffer: Uint8Array): boolean {
     return types.isPoint(buffer);
 }
 
-import { isDefinedHashType } from './script_signature.js';
-
 export function isCanonicalScriptSignature(buffer: Uint8Array): boolean {
     if (!(buffer instanceof Uint8Array)) return false;
     if (!isDefinedHashType(buffer[buffer.length - 1]!)) return false;

package/src/transaction.ts

@@ -1,4 +1,4 @@
-import { BinaryReader, BinaryWriter, reverse, varuint, fromHex, toHex, alloc } from './io/index.js';
+import { alloc, BinaryReader, BinaryWriter, fromHex, reverse, toHex, varuint } from './io/index.js';
 import * as bcrypto from './crypto.js';
 import * as bscript from './script.js';
 import { opcodes } from './script.js';
@@ -23,9 +23,7 @@ function vectorSize(someVector: Uint8Array[]): number {
 
 const EMPTY_BYTES = new Uint8Array(0) as Script;
 const EMPTY_WITNESS: Uint8Array[] = [];
-const ZERO = fromHex(
-    '0000000000000000000000000000000000000000000000000000000000000000',
-) as Bytes32;
+const ZERO = fromHex('0000000000000000000000000000000000000000000000000000000000000000') as Bytes32;
 const ONE = fromHex('0000000000000000000000000000000000000000000000000000000000000001') as Bytes32;
 
 /** Maximum value for SIGHASH_SINGLE blank outputs (0xFFFFFFFFFFFFFFFF) */
@@ -493,7 +491,9 @@ export class Transaction {
                 bufferWriter = new BinaryWriter(
                     prevOutScripts.map(varSliceSize).reduce((a, b) => a + b),
                 );
-                prevOutScripts.forEach((prevOutScript) => bufferWriter.writeVarBytes(prevOutScript));
+                prevOutScripts.forEach((prevOutScript) =>
+                    bufferWriter.writeVarBytes(prevOutScript),
+                );
                 hashScriptPubKeys = bcrypto.sha256(bufferWriter.finish());
 
                 bufferWriter = new BinaryWriter(4 * this.ins.length);
@@ -600,7 +600,10 @@ export class Transaction {
      * @param values - Array of previous output values for all inputs
      * @returns Cache object to pass to hashForWitnessV1
      */
-    getTaprootHashCache(prevOutScripts: readonly Script[], values: readonly Satoshi[]): TaprootHashCache {
+    getTaprootHashCache(
+        prevOutScripts: readonly Script[],
+        values: readonly Satoshi[],
+    ): TaprootHashCache {
         // hashPrevouts
         let bufferWriter = new BinaryWriter(36 * this.ins.length);
         for (const txIn of this.ins) {

package/src/types.ts

@@ -3,7 +3,18 @@
  *
  * @packageDocumentation
  */
-import { isZero, compare, fromHex, equals } from './io/index.js';
+import { compare, equals, fromHex, isZero } from './io/index.js';
+import type {
+    Bytes20,
+    Bytes32,
+    PrivateKey,
+    PublicKey,
+    Satoshi,
+    SchnorrSignature,
+    Script,
+    Signature,
+    XOnlyPublicKey,
+} from './branded.js';
 
 // ============================================================================
 // Branded Types (re-exported from branded.ts to avoid circular dependencies)
@@ -21,8 +32,6 @@ export type {
     Script,
 } from './branded.js';
 
-import type { Bytes32, Bytes20, Satoshi, PrivateKey, XOnlyPublicKey, PublicKey, SchnorrSignature, Signature, Script } from './branded.js';
-
 // ============================================================================
 // Constants
 // ============================================================================
@@ -40,20 +49,12 @@ export const TAPLEAF_VERSION_MASK = 0xfe;
 // ============================================================================
 
 export function isUInt8(value: unknown): value is number {
-    return (
-        typeof value === 'number' &&
-        Number.isInteger(value) &&
-        value >= 0 &&
-        value <= 0xff
-    );
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0 && value <= 0xff;
 }
 
 export function isUInt32(value: unknown): value is number {
     return (
-        typeof value === 'number' &&
-        Number.isInteger(value) &&
-        value >= 0 &&
-        value <= 0xffffffff
+        typeof value === 'number' && Number.isInteger(value) && value >= 0 && value <= 0xffffffff
     );
 }
 
@@ -244,10 +245,7 @@ export function assertXOnlyPublicKey(
     }
 }
 
-export function assertPrivateKey(
-    value: unknown,
-    name: string,
-): asserts value is PrivateKey {
+export function assertPrivateKey(value: unknown, name: string): asserts value is PrivateKey {
     if (!(value instanceof Uint8Array)) {
         throw new TypeError(`${name} must be Uint8Array, got ${typeof value}`);
     }

package/src/workers/WorkerSigningPool.node.ts

@@ -7,21 +7,21 @@
  * @packageDocumentation
  */
 
-import { Worker, isMainThread } from 'worker_threads';
+import { isMainThread, Worker } from 'worker_threads';
 import { cpus } from 'os';
 import type {
-    WorkerPoolConfig,
-    SigningTask,
+    BatchSigningMessage,
+    BatchSigningResultMessage,
+    BatchSigningTask,
     ParallelSignerKeyPair,
     ParallelSigningResult,
+    PooledWorker,
     SigningResultMessage,
+    SigningTask,
+    WorkerPoolConfig,
     WorkerResponse,
-    BatchSigningMessage,
-    BatchSigningTask,
-    BatchSigningResultMessage,
-    PooledWorker,
 } from './types.js';
-import { WorkerState, isBatchResult, isWorkerReady } from './types.js';
+import { isBatchResult, isWorkerReady, WorkerState } from './types.js';
 
 /**
  * ECC library types for Node.js worker.
@@ -163,29 +163,6 @@ export class NodeWorkerSigningPool {
         this.#preserveWorkers = this.#config.preserveWorkers;
     }
 
-    /**
-     * Gets the singleton pool instance.
-     *
-     * @param config - Optional configuration (only used on first call)
-     * @returns The singleton pool instance
-     */
-    public static getInstance(config?: NodeWorkerPoolConfig): NodeWorkerSigningPool {
-        if (!NodeWorkerSigningPool.#instance) {
-            NodeWorkerSigningPool.#instance = new NodeWorkerSigningPool(config);
-        }
-        return NodeWorkerSigningPool.#instance;
-    }
-
-    /**
-     * Resets the singleton instance (for testing).
-     */
-    public static resetInstance(): void {
-        if (NodeWorkerSigningPool.#instance) {
-            NodeWorkerSigningPool.#instance.shutdown().catch(() => {});
-            NodeWorkerSigningPool.#instance = null;
-        }
-    }
-
     /**
      * Number of workers in the pool.
      */
@@ -214,6 +191,29 @@ export class NodeWorkerSigningPool {
         return this.#preserveWorkers;
     }
 
+    /**
+     * Gets the singleton pool instance.
+     *
+     * @param config - Optional configuration (only used on first call)
+     * @returns The singleton pool instance
+     */
+    public static getInstance(config?: NodeWorkerPoolConfig): NodeWorkerSigningPool {
+        if (!NodeWorkerSigningPool.#instance) {
+            NodeWorkerSigningPool.#instance = new NodeWorkerSigningPool(config);
+        }
+        return NodeWorkerSigningPool.#instance;
+    }
+
+    /**
+     * Resets the singleton instance (for testing).
+     */
+    public static resetInstance(): void {
+        if (NodeWorkerSigningPool.#instance) {
+            NodeWorkerSigningPool.#instance.shutdown().catch(() => {});
+            NodeWorkerSigningPool.#instance = null;
+        }
+    }
+
     /**
      * Enables worker preservation between signing batches.
      */

package/src/workers/WorkerSigningPool.ts

@@ -31,22 +31,18 @@
  */
 
 import type {
-    WorkerPoolConfig,
-    SigningTask,
+    BatchSigningMessage,
+    BatchSigningResultMessage,
+    BatchSigningTask,
     ParallelSignerKeyPair,
     ParallelSigningResult,
+    PooledWorker,
     SigningResultMessage,
+    SigningTask,
+    WorkerPoolConfig,
     WorkerResponse,
-    BatchSigningMessage,
-    BatchSigningTask,
-    BatchSigningResultMessage,
-    PooledWorker,
-} from './types.js';
-import {
-    WorkerState,
-    isBatchResult,
-    isWorkerReady,
 } from './types.js';
+import { isBatchResult, isWorkerReady, WorkerState, } from './types.js';
 import { createWorkerBlobUrl, revokeWorkerBlobUrl } from './signing-worker.js';
 
 /**
@@ -151,34 +147,6 @@ export class WorkerSigningPool {
         this.#preserveWorkers = this.#config.preserveWorkers;
     }
 
-    /**
-     * Gets the singleton pool instance.
-     *
-     * @param config - Optional configuration (only used on first call)
-     * @returns The singleton pool instance
-     *
-     * @example
-     * ```typescript
-     * const pool = WorkerSigningPool.getInstance({ workerCount: 8 });
-     * ```
-     */
-    public static getInstance(config?: WorkerPoolConfig): WorkerSigningPool {
-        if (!WorkerSigningPool.#instance) {
-            WorkerSigningPool.#instance = new WorkerSigningPool(config);
-        }
-        return WorkerSigningPool.#instance;
-    }
-
-    /**
-     * Resets the singleton instance (for testing).
-     */
-    public static resetInstance(): void {
-        if (WorkerSigningPool.#instance) {
-            WorkerSigningPool.#instance.shutdown().catch(() => {});
-            WorkerSigningPool.#instance = null;
-        }
-    }
-
     /**
      * Number of workers in the pool.
      */
@@ -207,6 +175,34 @@ export class WorkerSigningPool {
         return this.#preserveWorkers;
     }
 
+    /**
+     * Gets the singleton pool instance.
+     *
+     * @param config - Optional configuration (only used on first call)
+     * @returns The singleton pool instance
+     *
+     * @example
+     * ```typescript
+     * const pool = WorkerSigningPool.getInstance({ workerCount: 8 });
+     * ```
+     */
+    public static getInstance(config?: WorkerPoolConfig): WorkerSigningPool {
+        if (!WorkerSigningPool.#instance) {
+            WorkerSigningPool.#instance = new WorkerSigningPool(config);
+        }
+        return WorkerSigningPool.#instance;
+    }
+
+    /**
+     * Resets the singleton instance (for testing).
+     */
+    public static resetInstance(): void {
+        if (WorkerSigningPool.#instance) {
+            WorkerSigningPool.#instance.shutdown().catch(() => {});
+            WorkerSigningPool.#instance = null;
+        }
+    }
+
     /**
      * Enables worker preservation between signing batches.
      *