@btc-vision/transaction 1.8.0-beta.1 → 1.8.0-beta.4

package/test/derivePath.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { AddressTypes, MLDSASecurityLevel, Mnemonic } from '../build/opnet.js';
+import type { Wallet } from '../build/opnet.js';
 import { networks } from '@btc-vision/bitcoin';
 
 describe('Wallet.derivePath', () => {
@@ -431,8 +432,8 @@ describe('Mnemonic.deriveOPWallet', () => {
             const wallets = mnemonic.deriveMultipleUnisat(AddressTypes.P2TR, 5);
 
             expect(wallets.length).toBe(5);
-            expect(wallets[0].p2tr).toBeDefined();
-            expect(wallets[4].p2tr).toBeDefined();
+            expect((wallets[0] as Wallet).p2tr).toBeDefined();
+            expect((wallets[4] as Wallet).p2tr).toBeDefined();
         });
 
         it('should derive unique addresses for each wallet', () => {
@@ -462,7 +463,7 @@ describe('Mnemonic.deriveOPWallet', () => {
             const wallets = mnemonic.deriveMultipleUnisat(AddressTypes.P2TR, 2, 5);
             const wallet5 = mnemonic.deriveOPWallet(AddressTypes.P2TR, 5);
 
-            expect(wallets[0].p2tr).toBe(wallet5.p2tr);
+            expect((wallets[0] as Wallet).p2tr).toBe(wallet5.p2tr);
         });
     });
 

package/test/disposable.test.ts

@@ -0,0 +1,279 @@
+import { describe, expect, it } from 'vitest';
+import {
+    Address,
+    AddressMap,
+    AddressSet,
+    BinaryWriter,
+    CustomMap,
+    DeterministicMap,
+    DeterministicSet,
+    ExtendedAddressMap,
+    FastMap,
+    FundingTransaction,
+    MLDSASecurityLevel,
+    Mnemonic,
+    EcKeyPair,
+} from '../build/opnet.js';
+import type { UTXO } from '../build/opnet.js';
+import { networks, payments, toHex } from '@btc-vision/bitcoin';
+
+const testMnemonic =
+    'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about';
+const network = networks.regtest;
+
+describe('Disposable - Symbol.dispose implementations', () => {
+    describe('Security-critical: Wallet', () => {
+        it('should zero private key material on dispose', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                network,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+
+            // Verify keys exist before dispose
+            expect(wallet.keypair.privateKey).toBeDefined();
+            expect(wallet.mldsaKeypair.privateKey).toBeDefined();
+
+            const classicalPrivKey = wallet.keypair.privateKey as Uint8Array;
+            const mldsaPrivKey = wallet.mldsaKeypair.privateKey as Uint8Array;
+
+            // Verify non-zero before dispose
+            expect(classicalPrivKey.some((b) => b !== 0)).toBe(true);
+            expect(mldsaPrivKey.some((b) => b !== 0)).toBe(true);
+
+            wallet[Symbol.dispose]();
+
+            // Verify zeroed after dispose
+            expect(classicalPrivKey.every((b) => b === 0)).toBe(true);
+            expect(mldsaPrivKey.every((b) => b === 0)).toBe(true);
+        });
+
+        it('should zero chain code on dispose', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                network,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+
+            const chainCode = wallet.chainCode;
+            wallet[Symbol.dispose]();
+
+            expect(chainCode.every((b) => b === 0)).toBe(true);
+        });
+    });
+
+    describe('Security-critical: Mnemonic', () => {
+        it('should zero seed on dispose', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                network,
+                MLDSASecurityLevel.LEVEL2,
+            );
+
+            // Access seed internally via the getter (returns a copy)
+            // We need to check the internal buffer is zeroed
+            const seedBefore = mnemonic.seed;
+            expect(seedBefore.some((b) => b !== 0)).toBe(true);
+
+            // Get reference to root keys before dispose
+            const classicalRoot = mnemonic.getClassicalRoot();
+            const quantumRoot = mnemonic.getQuantumRoot();
+            const classicalPrivKey = classicalRoot.privateKey;
+            const quantumPrivKey = quantumRoot.privateKey;
+
+            expect(classicalPrivKey).toBeDefined();
+            expect(quantumPrivKey).toBeDefined();
+
+            mnemonic[Symbol.dispose]();
+
+            // After dispose, the internal seed should be zeroed
+            // The getter returns a copy, so check the root keys
+            expect((classicalPrivKey as Uint8Array).every((b) => b === 0)).toBe(true);
+            expect((quantumPrivKey as Uint8Array).every((b) => b === 0)).toBe(true);
+        });
+    });
+
+    describe('Security-critical: Address', () => {
+        it('should zero base Uint8Array on dispose', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                network,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+            const addr = wallet.address;
+
+            // Verify non-zero before
+            expect(addr.some((b) => b !== 0)).toBe(true);
+
+            addr[Symbol.dispose]();
+
+            // Verify zeroed after dispose
+            expect(addr.every((b) => b === 0)).toBe(true);
+        });
+    });
+
+    describe('Collections: AddressMap', () => {
+        it('should clear all entries on dispose', () => {
+            const map = new AddressMap<number>();
+            const addr1 = new Address(Buffer.alloc(32, 0x01));
+            const addr2 = new Address(Buffer.alloc(32, 0x02));
+
+            map.set(addr1, 1);
+            map.set(addr2, 2);
+            expect(map.size).toBe(2);
+
+            map[Symbol.dispose]();
+
+            expect(map.size).toBe(0);
+        });
+    });
+
+    describe('Collections: ExtendedAddressMap', () => {
+        it('should clear all entries on dispose', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                network,
+                MLDSASecurityLevel.LEVEL2,
+            );
+
+            const wallet1 = mnemonic.derive(0);
+            const wallet2 = mnemonic.derive(1);
+
+            const map = new ExtendedAddressMap<number>();
+            map.set(wallet1.address, 10);
+            map.set(wallet2.address, 20);
+            expect(map.size).toBe(2);
+
+            map[Symbol.dispose]();
+
+            expect(map.size).toBe(0);
+        });
+    });
+
+    describe('Collections: FastMap', () => {
+        it('should clear all entries on dispose', () => {
+            const map = new FastMap<string, number>();
+            map.set('a', 1);
+            map.set('b', 2);
+            map.set('c', 3);
+            expect(map.size).toBe(3);
+
+            map[Symbol.dispose]();
+
+            expect(map.size).toBe(0);
+        });
+    });
+
+    describe('Collections: DeterministicMap', () => {
+        it('should clear all entries on dispose', () => {
+            const map = new DeterministicMap<number, string>((a, b) => a - b);
+            map.set(3, 'three');
+            map.set(1, 'one');
+            map.set(2, 'two');
+            expect(map.size).toBe(3);
+
+            map[Symbol.dispose]();
+
+            expect(map.size).toBe(0);
+        });
+    });
+
+    describe('Collections: DeterministicSet', () => {
+        it('should clear all elements on dispose', () => {
+            const set = new DeterministicSet<number>((a, b) => a - b);
+            set.add(1);
+            set.add(2);
+            set.add(3);
+            expect(set.size).toBe(3);
+
+            set[Symbol.dispose]();
+
+            expect(set.size).toBe(0);
+        });
+    });
+
+    describe('Collections: AddressSet', () => {
+        it('should clear all entries on dispose', () => {
+            const addr1 = new Address(Buffer.alloc(32, 0x01));
+            const addr2 = new Address(Buffer.alloc(32, 0x02));
+
+            const set = new AddressSet([addr1, addr2]);
+            expect(set.size).toBe(2);
+
+            set[Symbol.dispose]();
+
+            expect(set.size).toBe(0);
+        });
+    });
+
+    describe('Collections: CustomMap', () => {
+        it('should clear all entries on dispose', () => {
+            const map = new CustomMap<string, number>();
+            map.set('foo', 1);
+            map.set('bar', 2);
+            expect(map.size).toBe(2);
+
+            map[Symbol.dispose]();
+
+            expect(map.size).toBe(0);
+        });
+    });
+
+    describe('Buffers: BinaryWriter', () => {
+        it('should reset buffer on dispose', () => {
+            const writer = new BinaryWriter();
+            writer.writeU32(0xdeadbeef);
+            writer.writeU64(123456789n);
+
+            expect(writer.getOffset()).toBeGreaterThan(0);
+
+            writer[Symbol.dispose]();
+
+            expect(writer.getOffset()).toBe(0);
+        });
+    });
+
+    describe('Transaction state: TransactionBuilder (via FundingTransaction)', () => {
+        it('should clear inputs, outputs, and utxos on dispose', () => {
+            const signer = EcKeyPair.generateRandomKeyPair(network);
+            const taprootAddress = EcKeyPair.getTaprootAddress(signer, network);
+            const p2tr = payments.p2tr({ address: taprootAddress, network });
+
+            const utxo: UTXO = {
+                transactionId: '0'.repeat(64),
+                outputIndex: 0,
+                value: 100_000n,
+                scriptPubKey: {
+                    hex: toHex(p2tr.output as Uint8Array),
+                    address: taprootAddress,
+                },
+            };
+
+            const tx = new FundingTransaction({
+                signer,
+                network,
+                utxos: [utxo],
+                to: taprootAddress,
+                amount: 50_000n,
+                feeRate: 1,
+                priorityFee: 0n,
+                gasSatFee: 0n,
+                mldsaSigner: null,
+            });
+
+            tx[Symbol.dispose]();
+
+            // After dispose, getInputs/getOutputs should be empty
+            expect(tx.getInputs().length).toBe(0);
+            expect(tx.getOutputs().length).toBe(0);
+        });
+    });
+});

package/test/fastmap-setall.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { FastBigIntMap } from './old/FastBigIntMap.js';
-import { FastMap } from '../src';
+import { FastMap } from '../src/index.js';
 
 describe('setAll bug', () => {
     describe('FastBigIntMap (original - correct behavior)', () => {

package/test/fastmap.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from 'vitest';
-import { FastMap } from '../src';
+import { FastMap } from '../src/index.js';
 
 describe('FastMap<bigint, bigint> - Comprehensive Tests', () => {
     describe('Constructor', () => {
@@ -634,7 +634,7 @@ describe('FastMap<bigint, bigint> - Comprehensive Tests', () => {
             map.set(2n, 200n);
 
             const order: bigint[] = [];
-            map.forEach((value, key) => {
+            map.forEach((_value, key) => {
                 order.push(key);
             });
 
@@ -668,7 +668,7 @@ describe('FastMap<bigint, bigint> - Comprehensive Tests', () => {
             const map = new FastMap<bigint, bigint>([[1n, 100n]]);
             let receivedMap: FastMap<bigint, bigint> | null = null;
 
-            map.forEach((value, key, m) => {
+            map.forEach((_value, _key, m) => {
                 receivedMap = m;
             });
 

package/test/messagesigner-mldsa.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { MessageSigner, MLDSASecurityLevel, Mnemonic } from '../build/opnet.js';
-import { networks } from '@btc-vision/bitcoin';
+import { networks, toHex } from '@btc-vision/bitcoin';
 
 describe('MessageSigner ML-DSA', () => {
     const testMnemonic =
@@ -155,7 +155,7 @@ describe('MessageSigner ML-DSA', () => {
 
             // Verify it matches the SHA-256 hash
             const expectedHash = MessageSigner.sha256(Buffer.from(message, 'utf-8'));
-            expect(Buffer.from(signed.message).toString('hex')).toBe(expectedHash.toString('hex'));
+            expect(toHex(signed.message)).toBe(toHex(expectedHash));
         });
     });
 
@@ -807,7 +807,7 @@ describe('MessageSigner ML-DSA', () => {
 
             // Corrupt the signature
             const corruptedSignature = Buffer.from(signed.signature);
-            corruptedSignature[0] ^= 0xff;
+            corruptedSignature[0] = (corruptedSignature[0] as number) ^ 0xff;
 
             const isValidLegacyPublicKey = MessageSigner.verifyMLDSASignature(
                 wallet.mldsaKeypair,

package/test/messagesigner-schnorr.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { MessageSigner, MLDSASecurityLevel, Mnemonic } from '../build/opnet.js';
-import { networks } from '@btc-vision/bitcoin';
+import { networks, toHex } from '@btc-vision/bitcoin';
 
 describe('MessageSigner Schnorr', () => {
     const testMnemonic =
@@ -11,7 +11,7 @@ describe('MessageSigner Schnorr', () => {
             const message = 'Hello, OPNet!';
             const hash = MessageSigner.sha256(Buffer.from(message, 'utf-8'));
 
-            expect(hash).toBeInstanceOf(Buffer);
+            expect(hash).toBeInstanceOf(Uint8Array);
             expect(hash.length).toBe(32);
         });
 
@@ -19,7 +19,7 @@ describe('MessageSigner Schnorr', () => {
             const message = Buffer.from('Hello, Buffer!', 'utf-8');
             const hash = MessageSigner.sha256(message);
 
-            expect(hash).toBeInstanceOf(Buffer);
+            expect(hash).toBeInstanceOf(Uint8Array);
             expect(hash.length).toBe(32);
         });
 
@@ -27,7 +27,7 @@ describe('MessageSigner Schnorr', () => {
             const message = new Uint8Array([1, 2, 3, 4, 5]);
             const hash = MessageSigner.sha256(message);
 
-            expect(hash).toBeInstanceOf(Buffer);
+            expect(hash).toBeInstanceOf(Uint8Array);
             expect(hash.length).toBe(32);
         });
 
@@ -36,7 +36,7 @@ describe('MessageSigner Schnorr', () => {
             const hash1 = MessageSigner.sha256(Buffer.from(message, 'utf-8'));
             const hash2 = MessageSigner.sha256(Buffer.from(message, 'utf-8'));
 
-            expect(hash1.toString('hex')).toBe(hash2.toString('hex'));
+            expect(toHex(hash1)).toBe(toHex(hash2));
         });
 
         it('should produce different hashes for different inputs', () => {
@@ -45,14 +45,14 @@ describe('MessageSigner Schnorr', () => {
             const hash1 = MessageSigner.sha256(Buffer.from(message1, 'utf-8'));
             const hash2 = MessageSigner.sha256(Buffer.from(message2, 'utf-8'));
 
-            expect(hash1.toString('hex')).not.toBe(hash2.toString('hex'));
+            expect(toHex(hash1)).not.toBe(toHex(hash2));
         });
 
         it('should hash empty message', () => {
             const message = Buffer.alloc(0);
             const hash = MessageSigner.sha256(message);
 
-            expect(hash).toBeInstanceOf(Buffer);
+            expect(hash).toBeInstanceOf(Uint8Array);
             expect(hash.length).toBe(32);
         });
     });
@@ -318,7 +318,7 @@ describe('MessageSigner Schnorr', () => {
             const signed = MessageSigner.signMessage(wallet.keypair, message);
 
             const expectedHash = MessageSigner.sha256(Buffer.from(message, 'utf-8'));
-            expect(Buffer.from(signed.message).toString('hex')).toBe(expectedHash.toString('hex'));
+            expect(toHex(signed.message)).toBe(toHex(expectedHash));
         });
     });
 
@@ -530,7 +530,7 @@ describe('MessageSigner Schnorr', () => {
             const signed = MessageSigner.signMessage(wallet.keypair, message);
 
             const corruptedSignature = Buffer.from(signed.signature);
-            corruptedSignature[0] ^= 0xff;
+            corruptedSignature[0] = (corruptedSignature[0] as number) ^ 0xff;
 
             const isValidLegacyPublicKey = MessageSigner.verifySignature(
                 wallet.keypair.publicKey,