@btc-vision/transaction 1.7.31 → 1.8.0-alpha.1

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.7.31",
+    "version": "1.8.0-alpha.1",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {
@@ -148,32 +148,32 @@
         "prebuild": "npm run check:circular"
     },
     "devDependencies": {
-        "@babel/core": "^7.28.5",
+        "@babel/core": "^7.28.6",
         "@babel/plugin-proposal-class-properties": "^7.18.6",
         "@babel/plugin-transform-runtime": "^7.28.5",
-        "@babel/preset-env": "^7.28.5",
+        "@babel/preset-env": "^7.28.6",
         "@babel/preset-flow": "^7.27.1",
         "@babel/preset-react": "^7.28.5",
         "@babel/preset-typescript": "^7.28.5",
         "@rollup/plugin-typescript": "^12.3.0",
-        "@types/node": "^24.10.0",
+        "@types/node": "^25.0.9",
         "@types/sha.js": "^2.4.4",
         "@vitejs/plugin-legacy": "^7.2.1",
-        "@vitest/ui": "^4.0.8",
-        "eslint": "^9.39.1",
+        "@vitest/ui": "^4.0.17",
+        "eslint": "^9.39.2",
         "https-browserify": "^1.0.0",
         "madge": "^8.0.0",
         "os-browserify": "^0.3.0",
-        "prettier": "^3.6.2",
+        "prettier": "^3.8.0",
         "stream-browserify": "^3.0.0",
         "stream-http": "^3.2.0",
         "tslib": "^2.8.1",
-        "typedoc": "^0.28.14",
-        "typescript-eslint": "^8.46.3",
-        "vite": "^7.3.0",
+        "typedoc": "^0.28.16",
+        "typescript-eslint": "^8.53.1",
+        "vite": "^7.3.1",
         "vite-plugin-dts": "^4.5.4",
-        "vite-plugin-node-polyfills": "^0.24.0",
-        "vitest": "^4.0.8"
+        "vite-plugin-node-polyfills": "^0.25.0",
+        "vitest": "^4.0.17"
     },
     "dependencies": {
         "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
@@ -183,7 +183,7 @@
         "@btc-vision/bitcoin-rpc": "^1.0.6",
         "@btc-vision/logger": "^1.0.8",
         "@btc-vision/post-quantum": "^0.5.3",
-        "@eslint/js": "^9.39.1",
+        "@eslint/js": "^9.39.2",
         "@noble/curves": "^1.9.7",
         "@noble/secp256k1": "^3.0.0",
         "assert": "^2.1.0",

package/src/deterministic/ExtendedAddressMap.ts

@@ -0,0 +1,83 @@
+import { Address } from '../keypair/Address.js';
+import { FastMap } from './FastMap.js';
+
+export class ExtendedAddressMap<V> {
+    private items: FastMap<bigint, V>;
+
+    constructor(iterable?: ReadonlyArray<readonly [Address, V]> | null) {
+        this.items = new FastMap();
+
+        if (iterable) {
+            for (const [key, value] of iterable) {
+                this.set(key, value);
+            }
+        }
+    }
+
+    public get size(): number {
+        return this.items.size;
+    }
+
+    public set(key: Address, value: V): this {
+        const keyBigInt = key.tweakedToBigInt();
+        this.items.set(keyBigInt, value);
+
+        return this;
+    }
+
+    public get(key: Address): V | undefined {
+        return this.items.get(key.tweakedToBigInt());
+    }
+
+    public has(key: Address): boolean {
+        return this.items.has(key.tweakedToBigInt());
+    }
+
+    public delete(key: Address): boolean {
+        const keyBigInt = key.tweakedToBigInt();
+        return this.items.delete(keyBigInt);
+    }
+
+    public clear(): void {
+        this.items.clear();
+    }
+
+    public indexOf(address: Address): number {
+        return this.items.indexOf(address.tweakedToBigInt());
+    }
+
+    /**
+     * WARNING, THIS RETURN NEW COPY OF THE KEYS
+     */
+    *entries(): IterableIterator<[Address, V]> {
+        for (const [keyBigInt, value] of this.items.entries()) {
+            yield [Address.fromBigInt(keyBigInt), value];
+        }
+    }
+
+    *keys(): IterableIterator<Address> {
+        for (const keyBigInt of this.items.keys()) {
+            yield Address.fromBigInt(keyBigInt);
+        }
+    }
+
+    *values(): IterableIterator<V> {
+        for (const value of this.items.values()) {
+            yield value;
+        }
+    }
+
+    forEach(
+        callback: (value: V, key: Address, map: ExtendedAddressMap<V>) => void,
+        thisArg?: unknown,
+    ): void {
+        for (const [keyBigInt, value] of this.items.entries()) {
+            const key = Address.fromBigInt(0n, keyBigInt);
+            callback.call(thisArg, value, key, this);
+        }
+    }
+
+    *[Symbol.iterator](): IterableIterator<[Address, V]> {
+        yield* this.entries();
+    }
+}

package/src/keypair/Address.ts

@@ -32,6 +32,7 @@ export class Address extends Uint8Array {
     #p2wda: IP2WSHAddress | undefined;
     #mldsaPublicKey: Uint8Array | undefined;
     #cachedBigInt: bigint | undefined;
+    #cachedBigIntTweaked: bigint | undefined;
     #cachedUint64Array: [bigint, bigint, bigint, bigint] | undefined;
     #originalMDLSAPublicKey: Uint8Array | undefined;
     #mldsaLevel: MLDSASecurityLevel | undefined;
@@ -192,6 +193,7 @@ export class Address extends Uint8Array {
      * This is the inverse operation of toBigInt().
      *
      * @param {bigint} value - The 256-bit unsigned integer to convert (0 to 2^256-1)
+     * @param {bigint} [tweakedValue] - Optional tweaked public key as a 256-bit unsigned integer
      * @returns {Address} A new Address instance containing the converted value
      *
      * @throws {RangeError} If the value is negative or exceeds 2^256-1
@@ -203,16 +205,11 @@ export class Address extends Uint8Array {
      * console.log(address.toHex()); // 0x0000000000000000000000000000000000000000000000000000abc123...
      * ```
      */
-    public static fromBigInt(value: bigint): Address {
-        const buffer = new Uint8Array(32);
-        const view = new DataView(buffer.buffer);
+    public static fromBigInt(value: bigint, tweakedValue?: bigint): Address {
+        const address = Address.bigintToUint8Array(value);
+        const legacyAddress = tweakedValue ? Address.bigintToUint8Array(tweakedValue) : undefined;
 
-        view.setBigUint64(0, (value >> 192n) & 0xffffffffffffffffn, false);
-        view.setBigUint64(8, (value >> 128n) & 0xffffffffffffffffn, false);
-        view.setBigUint64(16, (value >> 64n) & 0xffffffffffffffffn, false);
-        view.setBigUint64(24, value & 0xffffffffffffffffn, false);
-
-        return new Address(buffer);
+        return new Address(address, legacyAddress);
     }
 
     /**
@@ -253,6 +250,18 @@ export class Address extends Uint8Array {
         return new Address(buffer);
     }
 
+    private static bigintToUint8Array(value: bigint): Uint8Array {
+        const buffer = new Uint8Array(32);
+        const view = new DataView(buffer.buffer);
+
+        view.setBigUint64(0, (value >> 192n) & 0xffffffffffffffffn, false);
+        view.setBigUint64(8, (value >> 128n) & 0xffffffffffffffffn, false);
+        view.setBigUint64(16, (value >> 64n) & 0xffffffffffffffffn, false);
+        view.setBigUint64(24, value & 0xffffffffffffffffn, false);
+
+        return buffer;
+    }
+
     /**
      * Converts the address to four 64-bit unsigned integers.
      *
@@ -419,6 +428,41 @@ export class Address extends Uint8Array {
         return this.#cachedBigInt;
     }
 
+    /**
+     * Converts the tweaked public key to a BigInt representation.
+     *
+     * This method uses an optimized DataView approach to read the 32-byte address
+     * as four 64-bit big-endian unsigned integers, then combines them using bitwise
+     * operations. This is approximately 10-20x faster than string-based conversion.
+     *
+     * @returns {bigint} The address as a 256-bit unsigned integer
+     *
+     * @example
+     * ```typescript
+     * const address = Address.fromString('0x0123456789abcdef...', '0xtweaked...');
+     * const bigIntValue = address.tweakedToBigInt();
+     * console.log(bigIntValue); // 123456789...n
+     * ```
+     */
+    public tweakedToBigInt(): bigint {
+        if (!this.legacyPublicKey) {
+            throw new Error('Legacy public key not set');
+        }
+
+        if (this.#cachedBigIntTweaked !== undefined) {
+            return this.#cachedBigIntTweaked;
+        }
+
+        const view = new DataView(this.legacyPublicKey.buffer, this.byteOffset, 32);
+        this.#cachedBigIntTweaked =
+            (view.getBigUint64(0, false) << 192n) |
+            (view.getBigUint64(8, false) << 128n) |
+            (view.getBigUint64(16, false) << 64n) |
+            view.getBigUint64(24, false);
+
+        return this.#cachedBigIntTweaked;
+    }
+
     public equals(a: Address): boolean {
         const b: Address = this as Address;
 

package/src/mnemonic/Mnemonic.ts

@@ -263,7 +263,7 @@ export class Mnemonic {
      * @param isChange - Whether this is a change address (default: false)
      * @returns A Wallet instance with both classical and quantum keys
      */
-    public deriveUnisat(
+    public deriveOPWallet(
         addressType: AddressTypes = AddressTypes.P2TR,
         index: number = 0,
         account: number = 0,
@@ -338,7 +338,7 @@ export class Mnemonic {
         const wallets: Wallet[] = [];
 
         for (let i = 0; i < count; i++) {
-            wallets.push(this.deriveUnisat(addressType, startIndex + i, account, isChange));
+            wallets.push(this.deriveOPWallet(addressType, startIndex + i, account, isChange));
         }
 
         return wallets;

package/src/opnet.ts

@@ -125,6 +125,7 @@ export * from './abi/ABICoder.js';
 export * from './buffer/BinaryReader.js';
 export * from './buffer/BinaryWriter.js';
 export * from './deterministic/AddressMap.js';
+export * from './deterministic/ExtendedAddressMap.js';
 export * from './deterministic/AddressSet.js';
 export * from './deterministic/DeterministicMap.js';
 export * from './deterministic/DeterministicSet.js';

package/src/transaction/browser/WalletNetworks.ts

@@ -1,7 +1,7 @@
 export enum WalletNetworks {
-    testnet = 'testnet',
-    mainnet = 'mainnet',
-    regtest = 'regtest',
+    Mainnet = 'mainnet',
+    Testnet = 'testnet',
+    Regtest = 'regtest',
 }
 
 export enum UnisatChainType {

package/src/transaction/browser/extensions/UnisatSigner.ts

@@ -107,13 +107,13 @@ export class UnisatSigner extends CustomKeypair {
 
         const network = await this.unisat.getNetwork();
         switch (network) {
-            case WalletNetworks.mainnet:
+            case WalletNetworks.Mainnet:
                 this._network = networks.bitcoin;
                 break;
-            case WalletNetworks.testnet:
+            case WalletNetworks.Testnet:
                 this._network = networks.testnet;
                 break;
-            case WalletNetworks.regtest:
+            case WalletNetworks.Regtest:
                 this._network = networks.regtest;
                 break;
             default:

package/src/transaction/browser/types/Unisat.ts

@@ -51,8 +51,8 @@ export interface PsbtSignatureOptions {
 export interface Unisat {
     web3?: Web3Provider;
 
-    disconnect: () => void;
-    connect: () => void;
+    disconnect: () => Promise<void>;
+    connect: () => Promise<void>;
 
     sendBitcoin(
         toAddress: string,

package/test/derivePath.test.ts

@@ -233,10 +233,11 @@ describe('Wallet.derivePath', () => {
     });
 });
 
-describe('Mnemonic.deriveUnisat', () => {
+describe('Mnemonic.deriveOPWallet', () => {
     const testMnemonic =
         'episode frost someone page color giraffe match vanish sheriff veteran hub year pull save dizzy limb already turn reopen truth cradle rural wisdom change';
-    const unisatExpectedAddress = 'bcrt1phn6ej9ct038j722wdzkvsk7c6pmugtd5d3qnpwxc8g40zerf2ujs55tkz3';
+    const unisatExpectedAddress =
+        'bcrt1phn6ej9ct038j722wdzkvsk7c6pmugtd5d3qnpwxc8g40zerf2ujs55tkz3';
 
     describe('P2TR (Taproot) derivation', () => {
         it('should match Unisat P2TR address for regtest', () => {
@@ -247,7 +248,7 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallet = mnemonic.deriveUnisat(AddressTypes.P2TR, 0, 0, false);
+            const wallet = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0, 0, false);
 
             expect(wallet.p2tr).toBe(unisatExpectedAddress);
         });
@@ -260,7 +261,7 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallet = mnemonic.deriveUnisat(AddressTypes.P2TR, 0);
+            const wallet = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0);
 
             expect(wallet.p2tr).toMatch(/^bc1p/);
         });
@@ -273,7 +274,7 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallet = mnemonic.deriveUnisat(AddressTypes.P2TR, 0);
+            const wallet = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0);
 
             expect(wallet.p2tr).toMatch(/^tb1p/);
         });
@@ -288,13 +289,13 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallet = mnemonic.deriveUnisat(AddressTypes.P2WPKH, 0);
+            const wallet = mnemonic.deriveOPWallet(AddressTypes.P2WPKH, 0);
 
             expect(wallet.p2wpkh).toBeDefined();
             expect(wallet.p2wpkh).toMatch(/^bc1q/);
         });
 
-        it('should use BIP84 path (m/84\'/0\'/0\'/0/0)', () => {
+        it("should use BIP84 path (m/84'/0'/0'/0/0)", () => {
             const mnemonic = new Mnemonic(
                 testMnemonic,
                 '',
@@ -302,7 +303,7 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallet = mnemonic.deriveUnisat(AddressTypes.P2WPKH, 0);
+            const wallet = mnemonic.deriveOPWallet(AddressTypes.P2WPKH, 0);
             expect(wallet.p2wpkh).toBeDefined();
         });
     });
@@ -316,7 +317,7 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallet = mnemonic.deriveUnisat(AddressTypes.P2PKH, 0);
+            const wallet = mnemonic.deriveOPWallet(AddressTypes.P2PKH, 0);
 
             expect(wallet.legacy).toBeDefined();
             expect(wallet.legacy).toMatch(/^1/);
@@ -332,9 +333,9 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallet0 = mnemonic.deriveUnisat(AddressTypes.P2TR, 0);
-            const wallet1 = mnemonic.deriveUnisat(AddressTypes.P2TR, 1);
-            const wallet2 = mnemonic.deriveUnisat(AddressTypes.P2TR, 2);
+            const wallet0 = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0);
+            const wallet1 = mnemonic.deriveOPWallet(AddressTypes.P2TR, 1);
+            const wallet2 = mnemonic.deriveOPWallet(AddressTypes.P2TR, 2);
 
             expect(wallet0.p2tr).not.toBe(wallet1.p2tr);
             expect(wallet1.p2tr).not.toBe(wallet2.p2tr);
@@ -349,8 +350,8 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallet1 = mnemonic.deriveUnisat(AddressTypes.P2TR, 5);
-            const wallet2 = mnemonic.deriveUnisat(AddressTypes.P2TR, 5);
+            const wallet1 = mnemonic.deriveOPWallet(AddressTypes.P2TR, 5);
+            const wallet2 = mnemonic.deriveOPWallet(AddressTypes.P2TR, 5);
 
             expect(wallet1.p2tr).toBe(wallet2.p2tr);
             expect(wallet1.toPublicKeyHex()).toBe(wallet2.toPublicKeyHex());
@@ -366,8 +367,8 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const account0 = mnemonic.deriveUnisat(AddressTypes.P2TR, 0, 0);
-            const account1 = mnemonic.deriveUnisat(AddressTypes.P2TR, 0, 1);
+            const account0 = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0, 0);
+            const account1 = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0, 1);
 
             expect(account0.p2tr).not.toBe(account1.p2tr);
         });
@@ -380,8 +381,8 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const receiving = mnemonic.deriveUnisat(AddressTypes.P2TR, 0, 0, false);
-            const change = mnemonic.deriveUnisat(AddressTypes.P2TR, 0, 0, true);
+            const receiving = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0, 0, false);
+            const change = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0, 0, true);
 
             expect(receiving.p2tr).not.toBe(change.p2tr);
         });
@@ -396,7 +397,7 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallet = mnemonic.deriveUnisat(AddressTypes.P2TR, 0);
+            const wallet = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0);
 
             expect(wallet.quantumPublicKey).toBeDefined();
             expect(wallet.quantumPublicKey.length).toBe(1312); // LEVEL2 size
@@ -411,14 +412,14 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallet0 = mnemonic.deriveUnisat(AddressTypes.P2TR, 0);
-            const wallet1 = mnemonic.deriveUnisat(AddressTypes.P2TR, 1);
+            const wallet0 = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0);
+            const wallet1 = mnemonic.deriveOPWallet(AddressTypes.P2TR, 1);
 
             expect(wallet0.address.toHex()).not.toBe(wallet1.address.toHex());
         });
     });
 
-    describe('deriveMultipleUnisat', () => {
+    describe('deriveMultipleOPWallet', () => {
         it('should derive multiple wallets', () => {
             const mnemonic = new Mnemonic(
                 testMnemonic,
@@ -427,7 +428,7 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallets = mnemonic.deriveMultipleUnisat(AddressTypes.P2TR, 5);
+            const wallets = mnemonic.deriveMultipleOPWallet(AddressTypes.P2TR, 5);
 
             expect(wallets.length).toBe(5);
             expect(wallets[0].p2tr).toBeDefined();
@@ -442,7 +443,7 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallets = mnemonic.deriveMultipleUnisat(AddressTypes.P2TR, 3);
+            const wallets = mnemonic.deriveMultipleOPWallet(AddressTypes.P2TR, 3);
 
             const addresses = wallets.map((w) => w.p2tr);
             const uniqueAddresses = new Set(addresses);
@@ -458,8 +459,8 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallets = mnemonic.deriveMultipleUnisat(AddressTypes.P2TR, 2, 5);
-            const wallet5 = mnemonic.deriveUnisat(AddressTypes.P2TR, 5);
+            const wallets = mnemonic.deriveMultipleOPWallet(AddressTypes.P2TR, 2, 5);
+            const wallet5 = mnemonic.deriveOPWallet(AddressTypes.P2TR, 5);
 
             expect(wallets[0].p2tr).toBe(wallet5.p2tr);
         });
@@ -475,7 +476,7 @@ describe('Mnemonic.deriveUnisat', () => {
             );
 
             expect(() => {
-                mnemonic.deriveUnisat('INVALID_TYPE' as AddressTypes, 0);
+                mnemonic.deriveOPWallet('INVALID_TYPE' as AddressTypes, 0);
             }).toThrow('Unsupported address type');
         });
     });
@@ -489,7 +490,7 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallet = mnemonic.deriveUnisat(AddressTypes.P2TR, 0);
+            const wallet = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0);
 
             expect(wallet.network.bech32).toBe('tb');
         });
@@ -504,7 +505,7 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL3,
             );
 
-            const wallet = mnemonic.deriveUnisat(AddressTypes.P2TR, 0);
+            const wallet = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0);
 
             expect(wallet.securityLevel).toBe(MLDSASecurityLevel.LEVEL3);
             expect(wallet.quantumPublicKey.length).toBe(1952); // LEVEL3 size