@btc-vision/transaction 1.6.19 → 1.7.1

package/test/network-awareness.test.ts

@@ -0,0 +1,163 @@
+import { describe, expect, it } from 'vitest';
+import { MLDSASecurityLevel, Mnemonic } from '../build/opnet.js';
+import { networks } from '@btc-vision/bitcoin';
+
+describe('Network Awareness', () => {
+    const testMnemonic =
+        'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about';
+
+    describe('Mnemonic network awareness', () => {
+        it('should derive different classical keys for different networks', () => {
+            const mnemonicMainnet = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const mnemonicTestnet = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.testnet,
+                MLDSASecurityLevel.LEVEL2,
+            );
+
+            const walletMainnet = mnemonicMainnet.derive(0);
+            const walletTestnet = mnemonicTestnet.derive(0);
+
+            // Classical private keys should be different
+            expect(walletMainnet.toPrivateKeyHex()).not.toBe(walletTestnet.toPrivateKeyHex());
+        });
+
+        it('should derive different quantum keys for different networks', () => {
+            const mnemonicMainnet = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const mnemonicTestnet = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.testnet,
+                MLDSASecurityLevel.LEVEL2,
+            );
+
+            const walletMainnet = mnemonicMainnet.derive(0);
+            const walletTestnet = mnemonicTestnet.derive(0);
+
+            // Quantum private keys should be different
+            expect(walletMainnet.quantumPrivateKeyHex).not.toBe(walletTestnet.quantumPrivateKeyHex);
+        });
+
+        it('should generate correct address prefixes for mainnet', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+
+            expect(wallet.p2tr).toMatch(/^bc1/);
+            expect(wallet.p2wpkh).toMatch(/^bc1/);
+        });
+
+        it('should generate correct address prefixes for testnet', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.testnet,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+
+            expect(wallet.p2tr).toMatch(/^tb1/);
+            expect(wallet.p2wpkh).toMatch(/^tb1/);
+        });
+
+        it('should generate correct address prefixes for regtest', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.regtest,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+
+            expect(wallet.p2tr).toMatch(/^bcrt1/);
+            expect(wallet.p2wpkh).toMatch(/^bcrt1/);
+        });
+    });
+
+    describe('Testnet and regtest parity', () => {
+        it('should derive same keys for testnet and regtest (BIP32 behavior)', () => {
+            const mnemonicTestnet = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.testnet,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const mnemonicRegtest = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.regtest,
+                MLDSASecurityLevel.LEVEL2,
+            );
+
+            const walletTestnet = mnemonicTestnet.derive(0);
+            const walletRegtest = mnemonicRegtest.derive(0);
+
+            // Testnet and regtest should have same private keys (BIP32 uses same version bytes)
+            expect(walletTestnet.toPrivateKeyHex()).toBe(walletRegtest.toPrivateKeyHex());
+            expect(walletTestnet.quantumPrivateKeyHex).toBe(walletRegtest.quantumPrivateKeyHex);
+
+            // But addresses should differ due to different prefixes
+            expect(walletTestnet.p2tr).not.toBe(walletRegtest.p2tr);
+            expect(walletTestnet.p2wpkh).not.toBe(walletRegtest.p2wpkh);
+        });
+    });
+
+    describe('Network preservation through derivation', () => {
+        it('should preserve mainnet through derivePath', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const parent = mnemonic.derive(0);
+            const child = parent.derivePath('m/0');
+
+            expect(child.network.bech32).toBe('bc');
+            expect(child.p2tr).toMatch(/^bc1/);
+        });
+
+        it('should preserve testnet through derivePath', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.testnet,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const parent = mnemonic.derive(0);
+            const child = parent.derivePath('m/0');
+
+            expect(child.network.bech32).toBe('tb');
+            expect(child.p2tr).toMatch(/^tb1/);
+        });
+
+        it('should preserve regtest through derivePath', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.regtest,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const parent = mnemonic.derive(0);
+            const child = parent.derivePath('m/0');
+
+            expect(child.network.bech32).toBe('bcrt');
+            expect(child.p2tr).toMatch(/^bcrt1/);
+        });
+    });
+});

package/tsconfig.json

@@ -10,6 +10,6 @@
         "skipLibCheck": true,
         "allowSyntheticDefaultImports": true
     },
-    "include": ["src/**/*.ts"],
+    "include": ["src/**/*.ts", "test/**/*.ts"],
     "exclude": ["node_modules"]
 }

package/vitest.config.ts

@@ -0,0 +1,21 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: 'node',
+        include: ['test/**/*.test.ts', 'test/**/*.spec.ts'],
+        coverage: {
+            provider: 'v8',
+            reporter: ['text', 'json', 'html'],
+            exclude: [
+                'node_modules/',
+                'build/',
+                'test/',
+                '**/*.d.ts',
+                '**/*.config.*',
+                '**/mockData',
+            ],
+        },
+    },
+});

package/browser/_version.d.ts

@@ -1 +0,0 @@
-export declare const version = "1.6.19";

package/browser/keypair/Wallet.d.ts

@@ -1,30 +0,0 @@
-import { ECPairInterface } from 'ecpair';
-import { Network } from '@btc-vision/bitcoin';
-import { Address } from './Address.js';
-import { IP2WSHAddress } from '../transaction/mineable/IP2WSHAddress.js';
-export declare class Wallet {
-    readonly network: Network;
-    private readonly _keypair;
-    private readonly _p2wpkh;
-    private readonly _p2tr;
-    private readonly _p2wda;
-    private readonly _legacy;
-    private readonly _segwitLegacy;
-    private readonly _bufferPubKey;
-    private readonly _tweakedKey;
-    private readonly _address;
-    constructor(privateKeyOrWif: string, network?: Network);
-    get address(): Address;
-    get tweakedPubKeyKey(): Buffer;
-    get keypair(): ECPairInterface;
-    get p2wpkh(): string;
-    get p2tr(): string;
-    get p2wda(): IP2WSHAddress;
-    get legacy(): string;
-    get addresses(): string[];
-    get segwitLegacy(): string;
-    get publicKey(): Buffer;
-    get xOnly(): Buffer;
-    static fromWif(wif: string, network?: Network): Wallet;
-    static new(network?: Network): Wallet;
-}