@btc-vision/transaction 1.8.0-beta.3 → 1.8.0-beta.5

package/test/old/FastBigIntMap.ts

@@ -91,7 +91,7 @@ export class FastBigIntMap {
      */
     *entries(): IterableIterator<[bigint, bigint]> {
         for (const key of this.keyOrder) {
-            yield [key, this.items[key.toString()]];
+            yield [key, this.items[key.toString()] as bigint];
         }
     }
 
@@ -107,7 +107,7 @@ export class FastBigIntMap {
      */
     *values(): IterableIterator<bigint> {
         for (const key of this.keyOrder) {
-            yield this.items[key.toString()];
+            yield this.items[key.toString()] as bigint;
         }
     }
 
@@ -119,7 +119,7 @@ export class FastBigIntMap {
         thisArg?: unknown,
     ): void {
         for (const key of this.keyOrder) {
-            callback.call(thisArg, this.items[key.toString()], key, this);
+            callback.call(thisArg, this.items[key.toString()] as bigint, key, this);
         }
     }
 

package/test/oldfastmap.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from 'vitest';
-import { FastBigIntMap } from './old/FastBigIntMap';
+import { FastBigIntMap } from './old/FastBigIntMap.js';
 
 describe('FastBigIntMap - Comprehensive Tests', () => {
     describe('Constructor', () => {
@@ -634,7 +634,7 @@ describe('FastBigIntMap - Comprehensive Tests', () => {
             map.set(2n, 200n);
 
             const order: bigint[] = [];
-            map.forEach((value, key) => {
+            map.forEach((_value: bigint, key: bigint) => {
                 order.push(key);
             });
 
@@ -646,7 +646,7 @@ describe('FastBigIntMap - Comprehensive Tests', () => {
             const context = { multiplier: 2n };
 
             let result: bigint = 0n;
-            map.forEach(function (this: { multiplier: bigint }, value) {
+            map.forEach(function (this: { multiplier: bigint }, value: bigint) {
                 result = value * this.multiplier;
             }, context);
 
@@ -657,7 +657,7 @@ describe('FastBigIntMap - Comprehensive Tests', () => {
             const map = new FastBigIntMap([[1n, 100n]]);
             let sum = 0n;
 
-            map.forEach((value) => {
+            map.forEach((value: bigint) => {
                 sum += value;
             });
 
@@ -668,7 +668,7 @@ describe('FastBigIntMap - Comprehensive Tests', () => {
             const map = new FastBigIntMap([[1n, 100n]]);
             let receivedMap: FastBigIntMap | null = null;
 
-            map.forEach((value, key, m) => {
+            map.forEach((_value: bigint, _key: bigint, m: FastBigIntMap) => {
                 receivedMap = m;
             });
 
@@ -763,7 +763,7 @@ describe('FastBigIntMap - Comprehensive Tests', () => {
             const keysFromKeys = [...map.keys()];
             const keysFromEntries = [...map.entries()].map(([k]) => k);
             const keysFromForEach: bigint[] = [];
-            map.forEach((_, key) => keysFromForEach.push(key));
+            map.forEach((_: bigint, key: bigint) => keysFromForEach.push(key));
             const keysFromIterator = [...map].map(([k]) => k);
 
             const expectedOrder = [5n, 1n, 3n, 2n, 4n];

package/test/transaction-builders.test.ts

@@ -0,0 +1,321 @@
+import { describe, expect, it, beforeAll } from 'vitest';
+import { networks, payments, script, toHex, toXOnly, opcodes } from '@btc-vision/bitcoin';
+import { type UniversalSigner } from '@btc-vision/ecpair';
+import type { QuantumBIP32Interface } from '@btc-vision/bip32';
+import {
+    Address,
+    CancelTransaction,
+    CustomScriptTransaction,
+    DeploymentTransaction,
+    EcKeyPair,
+    FundingTransaction,
+    InteractionTransaction,
+    MLDSASecurityLevel,
+    Mnemonic,
+    MultiSignTransaction,
+} from '../build/opnet.js';
+import type { IChallengeSolution, IChallengeVerification, UTXO } from '../build/opnet.js';
+
+const network = networks.regtest;
+const testMnemonic =
+    'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about';
+
+/**
+ * Helper: create a taproot UTXO for an address
+ */
+function createTaprootUtxo(
+    addr: string,
+    value: bigint,
+    txId: string = '0'.repeat(64),
+    index: number = 0,
+): UTXO {
+    const p2tr = payments.p2tr({ address: addr, network });
+    return {
+        transactionId: txId,
+        outputIndex: index,
+        value,
+        scriptPubKey: {
+            hex: toHex(p2tr.output as Uint8Array),
+            address: addr,
+        },
+    };
+}
+
+/**
+ * Helper: create a minimal mock IChallengeSolution
+ */
+function createMockChallenge(publicKey: Address): IChallengeSolution {
+    const verification: IChallengeVerification = {
+        epochHash: new Uint8Array(32),
+        epochRoot: new Uint8Array(32),
+        targetHash: new Uint8Array(32),
+        targetChecksum: new Uint8Array(32),
+        startBlock: 0n,
+        endBlock: 100n,
+        proofs: [],
+    };
+
+    return {
+        epochNumber: 1n,
+        publicKey,
+        solution: new Uint8Array(32),
+        salt: new Uint8Array(32),
+        graffiti: new Uint8Array(32),
+        difficulty: 1,
+        verification,
+        verifySubmissionSignature: () => true,
+        getSubmission: () => undefined,
+        toRaw: () => {
+            throw new Error('Not implemented in mock');
+        },
+        verify: () => true,
+        toBuffer: () => new Uint8Array(0),
+        toHex: () => '',
+        calculateSolution: () => new Uint8Array(32),
+        checkDifficulty: () => ({ valid: true, difficulty: 1 }),
+        getMiningTargetBlock: () => null,
+    };
+}
+
+describe('Transaction Builders - End-to-End', () => {
+    let signer: UniversalSigner;
+    let taprootAddress: string;
+    let walletAddress: Address;
+    let quantumRoot: QuantumBIP32Interface;
+
+    beforeAll(() => {
+        const mnemonic = new Mnemonic(
+            testMnemonic,
+            '',
+            network,
+            MLDSASecurityLevel.LEVEL2,
+        );
+        const wallet = mnemonic.derive(0);
+        signer = wallet.keypair;
+        walletAddress = wallet.address;
+        taprootAddress = wallet.p2tr;
+        quantumRoot = mnemonic.getQuantumRoot();
+    });
+
+    describe('FundingTransaction', () => {
+        it('should build and sign a basic funding transaction', async () => {
+            const utxo = createTaprootUtxo(taprootAddress, 100_000n);
+
+            const tx = new FundingTransaction({
+                signer,
+                network,
+                utxos: [utxo],
+                to: taprootAddress,
+                amount: 50_000n,
+                feeRate: 1,
+                priorityFee: 0n,
+                gasSatFee: 0n,
+                mldsaSigner: null,
+            });
+
+            const signed = await tx.signTransaction();
+
+            expect(signed.ins.length).toBeGreaterThan(0);
+            expect(signed.outs.length).toBeGreaterThan(0);
+            expect(signed.toHex()).toBeTruthy();
+            expect(signed.virtualSize()).toBeGreaterThan(0);
+        });
+
+        it('should produce multiple outputs when splitInputsInto > 1', async () => {
+            const utxo = createTaprootUtxo(taprootAddress, 200_000n);
+
+            const tx = new FundingTransaction({
+                signer,
+                network,
+                utxos: [utxo],
+                to: taprootAddress,
+                amount: 100_000n,
+                splitInputsInto: 3,
+                feeRate: 1,
+                priorityFee: 0n,
+                gasSatFee: 0n,
+                mldsaSigner: null,
+            });
+
+            const signed = await tx.signTransaction();
+
+            // 3 split outputs + possible change output
+            expect(signed.outs.length).toBeGreaterThanOrEqual(3);
+            expect(signed.ins.length).toBeGreaterThan(0);
+            expect(signed.toHex()).toBeTruthy();
+        });
+    });
+
+    describe('CancelTransaction', () => {
+        it('should build and sign a cancel transaction with compiledTargetScript', async () => {
+            const utxo = createTaprootUtxo(taprootAddress, 100_000n);
+
+            // Use script.compile to produce a valid compiled target script
+            const compiledTargetScript = script.compile([
+                toXOnly(signer.publicKey),
+                opcodes.OP_CHECKSIG,
+            ]);
+
+            const tx = new CancelTransaction({
+                signer,
+                network,
+                utxos: [utxo],
+                compiledTargetScript,
+                feeRate: 1,
+                mldsaSigner: null,
+            });
+
+            const signed = await tx.signTransaction();
+
+            expect(signed.ins.length).toBeGreaterThan(0);
+            expect(signed.outs.length).toBeGreaterThan(0);
+            expect(signed.toHex()).toBeTruthy();
+            expect(signed.virtualSize()).toBeGreaterThan(0);
+        });
+    });
+
+    describe('CustomScriptTransaction', () => {
+        it('should build and sign a custom script transaction', async () => {
+            const utxo = createTaprootUtxo(taprootAddress, 100_000n);
+
+            // Use fixed random bytes so we can compute the contract signer's pubkey
+            // and build a script that both signers can sign against.
+            const { crypto: bitCrypto } = await import('@btc-vision/bitcoin');
+            const fixedRandomBytes = new Uint8Array(32);
+            fixedRandomBytes.fill(0x42);
+            const contractSeed = bitCrypto.hash256(fixedRandomBytes);
+            const contractSigner = EcKeyPair.fromSeedKeyPair(contractSeed, network);
+
+            // Build a script that includes both pubkeys: [contractPubKey OP_CHECKSIGVERIFY signerXOnly OP_CHECKSIG]
+            const contractXOnly = toXOnly(contractSigner.publicKey);
+            const signerXOnly = toXOnly(signer.publicKey);
+
+            const tx = new CustomScriptTransaction({
+                signer,
+                network,
+                utxos: [utxo],
+                to: taprootAddress,
+                script: [
+                    contractXOnly,
+                    new Uint8Array([opcodes.OP_CHECKSIGVERIFY]),
+                    signerXOnly,
+                    new Uint8Array([opcodes.OP_CHECKSIG]),
+                ],
+                witnesses: [],
+                randomBytes: fixedRandomBytes,
+                feeRate: 1,
+                priorityFee: 330n,
+                gasSatFee: 330n,
+                mldsaSigner: null,
+            });
+
+            const signed = await tx.signTransaction();
+
+            expect(signed.ins.length).toBeGreaterThan(0);
+            expect(signed.outs.length).toBeGreaterThan(0);
+            expect(signed.toHex()).toBeTruthy();
+            expect(signed.virtualSize()).toBeGreaterThan(0);
+        });
+    });
+
+    describe('MultiSignTransaction', () => {
+        it('should build a multisig transaction and produce valid PSBT', async () => {
+            const signer2 = EcKeyPair.generateRandomKeyPair(network);
+            const signer3 = EcKeyPair.generateRandomKeyPair(network);
+
+            const receiver = EcKeyPair.getTaprootAddress(signer2, network);
+            const refundVault = EcKeyPair.getTaprootAddress(signer3, network);
+
+            const pubkeys = [signer.publicKey, signer2.publicKey, signer3.publicKey];
+
+            const multiSigTx = new MultiSignTransaction({
+                network,
+                utxos: [createTaprootUtxo(taprootAddress, 100_000n)],
+                pubkeys,
+                minimumSignatures: 2,
+                receiver,
+                requestedAmount: 30_000n,
+                refundVault,
+                feeRate: 1,
+                mldsaSigner: null,
+            });
+
+            // signPSBT returns a Psbt (not fully signed since it's multisig)
+            const psbt = await multiSigTx.signPSBT();
+
+            expect(psbt).toBeDefined();
+            expect(psbt.data.inputs.length).toBeGreaterThan(0);
+            // There should be outputs (refund + receiver)
+            expect(psbt.data.outputs.length).toBeGreaterThanOrEqual(2);
+        });
+    });
+
+    describe('InteractionTransaction', () => {
+        it('should build and sign an interaction transaction', async () => {
+            const utxo = createTaprootUtxo(taprootAddress, 100_000n);
+
+            const challenge = createMockChallenge(walletAddress);
+
+            // contract is a 32-byte hex string
+            const contract = '0x' + '00'.repeat(32);
+
+            // Let the builder generate the compiled target script from calldata+challenge
+            const tx = new InteractionTransaction({
+                signer,
+                network,
+                utxos: [utxo],
+                to: taprootAddress,
+                calldata: new Uint8Array([0x01, 0x02, 0x03, 0x04]),
+                challenge,
+                contract,
+                feeRate: 1,
+                priorityFee: 330n,
+                gasSatFee: 330n,
+                mldsaSigner: null,
+            });
+
+            const signed = await tx.signTransaction();
+
+            expect(signed.ins.length).toBeGreaterThan(0);
+            expect(signed.outs.length).toBeGreaterThan(0);
+            expect(signed.toHex()).toBeTruthy();
+            expect(signed.virtualSize()).toBeGreaterThan(0);
+        });
+    });
+
+    describe('DeploymentTransaction', () => {
+        it('should build and sign a deployment transaction', async () => {
+            const utxo = createTaprootUtxo(taprootAddress, 200_000n);
+
+            const challenge = createMockChallenge(walletAddress);
+
+            // Minimal bytecode
+            const bytecode = new Uint8Array(100);
+            bytecode.fill(0xab);
+
+            // Let the builder generate the compiled target script from bytecode+challenge
+            const tx = new DeploymentTransaction({
+                signer,
+                network,
+                utxos: [utxo],
+                bytecode,
+                challenge,
+                feeRate: 1,
+                priorityFee: 330n,
+                gasSatFee: 330n,
+                mldsaSigner: quantumRoot,
+            });
+
+            const signed = await tx.signTransaction();
+
+            expect(signed.ins.length).toBeGreaterThan(0);
+            expect(signed.outs.length).toBeGreaterThan(0);
+            expect(signed.toHex()).toBeTruthy();
+            expect(signed.virtualSize()).toBeGreaterThan(0);
+
+            // Deployment should expose contract address
+            expect(tx.contractAddress).toBeDefined();
+            expect(tx.contractPubKey).toBeDefined();
+        });
+    });
+});

package/tsconfig.base.json

@@ -1,27 +1,43 @@
 {
     "compilerOptions": {
-        "declaration": true,
-        "noImplicitAny": true,
-        "removeComments": true,
-        "suppressImplicitAnyIndexErrors": false,
-        "preserveConstEnums": true,
-        "resolveJsonModule": true,
-        "skipLibCheck": true,
-        "sourceMap": false,
-        "moduleDetection": "force",
-        "experimentalDecorators": true,
-        "lib": ["es6", "es2020", "es2021", "es2022", "esnext", "webworker", "dom", "scripthost"],
         "strict": true,
+        "noImplicitAny": true,
         "strictNullChecks": true,
         "strictFunctionTypes": true,
         "strictBindCallApply": true,
         "strictPropertyInitialization": true,
+        "noImplicitThis": true,
+        "useUnknownInCatchVariables": true,
         "alwaysStrict": true,
-        "moduleResolution": "node",
-        "allowJs": true,
-        "incremental": true,
-        "allowSyntheticDefaultImports": true,
-        "esModuleInterop": true
-    },
-    "include": ["src/**/*.ts", "src/*", "src/**/*.js", "src/*.ts", "src/*.js", "src/*.cjs"]
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "exactOptionalPropertyTypes": true,
+        "noImplicitReturns": true,
+        "noFallthroughCasesInSwitch": true,
+        "noUncheckedIndexedAccess": true,
+        "noImplicitOverride": true,
+        "noPropertyAccessFromIndexSignature": true,
+        "module": "ESNext",
+        "target": "ESNext",
+        "lib": [
+            "ESNext",
+            "DOM",
+            "DOM.Iterable",
+            "DOM.AsyncIterable",
+            "WebWorker",
+            "WebWorker.AsyncIterable",
+            "WebWorker.ImportScripts"
+        ],
+        "isolatedModules": true,
+        "verbatimModuleSyntax": true,
+        "esModuleInterop": true,
+        "resolveJsonModule": true,
+        "declaration": true,
+        "declarationMap": true,
+        "sourceMap": true,
+        "forceConsistentCasingInFileNames": true,
+        "skipLibCheck": true,
+        "moduleDetection": "force",
+        "incremental": true
+    }
 }

package/tsconfig.browser.json

@@ -0,0 +1,15 @@
+{
+    "extends": "./tsconfig.base.json",
+    "compilerOptions": {
+        "module": "ESNext",
+        "moduleResolution": "Bundler",
+        "verbatimModuleSyntax": false,
+        "outDir": "./browser",
+        "baseUrl": ".",
+        "paths": {
+            "@btc-vision/transaction": ["node_modules/@btc-vision/transaction"]
+        }
+    },
+    "include": ["src/**/*.ts"],
+    "exclude": ["node_modules", "test", "**/*.test.ts", "**/*.spec.ts"]
+}

package/tsconfig.json

@@ -1,14 +1,9 @@
 {
     "extends": "./tsconfig.base.json",
     "compilerOptions": {
-        "module": "ESNext",
-        "target": "ES2020",
-        "declaration": true,
-        "outDir": "./build",
-        "moduleResolution": "node",
-        "esModuleInterop": true,
-        "skipLibCheck": true,
-        "allowSyntheticDefaultImports": true
+        "module": "NodeNext",
+        "moduleResolution": "NodeNext",
+        "outDir": "./build"
     },
     "include": ["src/**/*.ts", "test/**/*.ts"],
     "exclude": ["node_modules"]

package/vite.config.browser.ts

@@ -41,15 +41,13 @@ export default defineConfig({
                 chunkFileNames: '[name].js',
                 manualChunks: (id) => {
                     // BTC Vision packages - keep bitcoin separate as it's large and isolated
-                    if (id.includes('@btc-vision/bitcoin') || id.includes('/bitcoin/build/') || id.includes('/bitcoin/src/')) {
+                    if (id.includes('@btc-vision/bitcoin') || id.includes('/bitcoin/build/') || id.includes('/bitcoin/browser/') || id.includes('/bitcoin/src/')) {
                         return 'btc-vision-bitcoin';
                     }
                     if (id.includes('node_modules')) {
                         // Noble crypto - isolated, no circular deps
                         if (id.includes('@noble/curves')) return 'noble-curves';
                         if (id.includes('@noble/hashes')) return 'noble-hashes';
-                        // Validation - isolated
-                        if (id.includes('valibot')) return 'valibot';
                         // Everything else in vendors to avoid circular deps
                         return 'vendors';
                     }
@@ -64,8 +62,8 @@ export default defineConfig({
             vm: resolve(__dirname, 'src/shims/vm-browser.js'),
             stream: 'stream-browserify',
             buffer: 'buffer',
-            // Use source versions for proper tree-shaking (not browser bundles)
-            '@btc-vision/bitcoin': resolve(__dirname, 'node_modules/@btc-vision/bitcoin/build/index.js'),
+            '@btc-vision/bitcoin/workers': resolve(__dirname, 'node_modules/@btc-vision/bitcoin/browser/workers/index.js'),
+            '@btc-vision/bitcoin': resolve(__dirname, 'node_modules/@btc-vision/bitcoin/browser/index.js'),
             '@btc-vision/bip32': resolve(__dirname, 'node_modules/@btc-vision/bip32/src/cjs/index.cjs'),
         },
         mainFields: ['module', 'main'],
@@ -86,6 +84,7 @@ export default defineConfig({
             exclude: ['crypto', 'fs', 'path', 'os', 'http', 'https', 'net', 'tls', 'dns', 'child_process', 'cluster', 'dgram', 'readline', 'repl', 'tty', 'worker_threads', 'perf_hooks', 'inspector', 'async_hooks', 'trace_events', 'v8', 'wasi', 'zlib', 'vm'],
         }),
         dts({
+            tsconfigPath: resolve(__dirname, 'tsconfig.browser.json'),
             outDir: 'browser',
             include: ['src/**/*.ts'],
             exclude: ['src/**/*.test.ts', 'src/**/*.spec.ts'],

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 { playwright } from '@vitest/browser-playwright';
+
+export default defineConfig({
+    resolve: {
+        alias: {
+            crypto: resolve(__dirname, 'src/crypto/crypto-browser.js'),
+            zlib: resolve(__dirname, 'src/shims/zlib-browser.js'),
+            vm: resolve(__dirname, 'src/shims/vm-browser.js'),
+            stream: 'stream-browserify',
+            buffer: 'buffer',
+            '@btc-vision/bitcoin/workers': resolve(__dirname, 'node_modules/@btc-vision/bitcoin/browser/workers/index.js'),
+            '@btc-vision/bitcoin': resolve(__dirname, 'node_modules/@btc-vision/bitcoin/browser/index.js'),
+            '@btc-vision/bip32': resolve(__dirname, 'node_modules/@btc-vision/bip32/src/cjs/index.cjs'),
+            '../build/opnet.js': resolve(__dirname, 'src/opnet.ts'),
+            '../../build/opnet.js': resolve(__dirname, 'src/opnet.ts'),
+        },
+    },
+    plugins: [
+        nodePolyfills({
+            globals: {
+                Buffer: true,
+                global: true,
+                process: true,
+            },
+            exclude: ['crypto', 'fs', 'path', 'os', 'http', 'https', 'net', 'tls', 'dns', 'child_process', 'cluster', 'dgram', 'readline', 'repl', 'tty', 'worker_threads', 'perf_hooks', 'inspector', 'async_hooks', 'trace_events', 'v8', 'wasi', 'zlib', 'vm'],
+        }),
+    ],
+    test: {
+        globals: true,
+        include: [
+            // Browser-compatible existing tests (pure logic, no Node.js crypto)
+            'test/address.test.ts',
+            'test/addressmap.test.ts',
+            'test/address-rotation.test.ts',
+            'test/addressverificator-mldsa.test.ts',
+            'test/binary-reader-writer.test.ts',
+            'test/buffer-helper.test.ts',
+            'test/derivePath.test.ts',
+            'test/disposable.test.ts',
+            'test/fastmap.test.ts',
+            'test/fastmap-setall.test.ts',
+            'test/messagesigner-mldsa.test.ts',
+            'test/messagesigner-schnorr.test.ts',
+            'test/network-awareness.test.ts',
+            'test/oldfastmap.test.ts',
+            'test/transaction-builders.test.ts',
+            // Browser-adapted versions
+            'test/browser/offline-transaction.test.ts',
+            'test/browser/transaction-signing.test.ts',
+            'test/browser/parallel-signing.test.ts',
+        ],
+        exclude: [
+            // Original uses import { createHash } from 'crypto'
+            'test/offline-transaction.test.ts',
+        ],
+        testTimeout: 30000,
+        browser: {
+            enabled: true,
+            provider: playwright(),
+            instances: [{ browser: 'chromium' }],
+            headless: true,
+            screenshotFailures: false,
+        },
+    },
+});

package/vitest.config.ts

@@ -4,7 +4,7 @@ export default defineConfig({
     test: {
         globals: true,
         environment: 'node',
-        include: ['test/**/*.test.ts', 'test/**/*.spec.ts'],
+        include: ['test/*.test.ts', 'test/*.spec.ts'],
         coverage: {
             provider: 'v8',
             reporter: ['text', 'json', 'html'],