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

package/test/workers-pool.spec.ts

@@ -1,13 +1,10 @@
-import { describe, it, expect, beforeEach, afterEach, vi, type Mock } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import {
-    SignatureType,
-    WorkerState,
     type BatchSigningTaskResult,
-    type SigningTask,
     type ParallelSignerKeyPair,
+    SignatureType,
+    type SigningTask,
     type WorkerResponse,
-    type SigningResultMessage,
-    type WorkerPoolConfig,
 } from '../src/workers/types.js';
 
 // Mock Worker class for browser pool testing
@@ -60,14 +57,16 @@ class MockWorker {
                 }
 
                 // Generate results for all tasks
-                const results = batchMsg.tasks.map((task): BatchSigningTaskResult => ({
-                    taskId: task.taskId,
-                    signature: new Uint8Array(64).fill(0xab),
-                    inputIndex: task.inputIndex,
-                    publicKey: task.publicKey,
-                    signatureType: task.signatureType,
-                    ...(task.leafHash ? { leafHash: task.leafHash } : {}),
-                }));
+                const results = batchMsg.tasks.map(
+                    (task): BatchSigningTaskResult => ({
+                        taskId: task.taskId,
+                        signature: new Uint8Array(64).fill(0xab),
+                        inputIndex: task.inputIndex,
+                        publicKey: task.publicKey,
+                        signatureType: task.signatureType,
+                        ...(task.leafHash ? { leafHash: task.leafHash } : {}),
+                    }),
+                );
 
                 this.simulateMessage({
                     type: 'batchResult',
@@ -104,6 +103,15 @@ class MockWorker {
         this.errorHandlers = [];
     }
 
+    simulateError(error: Error): void {
+        if (this.onerror) {
+            this.onerror(error);
+        }
+        for (const handler of this.errorHandlers) {
+            handler(error);
+        }
+    }
+
     private simulateMessage(data: WorkerResponse): void {
         const event = { data };
         if (this.onmessage) {
@@ -113,15 +121,6 @@ class MockWorker {
             handler(event);
         }
     }
-
-    simulateError(error: Error): void {
-        if (this.onerror) {
-            this.onerror(error);
-        }
-        for (const handler of this.errorHandlers) {
-            handler(error);
-        }
-    }
 }
 
 // Mock Worker that fails signing

package/test/workers-signing.spec.ts

@@ -5,9 +5,8 @@
  * infrastructure are cryptographically valid.
  */
 
-import { describe, it, expect, beforeAll } from 'vitest';
+import { beforeAll, describe, expect, it } from 'vitest';
 import * as ecc from 'tiny-secp256k1';
-import { ECPairFactory } from 'ecpair';
 import { randomBytes } from 'crypto';
 
 import { SignatureType, type WorkerEccLib } from '../src/workers/types.js';
@@ -15,8 +14,13 @@ import { generateWorkerCode } from '../src/workers/signing-worker.js';
 import { toXOnly } from '../src/pubkey.js';
 import { initEccLib } from '../src/ecc/context.js';
 import type { EccLib } from '../src/types.js';
+import { ECPairSigner, createNobleBackend } from '@btc-vision/ecpair';
+import { bitcoin } from '../src/networks.js';
 
-const ECPair = ECPairFactory(ecc);
+const backend = createNobleBackend();
+const ECPair = {
+    makeRandom: () => ECPairSigner.makeRandom(backend, bitcoin),
+};
 
 describe('Worker Signing - Signature Verification', () => {
     beforeAll(() => {

package/test/workers.spec.ts

@@ -1,16 +1,15 @@
-import { describe, it, expect, beforeEach, afterEach, vi, type Mock } from 'vitest';
+import { beforeEach, describe, expect, it } from 'vitest';
 import {
-    SignatureType,
-    WorkerState,
     isSigningError,
     isSigningResult,
     isWorkerReady,
-    type WorkerResponse,
-    type SigningResultMessage,
+    type ParallelSignerKeyPair,
+    SignatureType,
     type SigningErrorMessage,
-    type WorkerReadyMessage,
+    type SigningResultMessage,
     type SigningTask,
-    type ParallelSignerKeyPair,
+    type WorkerReadyMessage,
+    WorkerState,
 } from '../src/workers/types.js';
 import { generateWorkerCode } from '../src/workers/signing-worker.js';
 

package/typedoc.json

@@ -25,5 +25,15 @@
     "plugin": [
         "typedoc-material-theme"
     ],
-    "themeColor": "#F7931A"
+    "themeColor": "#F7931A",
+    "intentionallyNotExported": [
+        "Brand",
+        "HashLeaf",
+        "HashBranch",
+        "TaggedHashPrefixes",
+        "__module",
+        "PrevOut",
+        "TxInCacheMap",
+        "NodeEccLibrary"
+    ]
 }

package/vitest.config.browser.ts

@@ -0,0 +1,68 @@
+import { resolve } from 'path';
+import { defineConfig } from 'vitest/config';
+import { nodePolyfills } from 'vite-plugin-node-polyfills';
+import wasm from 'vite-plugin-wasm';
+import topLevelAwait from 'vite-plugin-top-level-await';
+import { playwright } from '@vitest/browser-playwright';
+
+export default defineConfig({
+    resolve: {
+        alias: {
+            crypto: resolve(__dirname, 'src/crypto/crypto-browser.js'),
+            stream: 'stream-browserify',
+            buffer: 'buffer',
+            zlib: 'browserify-zlib',
+        },
+    },
+    plugins: [
+        wasm(),
+        topLevelAwait(),
+        nodePolyfills({
+            globals: {
+                Buffer: true,
+                global: true,
+                process: true,
+            },
+        }),
+    ],
+    optimizeDeps: {
+        exclude: ['tiny-secp256k1'],
+    },
+    test: {
+        globals: true,
+        include: [
+            // Browser-compatible existing tests (no Node.js deps)
+            'test/address.spec.ts',
+            'test/block.spec.ts',
+            'test/bufferutils.spec.ts',
+            'test/crypto.spec.ts',
+            'test/bitcoin.core.spec.ts',
+            'test/transaction.spec.ts',
+            'test/types.spec.ts',
+            'test/script_number.spec.ts',
+            'test/script_signature.spec.ts',
+            'test/workers.spec.ts',
+            'test/workers-pool.spec.ts',
+            // Browser-adapted versions
+            'test/browser/payments.spec.ts',
+            'test/browser/psbt.spec.ts',
+            'test/browser/workers-signing.spec.ts',
+            'test/browser/script.spec.ts',
+        ],
+        exclude: [
+            'test/integration/**/*.ts',
+            // Originals that need Node.js APIs
+            'test/payments.spec.ts',
+            'test/psbt.spec.ts',
+            'test/workers-signing.spec.ts',
+            'test/script.spec.ts',
+        ],
+        testTimeout: 30000,
+        browser: {
+            enabled: true,
+            provider: playwright(),
+            instances: [{ browser: 'chromium' }],
+            headless: true,
+        },
+    },
+});

package/browser/ecpair.d.ts

@@ -1,99 +0,0 @@
-/**
- * Ambient module declaration for ecpair.
- *
- * The upstream ecpair@3 .d.ts files depend on valibot@^0.37 type-level APIs.
- * When a different valibot major is hoisted (e.g. v1.x required by bip32),
- * @typescript-eslint resolves valibot from the project root instead of
- * ecpair's nested node_modules, turning every ecpair type into an error type.
- *
- * This local declaration re-exports the subset of ecpair's public API that
- * this project actually uses, without any valibot dependency.
- */
-declare module 'ecpair' {
-    interface Network {
-        messagePrefix: string | Uint8Array;
-        bech32: string;
-        bip32: {
-            public: number;
-            private: number;
-        };
-        pubKeyHash: number;
-        scriptHash: number;
-        wif: number;
-    }
-
-    interface Signer {
-        publicKey: Uint8Array;
-        network?: unknown;
-        sign(hash: Uint8Array, lowR?: boolean): Uint8Array;
-    }
-
-    interface SignerAsync {
-        publicKey: Uint8Array;
-        network?: unknown;
-        sign(hash: Uint8Array, lowR?: boolean): Promise<Uint8Array>;
-    }
-
-    interface ECPairInterface extends Signer {
-        compressed: boolean;
-        network: Network;
-        lowR: boolean;
-        privateKey?: Uint8Array;
-        toWIF(): string;
-        tweak(t: Uint8Array): ECPairInterface;
-        verify(hash: Uint8Array, signature: Uint8Array): boolean;
-        verifySchnorr(hash: Uint8Array, signature: Uint8Array): boolean;
-        signSchnorr(hash: Uint8Array): Uint8Array;
-    }
-
-    interface ECPairOptions {
-        compressed?: boolean;
-        network?: Network;
-        rng?: (arg?: number) => Uint8Array;
-    }
-
-    interface ECPairAPI {
-        isPoint(maybePoint: unknown): boolean;
-        fromPrivateKey(buffer: Uint8Array, options?: ECPairOptions): ECPairInterface;
-        fromPublicKey(buffer: Uint8Array, options?: ECPairOptions): ECPairInterface;
-        fromWIF(wifString: string, network?: Network | Network[]): ECPairInterface;
-        makeRandom(options?: ECPairOptions): ECPairInterface;
-    }
-
-    interface TinySecp256k1Interface {
-        isPoint(p: Uint8Array): boolean;
-        pointCompress(p: Uint8Array, compressed?: boolean): Uint8Array;
-        isPrivate(d: Uint8Array): boolean;
-        pointFromScalar(d: Uint8Array, compressed?: boolean): Uint8Array | null;
-        xOnlyPointAddTweak(
-            p: Uint8Array,
-            tweak: Uint8Array,
-        ): { parity: 1 | 0; xOnlyPubkey: Uint8Array } | null;
-        privateAdd(d: Uint8Array, tweak: Uint8Array): Uint8Array | null;
-        privateNegate(d: Uint8Array): Uint8Array;
-        sign(h: Uint8Array, d: Uint8Array, e?: Uint8Array): Uint8Array;
-        signSchnorr?(h: Uint8Array, d: Uint8Array, e?: Uint8Array): Uint8Array;
-        verify(h: Uint8Array, Q: Uint8Array, signature: Uint8Array, strict?: boolean): boolean;
-        verifySchnorr?(h: Uint8Array, Q: Uint8Array, signature: Uint8Array): boolean;
-    }
-
-    const networks: {
-        bitcoin: Network;
-        testnet: Network;
-    };
-
-    function ECPairFactory(ecc: TinySecp256k1Interface): ECPairAPI;
-    export default ECPairFactory;
-
-    export {
-        ECPairFactory,
-        Signer,
-        SignerAsync,
-        ECPairAPI,
-        ECPairInterface,
-        ECPairOptions,
-        TinySecp256k1Interface,
-        Network,
-        networks,
-    };
-}

package/src/ecpair.d.ts

@@ -1,99 +0,0 @@
-/**
- * Ambient module declaration for ecpair.
- *
- * The upstream ecpair@3 .d.ts files depend on valibot@^0.37 type-level APIs.
- * When a different valibot major is hoisted (e.g. v1.x required by bip32),
- * @typescript-eslint resolves valibot from the project root instead of
- * ecpair's nested node_modules, turning every ecpair type into an error type.
- *
- * This local declaration re-exports the subset of ecpair's public API that
- * this project actually uses, without any valibot dependency.
- */
-declare module 'ecpair' {
-    interface Network {
-        messagePrefix: string | Uint8Array;
-        bech32: string;
-        bip32: {
-            public: number;
-            private: number;
-        };
-        pubKeyHash: number;
-        scriptHash: number;
-        wif: number;
-    }
-
-    interface Signer {
-        publicKey: Uint8Array;
-        network?: unknown;
-        sign(hash: Uint8Array, lowR?: boolean): Uint8Array;
-    }
-
-    interface SignerAsync {
-        publicKey: Uint8Array;
-        network?: unknown;
-        sign(hash: Uint8Array, lowR?: boolean): Promise<Uint8Array>;
-    }
-
-    interface ECPairInterface extends Signer {
-        compressed: boolean;
-        network: Network;
-        lowR: boolean;
-        privateKey?: Uint8Array;
-        toWIF(): string;
-        tweak(t: Uint8Array): ECPairInterface;
-        verify(hash: Uint8Array, signature: Uint8Array): boolean;
-        verifySchnorr(hash: Uint8Array, signature: Uint8Array): boolean;
-        signSchnorr(hash: Uint8Array): Uint8Array;
-    }
-
-    interface ECPairOptions {
-        compressed?: boolean;
-        network?: Network;
-        rng?: (arg?: number) => Uint8Array;
-    }
-
-    interface ECPairAPI {
-        isPoint(maybePoint: unknown): boolean;
-        fromPrivateKey(buffer: Uint8Array, options?: ECPairOptions): ECPairInterface;
-        fromPublicKey(buffer: Uint8Array, options?: ECPairOptions): ECPairInterface;
-        fromWIF(wifString: string, network?: Network | Network[]): ECPairInterface;
-        makeRandom(options?: ECPairOptions): ECPairInterface;
-    }
-
-    interface TinySecp256k1Interface {
-        isPoint(p: Uint8Array): boolean;
-        pointCompress(p: Uint8Array, compressed?: boolean): Uint8Array;
-        isPrivate(d: Uint8Array): boolean;
-        pointFromScalar(d: Uint8Array, compressed?: boolean): Uint8Array | null;
-        xOnlyPointAddTweak(
-            p: Uint8Array,
-            tweak: Uint8Array,
-        ): { parity: 1 | 0; xOnlyPubkey: Uint8Array } | null;
-        privateAdd(d: Uint8Array, tweak: Uint8Array): Uint8Array | null;
-        privateNegate(d: Uint8Array): Uint8Array;
-        sign(h: Uint8Array, d: Uint8Array, e?: Uint8Array): Uint8Array;
-        signSchnorr?(h: Uint8Array, d: Uint8Array, e?: Uint8Array): Uint8Array;
-        verify(h: Uint8Array, Q: Uint8Array, signature: Uint8Array, strict?: boolean): boolean;
-        verifySchnorr?(h: Uint8Array, Q: Uint8Array, signature: Uint8Array): boolean;
-    }
-
-    const networks: {
-        bitcoin: Network;
-        testnet: Network;
-    };
-
-    function ECPairFactory(ecc: TinySecp256k1Interface): ECPairAPI;
-    export default ECPairFactory;
-
-    export {
-        ECPairFactory,
-        Signer,
-        SignerAsync,
-        ECPairAPI,
-        ECPairInterface,
-        ECPairOptions,
-        TinySecp256k1Interface,
-        Network,
-        networks,
-    };
-}