@btc-vision/transaction 1.7.6 → 1.7.10

package/test/addressverificator-mldsa.test.ts

@@ -204,9 +204,12 @@ describe('AddressVerificator ML-DSA Support', () => {
             const wallet = mnemonic.derive(0);
             const p2opAddress = wallet.address.p2op(networks.bitcoin);
 
-            const isValid = AddressVerificator.isValidP2OPAddress(p2opAddress, networks.bitcoin);
+            const isValidLegacyPublicKey = AddressVerificator.isValidP2OPAddress(
+                p2opAddress,
+                networks.bitcoin,
+            );
 
-            expect(isValid).toBe(true);
+            expect(isValidLegacyPublicKey).toBe(true);
         });
 
         it('should validate testnet P2OP address', () => {
@@ -219,9 +222,12 @@ describe('AddressVerificator ML-DSA Support', () => {
             const wallet = mnemonic.derive(0);
             const p2opAddress = wallet.address.p2op(networks.testnet);
 
-            const isValid = AddressVerificator.isValidP2OPAddress(p2opAddress, networks.testnet);
+            const isValidLegacyPublicKey = AddressVerificator.isValidP2OPAddress(
+                p2opAddress,
+                networks.testnet,
+            );
 
-            expect(isValid).toBe(true);
+            expect(isValidLegacyPublicKey).toBe(true);
         });
 
         it('should validate regtest P2OP address', () => {
@@ -234,9 +240,12 @@ describe('AddressVerificator ML-DSA Support', () => {
             const wallet = mnemonic.derive(0);
             const p2opAddress = wallet.address.p2op(networks.regtest);
 
-            const isValid = AddressVerificator.isValidP2OPAddress(p2opAddress, networks.regtest);
+            const isValidLegacyPublicKey = AddressVerificator.isValidP2OPAddress(
+                p2opAddress,
+                networks.regtest,
+            );
 
-            expect(isValid).toBe(true);
+            expect(isValidLegacyPublicKey).toBe(true);
         });
 
         it('should reject P2TR address as P2OP', () => {
@@ -249,9 +258,12 @@ describe('AddressVerificator ML-DSA Support', () => {
             const wallet = mnemonic.derive(0);
             const p2trAddress = wallet.p2tr;
 
-            const isValid = AddressVerificator.isValidP2OPAddress(p2trAddress, networks.bitcoin);
+            const isValidLegacyPublicKey = AddressVerificator.isValidP2OPAddress(
+                p2trAddress,
+                networks.bitcoin,
+            );
 
-            expect(isValid).toBe(false);
+            expect(isValidLegacyPublicKey).toBe(false);
         });
 
         it('should reject P2WPKH address as P2OP', () => {
@@ -264,22 +276,31 @@ describe('AddressVerificator ML-DSA Support', () => {
             const wallet = mnemonic.derive(0);
             const p2wpkhAddress = wallet.p2wpkh;
 
-            const isValid = AddressVerificator.isValidP2OPAddress(p2wpkhAddress, networks.bitcoin);
+            const isValidLegacyPublicKey = AddressVerificator.isValidP2OPAddress(
+                p2wpkhAddress,
+                networks.bitcoin,
+            );
 
-            expect(isValid).toBe(false);
+            expect(isValidLegacyPublicKey).toBe(false);
         });
 
         it('should reject invalid address string', () => {
             const invalidAddress = 'not a valid address';
-            const isValid = AddressVerificator.isValidP2OPAddress(invalidAddress, networks.bitcoin);
+            const isValidLegacyPublicKey = AddressVerificator.isValidP2OPAddress(
+                invalidAddress,
+                networks.bitcoin,
+            );
 
-            expect(isValid).toBe(false);
+            expect(isValidLegacyPublicKey).toBe(false);
         });
 
         it('should reject empty string', () => {
-            const isValid = AddressVerificator.isValidP2OPAddress('', networks.bitcoin);
+            const isValidLegacyPublicKey = AddressVerificator.isValidP2OPAddress(
+                '',
+                networks.bitcoin,
+            );
 
-            expect(isValid).toBe(false);
+            expect(isValidLegacyPublicKey).toBe(false);
         });
 
         it('should reject address on wrong network', () => {
@@ -293,9 +314,12 @@ describe('AddressVerificator ML-DSA Support', () => {
             const p2opAddress = wallet.address.p2op(networks.bitcoin);
 
             // Try to validate mainnet address on testnet
-            const isValid = AddressVerificator.isValidP2OPAddress(p2opAddress, networks.testnet);
+            const isValidLegacyPublicKey = AddressVerificator.isValidP2OPAddress(
+                p2opAddress,
+                networks.testnet,
+            );
 
-            expect(isValid).toBe(false);
+            expect(isValidLegacyPublicKey).toBe(false);
         });
     });
 

package/test/fastmap-setall.test.ts

@@ -0,0 +1,143 @@
+import { describe, expect, it } from 'vitest';
+import { FastBigIntMap } from './old/FastBigIntMap.js';
+import { FastMap } from '../src';
+
+describe('setAll bug', () => {
+    describe('FastBigIntMap (original - correct behavior)', () => {
+        it('should replace all entries, not merge', () => {
+            const map1 = new FastBigIntMap([
+                [1n, 100n],
+                [2n, 200n],
+            ]);
+
+            const map2 = new FastBigIntMap([
+                [3n, 300n],
+                [4n, 400n],
+            ]);
+
+            // setAll should REPLACE, not merge
+            map2.setAll(map1);
+
+            // Should have entries from map1 only
+            expect(map2.size).toBe(2);
+            expect(map2.get(1n)).toBe(100n);
+            expect(map2.get(2n)).toBe(200n);
+
+            // Old entries should be GONE
+            expect(map2.has(3n)).toBe(false);
+            expect(map2.has(4n)).toBe(false);
+            expect(map2.get(3n)).toBeUndefined();
+            expect(map2.get(4n)).toBeUndefined();
+        });
+    });
+
+    describe('FastMap (replacement - should match original behavior)', () => {
+        it('should replace all entries, not merge', () => {
+            const map1 = new FastMap<bigint, bigint>([
+                [1n, 100n],
+                [2n, 200n],
+            ]);
+
+            const map2 = new FastMap<bigint, bigint>([
+                [3n, 300n],
+                [4n, 400n],
+            ]);
+
+            // setAll should REPLACE, not merge
+            map2.setAll(map1);
+
+            // Should have entries from map1 only
+            expect(map2.size).toBe(2);
+            expect(map2.get(1n)).toBe(100n);
+            expect(map2.get(2n)).toBe(200n);
+
+            // Old entries should be GONE
+            expect(map2.has(3n)).toBe(false);
+            expect(map2.has(4n)).toBe(false);
+            expect(map2.get(3n)).toBeUndefined();
+            expect(map2.get(4n)).toBeUndefined();
+        });
+
+        it('should not leak old keys in iteration', () => {
+            const map1 = new FastMap<bigint, bigint>([[1n, 100n]]);
+
+            const map2 = new FastMap<bigint, bigint>([
+                [2n, 200n],
+                [3n, 300n],
+            ]);
+
+            map2.setAll(map1);
+
+            const keys = [...map2.keys()];
+            const values = [...map2.values()];
+            const entries = [...map2.entries()];
+
+            expect(keys).toEqual([1n]);
+            expect(values).toEqual([100n]);
+            expect(entries).toEqual([[1n, 100n]]);
+        });
+
+        it('should handle overlapping keys correctly', () => {
+            const map1 = new FastMap<bigint, bigint>([
+                [1n, 100n],
+                [2n, 200n],
+            ]);
+
+            const map2 = new FastMap<bigint, bigint>([
+                [2n, 999n], // overlapping key
+                [3n, 300n],
+            ]);
+
+            map2.setAll(map1);
+
+            // Should have map1's values, including overwriting the overlapping key
+            expect(map2.size).toBe(2);
+            expect(map2.get(1n)).toBe(100n);
+            expect(map2.get(2n)).toBe(200n); // map1's value, not 999n
+
+            // 3n should be gone
+            expect(map2.has(3n)).toBe(false);
+        });
+    });
+
+    describe('behavior parity', () => {
+        it('FastMap.setAll should behave identically to FastBigIntMap.setAll', () => {
+            // Setup identical scenarios
+            const oldMap1 = new FastBigIntMap([
+                [1n, 10n],
+                [2n, 20n],
+            ]);
+            const oldMap2 = new FastBigIntMap([
+                [3n, 30n],
+                [4n, 40n],
+                [5n, 50n],
+            ]);
+
+            const newMap1 = new FastMap<bigint, bigint>([
+                [1n, 10n],
+                [2n, 20n],
+            ]);
+            const newMap2 = new FastMap<bigint, bigint>([
+                [3n, 30n],
+                [4n, 40n],
+                [5n, 50n],
+            ]);
+
+            // Perform setAll on both
+            oldMap2.setAll(oldMap1);
+            newMap2.setAll(newMap1);
+
+            // Compare sizes
+            expect(newMap2.size).toBe(oldMap2.size);
+
+            // Compare keys
+            expect([...newMap2.keys()]).toEqual([...oldMap2.keys()]);
+
+            // Compare values
+            expect([...newMap2.values()]).toEqual([...oldMap2.values()]);
+
+            // Compare entries
+            expect([...newMap2.entries()]).toEqual([...oldMap2.entries()]);
+        });
+    });
+});