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

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,12 @@ 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);
-
-        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);
+    public static fromBigInt(value: bigint, tweakedValue?: bigint): Address {
+        const address = Address.bigintToUint8Array(value);
+        const legacyAddress =
+            tweakedValue !== undefined ? Address.bigintToUint8Array(tweakedValue) : undefined;
 
-        return new Address(buffer);
+        return new Address(address, legacyAddress);
     }
 
     /**
@@ -253,6 +251,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 +429,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;
 
@@ -725,6 +770,7 @@ export class Address extends Uint8Array {
 
     public toTweakedHybridPublicKeyHex(): string {
         this.ensureLegacyProcessed();
+        this.ensureTweakedUncompressed();
         if (!this.#tweakedUncompressed) {
             throw new Error('Legacy public key not set');
         }
@@ -734,6 +780,7 @@ export class Address extends Uint8Array {
 
     public toTweakedHybridPublicKeyBuffer(): Buffer {
         this.ensureLegacyProcessed();
+        this.ensureTweakedUncompressed();
         if (!this.#tweakedUncompressed) {
             throw new Error('Legacy public key not set');
         }
@@ -741,6 +788,29 @@ export class Address extends Uint8Array {
         return this.#tweakedUncompressed;
     }
 
+    /**
+     * Lazily generates the tweaked uncompressed/hybrid key from the legacy public key.
+     * Only called when toTweakedHybridPublicKey* methods are accessed.
+     */
+    private ensureTweakedUncompressed(): void {
+        if (this.#tweakedUncompressed) return;
+
+        const key = this.#legacyPublicKey;
+        if (!key) return;
+
+        // Only attempt hybrid key generation for 32-byte keys that weren't processed through autoFormat
+        if (key.length === ADDRESS_BYTE_LENGTH && !this.#originalPublicKey) {
+            try {
+                const buf = Buffer.alloc(ADDRESS_BYTE_LENGTH);
+                buf.set(key);
+                this.#tweakedUncompressed = ContractAddress.generateHybridKeyFromHash(buf);
+            } catch {
+                // Hybrid key generation may fail for keys that aren't valid EC points
+                // (e.g., zero addresses). Leave #tweakedUncompressed undefined.
+            }
+        }
+    }
+
     /**
      * Sets the MLDSA key portion of the address.
      * @param {ArrayLike<number>} mldsaPublicKey - The MLDSA public key or its hash
@@ -793,11 +863,6 @@ export class Address extends Uint8Array {
         // Length validation already done in constructor
 
         if (pending.length === ADDRESS_BYTE_LENGTH) {
-            // 32-byte input: already tweaked x-only, just generate hybrid
-            const buf = Buffer.alloc(ADDRESS_BYTE_LENGTH);
-            buf.set(pending);
-
-            this.#tweakedUncompressed = ContractAddress.generateHybridKeyFromHash(buf);
             this.#legacyPublicKey = pending;
         } else {
             // 33 or 65 bytes: full autoFormat processing with EC operations

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/src/transaction/builders/MultiSignTransaction.ts

@@ -227,7 +227,7 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
                 input.tapScriptSig = (input.tapScriptSig || []).concat(partialSignatures);
             }
 
-            delete input.finalScriptWitness;
+            Reflect.deleteProperty(input, 'finalScriptWitness');
 
             const signHashTypes: number[] = MultiSignTransaction.signHashTypesArray
                 ? [MultiSignTransaction.calculateSignHash(MultiSignTransaction.signHashTypesArray)]
@@ -397,7 +397,7 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
                     );
                 }
 
-                delete input.finalScriptWitness;
+                Reflect.deleteProperty(input, 'finalScriptWitness');
 
                 psbt.finalizeInput(
                     i,

package/src/transaction/shared/TweakedTransaction.ts

@@ -948,18 +948,18 @@ export abstract class TweakedTransaction extends Logger {
             if (isP2WPKH(redeemOutput)) {
                 // P2SH-P2WPKH
                 // Use witnessUtxo + redeemScript
-                delete input.nonWitnessUtxo; // ensure we do NOT have nonWitnessUtxo
+                Reflect.deleteProperty(input, 'nonWitnessUtxo'); // ensure we do NOT have nonWitnessUtxo
                 // witnessScript is not needed
             } else if (isP2WSHScript(redeemOutput)) {
                 // P2SH-P2WSH
                 // Use witnessUtxo + redeemScript + witnessScript
-                delete input.nonWitnessUtxo; // ensure we do NOT have nonWitnessUtxo
+                Reflect.deleteProperty(input, 'nonWitnessUtxo'); // ensure we do NOT have nonWitnessUtxo
 
                 this.processP2WSHInput(utxo, input, i);
             } else {
                 // Legacy P2SH
                 // Use nonWitnessUtxo
-                delete input.witnessUtxo; // ensure we do NOT have witnessUtxo
+                Reflect.deleteProperty(input, 'witnessUtxo'); // ensure we do NOT have witnessUtxo
             }
         }
 

package/src/utils/lengths.ts

@@ -1,4 +1,6 @@
 export const ADDRESS_BYTE_LENGTH: number = 32;
+export const EXTENDED_ADDRESS_BYTE_LENGTH: number = 64;
+export const SCHNORR_SIGNATURE_BYTE_LENGTH: number = 64;
 export const SELECTOR_BYTE_LENGTH: number = 4;
 
 export const U256_BYTE_LENGTH: number = 32;
@@ -11,7 +13,7 @@ export const U8_BYTE_LENGTH: number = 1;
 export const I256_BYTE_LENGTH: number = 32;
 export const I128_BYTE_LENGTH: number = 16;
 export const I64_BYTE_LENGTH: number = 8;
-export const number_BYTE_LENGTH: number = 4;
+export const I32_BYTE_LENGTH: number = 4;
 export const I16_BYTE_LENGTH: number = 2;
 export const I8_BYTE_LENGTH: number = 1;
 

package/src/utils/types.ts

@@ -8,11 +8,14 @@ export type MemorySlotData<T> = T;
 export type PointerStorage = DeterministicMap<MemorySlotPointer, MemorySlotData<bigint>>;
 export type BlockchainStorage = DeterministicMap<string, PointerStorage>;
 
+export type i8 = number;
+export type i16 = number;
 export type i32 = number;
+export type i64 = bigint;
+
 export type u8 = number;
 export type u16 = number;
 export type u32 = number;
-
 export type u64 = bigint;
 
 export type Selector = number;