@dynamic-labs-wallet/btc 0.0.253 → 0.0.255

package/index.cjs.js

@@ -3,9 +3,7 @@
 var browser = require('@dynamic-labs-wallet/browser');
 var bitcoin = require('bitcoinjs-lib');
 var ecc = require('@bitcoinerlab/secp256k1');
-var bip322Js = require('bip322-js');
-var bs58 = require('bs58');
-var sha256 = require('@noble/hashes/sha256');
+var btcUtils = require('@dynamic-labs-wallet/btc-utils');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -37,722 +35,6 @@ function _extends() {
     return _extends.apply(this, arguments);
 }
 
-/**
- * Maps a BitcoinNetwork string to a bitcoinjs-lib Network object.
- *
- * @param network - The network identifier ('mainnet' or 'testnet').
- * @returns The corresponding bitcoinjs-lib Network object. Defaults to bitcoin mainnet if the network is not recognized.
- */ function getBitcoinNetwork(network) {
-    switch(network){
-        case 'mainnet':
-            return bitcoin__namespace.networks.bitcoin;
-        case 'testnet':
-            return bitcoin__namespace.networks.testnet;
-        default:
-            return bitcoin__namespace.networks.bitcoin;
-    }
-}
-
-/**
- * Helper to handle Buffer/Uint8Array compatibility issues
- *
- * @param data - The data to convert to a Buffer
- * @returns The Buffer representation of the data
- */ const toBuffer = (data)=>{
-    if (Buffer.isBuffer(data)) return data;
-    return Buffer.from(data);
-};
-
-/**
- * Creates a native SegWit P2WPKH address
- *
- * @param pubKey - The public key
- * @param networkName - The network name
- * @returns The native SegWit address
- */ const createNativeSegWitAddress = (pubKey, networkName)=>{
-    const network = getBitcoinNetwork(networkName);
-    // Convert to Uint8Array
-    let pubKeyArray = Uint8Array.from(pubKey);
-    // If it's an uncompressed key (65 bytes), compress it (33 bytes)
-    if (pubKeyArray.length === 65) {
-        // Uncompressed format: 0x04 || x (32 bytes) || y (32 bytes)
-        // Compressed format: 0x02 or 0x03 || x (32 bytes)
-        const y = pubKeyArray[64];
-        const compressedX = pubKeyArray.slice(1, 33); // Skip the 0x04 prefix, take x (32 bytes)
-        const compressed = new Uint8Array(33);
-        compressed[0] = y % 2 === 0 ? 0x02 : 0x03; // Even y -> 0x02, Odd y -> 0x03
-        compressed.set(compressedX, 1);
-        pubKeyArray = compressed;
-    }
-    const { address } = bitcoin.payments.p2wpkh({
-        pubkey: toBuffer(pubKeyArray),
-        network
-    });
-    return address || '';
-};
-
-let isInitialized = false;
-/**
- * Initializes the ECC library if not already initialized
- */ const initEccLib = ()=>{
-    if (isInitialized) return;
-    bitcoin.initEccLib(ecc);
-    isInitialized = true;
-};
-
-/**
- * Creates a Taproot P2TR address
- *
- * @param pubKey - The public key
- * @param networkName - The network name
- * @returns The Taproot address
- */ const createTaprootAddress = (pubKey, networkName)=>{
-    initEccLib();
-    const network = getBitcoinNetwork(networkName);
-    // For Taproot, we need the 32-byte x-only public key
-    const xOnlyPubKey = pubKey.subarray(-32);
-    const xOnlyPubKeyArray = Uint8Array.from(xOnlyPubKey);
-    const { address } = bitcoin.payments.p2tr({
-        internalPubkey: toBuffer(xOnlyPubKeyArray),
-        network
-    });
-    if (!address) {
-        throw new Error('Failed to create Taproot address');
-    }
-    return address;
-};
-
-// eslint-disable-next-line @nx/enforce-module-boundaries
-/**
- * Converts a public key to a Bitcoin address
- *
- * @param publicKey - The public key
- * @param addressType - The address type (default: TAPROOT)
- * @param network - The Bitcoin network (default: 'mainnet')
- * @returns The Bitcoin address
- */ const publicKeyToBitcoinAddress = (publicKey, addressType = browser.BitcoinAddressType.TAPROOT, network = 'mainnet')=>{
-    initEccLib();
-    // Convert to Uint8Array to Buffer if needed
-    const pubKeyBuffer = toBuffer(publicKey);
-    switch(addressType){
-        case browser.BitcoinAddressType.NATIVE_SEGWIT:
-            return createNativeSegWitAddress(pubKeyBuffer, network);
-        case browser.BitcoinAddressType.TAPROOT:
-            return createTaprootAddress(pubKeyBuffer, network);
-        default:
-            throw new Error(`Unsupported address type: ${addressType}`);
-    }
-};
-
-/**
- * Converts a public key input (various formats) to a Buffer.
- * Handles objects with `pubkey` property, numeric key maps, `serializeUncompressed` methods, etc.
- *
- * @param pubkey - The raw public key input
- * @returns The public key as a Buffer
- */ const convertPublicKeyToBuffer = (pubkey)=>{
-    const actualPubkey = pubkey;
-    if (Buffer.isBuffer(actualPubkey)) {
-        return actualPubkey;
-    }
-    if (actualPubkey instanceof Uint8Array) {
-        return Buffer.from(actualPubkey);
-    }
-    if (typeof actualPubkey === 'string') {
-        const result = Buffer.from(actualPubkey, 'hex');
-        if (result.length === 0) {
-            throw new Error('Invalid public key format');
-        }
-        return result;
-    }
-    if (typeof actualPubkey === 'object' && actualPubkey !== null) {
-        return convertObjectToBuffer(actualPubkey);
-    }
-    throw new Error('Invalid public key format');
-};
-const convertObjectToBuffer = (actualPubkey)=>{
-    if ('pubkey' in actualPubkey) {
-        return convertPublicKeyToBuffer(actualPubkey.pubkey);
-    }
-    if ('serializeUncompressed' in actualPubkey && typeof actualPubkey.serializeUncompressed === 'function') {
-        return Buffer.from(actualPubkey.serializeUncompressed());
-    }
-    const keys = Object.keys(actualPubkey).map(Number).filter((k)=>!Number.isNaN(k)).sort((a, b)=>a - b);
-    if (keys.length > 0) {
-        return Buffer.from(keys.map((k)=>actualPubkey[k]));
-    }
-    throw new Error('Invalid public key object');
-};
-
-/**
- * Normalizes a public key buffer for Taproot (P2TR).
- * Ensures the result is a 32-byte x-only key.
- *
- * @param buffer - The public key buffer
- * @returns The 32-byte x-only public key buffer
- */ const normalizeForTaproot = (buffer)=>{
-    if (buffer.length === 32) return buffer;
-    if (buffer.length === 33) return buffer.subarray(1, 33);
-    if (buffer.length === 65) return buffer.subarray(1, 33);
-    if (buffer.length === 64) return buffer.subarray(0, 32);
-    throw new Error(`Unexpected public key length for Taproot: ${buffer.length}`);
-};
-
-/**
- * Normalizes a public key buffer for Compressed formats (Legacy, SegWit, Native SegWit).
- * Ensures the result is a 33-byte compressed key.
- *
- * @param buffer - The public key buffer
- * @returns The 33-byte compressed public key buffer
- */ const normalizeForCompressed = (buffer)=>{
-    if (buffer.length === 33) {
-        return buffer;
-    }
-    if (buffer.length === 65 && buffer[0] === 0x04) {
-        // Uncompressed standard (04 + X + Y)
-        const x = buffer.subarray(1, 33);
-        const yLastByte = buffer[64];
-        return compressPublicKey(x, yLastByte);
-    }
-    if (buffer.length === 64) {
-        // Raw X + Y (missing 04 prefix)
-        const x = buffer.subarray(0, 32);
-        const yLastByte = buffer[63];
-        return compressPublicKey(x, yLastByte);
-    }
-    throw new Error(`Unexpected public key length: ${buffer.length}`);
-};
-const compressPublicKey = (x, yLastByte)=>{
-    const prefix = yLastByte % 2 === 0 ? 0x02 : 0x03;
-    return Buffer.concat([
-        Buffer.from([
-            prefix
-        ]),
-        x
-    ]);
-};
-
-// eslint-disable @nx/enforce-module-boundaries
-/**
- * Normalizes a public key to a standard Buffer format
- * Handles various input types (Uint8Array, Buffer, object with pubKeyAsHex, etc.)
- * and formats (32-byte x-only, 33-byte compressed, 65-byte uncompressed)
- * based on the target address type.
- *
- * @param pubkey - The raw public key input
- * @param addressType - The target Bitcoin address type
- * @returns The normalized public key as a Buffer
- */ const normalizePublicKey = (pubkey, addressType)=>{
-    const buffer = convertPublicKeyToBuffer(pubkey);
-    if (addressType === browser.BitcoinAddressType.TAPROOT) {
-        return normalizeForTaproot(buffer);
-    }
-    return normalizeForCompressed(buffer);
-};
-
-// eslint-disable-next-line @nx/enforce-module-boundaries
-/**
- * Infers the Bitcoin address type from a BIP-44 derivation path
- *
- * @param derivationPathStr - The derivation path string (e.g. "m/44'/0'/0'/0/0" as JSON or string)
- * @returns The inferred BitcoinAddressType
- */ const getAddressTypeFromDerivationPath = (derivationPathStr)=>{
-    const derivationPathObj = JSON.parse(derivationPathStr);
-    const path = Object.values(derivationPathObj).map(Number);
-    if (path.length < 2) throw new Error('Invalid derivation path length');
-    const purpose = path[0];
-    // Handle both raw and hardened just in case, or just raw if strictly non-hardened
-    // 44 = 0x2C (Legacy), 49 = 0x31 (SegWit P2SH), 84 = 0x54 (Native SegWit), 86 = 0x56 (Taproot)
-    const purposeIndex = purpose >= 0x80000000 ? purpose - 0x80000000 : purpose;
-    let addressType;
-    switch(purposeIndex){
-        case 84:
-            addressType = browser.BitcoinAddressType.NATIVE_SEGWIT;
-            break;
-        case 86:
-            addressType = browser.BitcoinAddressType.TAPROOT;
-            break;
-        default:
-            throw new Error(`Unknown derivation path purpose: ${purposeIndex}`);
-    }
-    return addressType;
-};
-
-/**
- * Calculates the hash to be signed for a BIP-322 message verification
- *
- * @param message - The message to sign
- * @param pubKey - The public key of the signer
- * @param addressType - The address type (e.g. TAPROOT, SEGWIT)
- * @param network - The Bitcoin network
- * @returns The formatted message hash and the PSBT to be signed
- */ const calculateBip322Hash = (message, pubKey, addressType, network)=>{
-    // Normalize key and derive address
-    const normalizedKey = normalizePublicKey(pubKey, addressType);
-    const address = publicKeyToBitcoinAddress(normalizedKey, addressType, network);
-    if (!address) {
-        throw new Error('Failed to generate address for BIP-322');
-    }
-    const scriptPubKey = bip322Js.Address.convertAdressToScriptPubkey(address);
-    const toSpendTx = bip322Js.BIP322.buildToSpendTx(message, scriptPubKey);
-    const toSignPsbt = bip322Js.BIP322.buildToSignTx(toSpendTx.getId(), scriptPubKey);
-    // Calculate Hash to Sign
-    const txToSign = toSignPsbt.__CACHE.__TX; // Access underlying TX like prototype
-    let hashToSign;
-    if (addressType === browser.BitcoinAddressType.TAPROOT) {
-        // Taproot (BIP-341) Signing
-        const prevOutScripts = [
-            scriptPubKey
-        ];
-        const values = [
-            0
-        ]; // BIP-322 value
-        // Cast to any to avoid type issues if definition is missing
-        hashToSign = Buffer.from(txToSign.hashForWitnessV1(0, prevOutScripts, values, bitcoin__namespace.Transaction.SIGHASH_DEFAULT // Default sighash for Taproot
-        ));
-    } else {
-        // SegWit (BIP-143) Signing (P2WPKH)
-        const txToSignSegwit = new bitcoin__namespace.Transaction();
-        txToSignSegwit.version = 0;
-        txToSignSegwit.locktime = 0;
-        const prevTxId = toSpendTx.getId();
-        const prevHash = Buffer.from(prevTxId, 'hex').reverse();
-        txToSignSegwit.addInput(prevHash, 0, 0);
-        txToSignSegwit.addOutput(Buffer.from([
-            0x6a
-        ]), BigInt(0));
-        const p2pkh = bitcoin__namespace.payments.p2pkh({
-            pubkey: normalizedKey,
-            network: network === 'testnet' ? bitcoin__namespace.networks.testnet : bitcoin__namespace.networks.bitcoin
-        });
-        const scriptCode = p2pkh.output;
-        if (!scriptCode) throw new Error('Failed to generate scriptCode');
-        hashToSign = txToSignSegwit.hashForWitnessV0(0, scriptCode, BigInt(0), bitcoin__namespace.Transaction.SIGHASH_ALL);
-    }
-    return {
-        formattedMessage: new Uint8Array(hashToSign),
-        toSignPsbt
-    };
-};
-
-/**
- * Encodes the signature into the BIP-322 witness format
- *
- * @param toSignPsbt - The PSBT that was signed
- * @param pubKey - The public key of the signer
- * @param signature - The signature produced by the signer
- * @param addressType - The address type
- * @returns The base64 encoded BIP-322 signature
- */ const encodeBip322Signature = (toSignPsbt, pubKey, signature, addressType)=>{
-    const normalizedKey = normalizePublicKey(pubKey, addressType);
-    if (addressType === browser.BitcoinAddressType.TAPROOT) {
-        // Prototype logic: direct update
-        // Signature from MPC should be 64 bytes (r|s)
-        let sigBuffer;
-        if (signature instanceof Uint8Array || Buffer.isBuffer(signature)) {
-            sigBuffer = Buffer.from(signature);
-        } else {
-            // ECDSA signature object? Should be raw bytes for Schnorr/BIP340
-            // If it's EcdsaSignature (r,s), concat them.
-            const r = signature.r;
-            const s = signature.s;
-            const rBuf = Buffer.isBuffer(r) ? r : Buffer.from(r);
-            const sBuf = Buffer.isBuffer(s) ? s : Buffer.from(s);
-            sigBuffer = Buffer.concat([
-                rBuf,
-                sBuf
-            ]);
-        }
-        toSignPsbt.updateInput(0, {
-            tapKeySig: sigBuffer
-        });
-    } else {
-        // Serialize the signature (COMPACT SIGNATURE)
-        const r = signature.r;
-        const s = signature.s;
-        const compactSignature = Buffer.concat([
-            Buffer.from(r),
-            Buffer.from(s)
-        ]);
-        // Apply Signature
-        const mpcSignerForPsbt = {
-            publicKey: normalizedKey,
-            sign: (_hash)=>{
-                return compactSignature;
-            }
-        };
-        // Sign the input
-        toSignPsbt.signInput(0, mpcSignerForPsbt);
-    }
-    // Finalize the inputs
-    toSignPsbt.finalizeAllInputs();
-    // Encode Final Result
-    return bip322Js.BIP322.encodeWitness(toSignPsbt);
-};
-
-initEccLib();
-/**
- * Converts a private key (hex string) to Bitcoin WIF (Wallet Import Format)
- * WIF is the standard format that Bitcoin wallets expect for importing private keys
- * 
- * WIF encoding steps:
- * 1. Add network prefix (0x80 for mainnet, 0xef for testnet/regtest)
- * 2. Add compression flag (0x01) for compressed public keys (used for SegWit)
- * 3. Calculate checksum (double SHA-256, take first 4 bytes)
- * 4. Base58 encode the result
- * 
- * @param privateKey - Private key as hex string (with or without 0x prefix)
- * @param network - Bitcoin network (mainnet, testnet)
- * @param options - Optional configuration
- * @param options.compressed - Whether to use compressed format (default: true for SegWit compatibility)
- * @param options.onWarning - Optional callback for warnings (e.g., unexpected key length)
- * @returns WIF-encoded private key string
- * @throws Error if conversion fails
- */ const privateKeyToWIF = (privateKey, network = 'mainnet', options)=>{
-    const { compressed = true, onWarning } = options || {};
-    try {
-        // Remove 0x prefix if present
-        const cleanPrivateKey = privateKey.startsWith('0x') ? privateKey.slice(2) : privateKey;
-        // Validate hex string length (should be 64 characters = 32 bytes)
-        if (cleanPrivateKey.length !== 64) {
-            onWarning == null ? void 0 : onWarning('Unexpected private key length', {
-                length: cleanPrivateKey.length,
-                expected: 64
-            });
-        }
-        // Convert hex to Uint8Array
-        const privateKeyBytes = new Uint8Array(cleanPrivateKey.match(/.{1,2}/g).map((byte)=>Number.parseInt(byte, 16)));
-        // Step 1: Get network prefix from bitcoinjs-lib network
-        const networkConfig = getBitcoinNetwork(network);
-        const networkPrefix = networkConfig.wif;
-        // Step 2: Build extended key with network prefix and optional compression flag
-        // For Native SegWit and SegWit, we use compressed format (0x01 flag)
-        const extendedKeyLength = compressed ? 34 : 33; // 1 byte prefix + 32 bytes key + (optional) 1 byte compression
-        const extendedKey = new Uint8Array(extendedKeyLength);
-        extendedKey[0] = networkPrefix;
-        extendedKey.set(privateKeyBytes, 1);
-        if (compressed) {
-            extendedKey[33] = 0x01; // Compression flag for SegWit addresses
-        }
-        // Step 3: Calculate checksum (double SHA-256, take first 4 bytes)
-        const firstHash = sha256.sha256(extendedKey);
-        const secondHash = sha256.sha256(firstHash);
-        const checksum = secondHash.slice(0, 4);
-        // Step 4: Append checksum and Base58 encode
-        const wifBytes = new Uint8Array(extendedKey.length + checksum.length);
-        wifBytes.set(extendedKey, 0);
-        wifBytes.set(checksum, extendedKey.length);
-        const wif = bs58.encode(wifBytes);
-        return wif;
-    } catch (error) {
-        // Re-throw with more context
-        throw new Error(`Failed to convert private key to WIF: ${error instanceof Error ? error.message : String(error)}`);
-    }
-};
-
-/**
- * Converts a Bitcoin WIF (Wallet Import Format) private key to hex format
- * This is the reverse operation of `privateKeyToWIF`
- *
- * WIF decoding steps:
- * 1. Base58 decode the WIF string
- * 2. Validate network prefix
- * 3. Validate checksum (double SHA-256, first 4 bytes)
- * 4. Extract private key bytes (skip prefix, compression flag, and checksum)
- * 5. Convert to hex string
- *
- * @param wif - Private key in WIF format (Base58 encoded)
- * @param network - Bitcoin network (mainnet, testnet)
- * @returns Private key as hex string (64 characters, 32 bytes)
- * @throws Error if WIF format is invalid
- */ const wifToPrivateKey = (wif, network = 'mainnet')=>{
-    try {
-        // 1. Decode Base58
-        const decoded = bs58.decode(wif);
-        // 2. Validate length (should be 37 bytes: 1 prefix + 32 key + 1 compression + 4 checksum)
-        //    or 38 bytes (with compression flag)
-        if (decoded.length !== 37 && decoded.length !== 38) {
-            throw new Error(`Invalid WIF length: ${decoded.length}, expected 37 or 38 bytes`);
-        }
-        // 3. Get network config to validate prefix
-        const networkConfig = getBitcoinNetwork(network);
-        const expectedPrefix = networkConfig.wif;
-        // 4. Validate network prefix
-        if (decoded[0] !== expectedPrefix) {
-            throw new Error(`Invalid WIF network prefix: expected ${expectedPrefix}, got ${decoded[0]}`);
-        }
-        // 5. Validate checksum
-        const payload = decoded.slice(0, -4);
-        const checksum = decoded.slice(-4);
-        const firstHash = sha256.sha256(payload);
-        const secondHash = sha256.sha256(firstHash);
-        const calculatedChecksum = secondHash.slice(0, 4);
-        if (!calculatedChecksum.every((byte, index)=>byte === checksum[index])) {
-            throw new Error('Invalid WIF checksum');
-        }
-        // 6. Extract private key bytes (skip prefix, skip compression flag if present, skip checksum)
-        // Private key is always 32 bytes, starting at index 1
-        const privateKeyStart = 1;
-        const privateKeyEnd = 33; // 32 bytes of private key
-        const privateKeyBytes = decoded.slice(privateKeyStart, privateKeyEnd);
-        // 7. Convert to hex string
-        return Buffer.from(privateKeyBytes).toString('hex');
-    } catch (error) {
-        throw new Error(`Invalid WIF format: ${error instanceof Error ? error.message : String(error)}. Only WIF format is supported.`);
-    }
-};
-
-/**
- * Derives a public key from a private key (WIF format) based on address type
- *
- * - For NATIVE_SEGWIT (ECDSA): Returns compressed public key (33 bytes)
- * - For TAPROOT (BIP340): Returns x-only public key (32 bytes)
- *
- * @param privateKey - Private key in WIF format (Base58 encoded)
- * @param addressType - Bitcoin address type (NATIVE_SEGWIT or TAPROOT)
- * @param network - Bitcoin network (mainnet, testnet)
- * @returns Public key as Buffer (33 bytes for NATIVE_SEGWIT, 32 bytes for TAPROOT)
- * @throws Error if private key is invalid or derivation fails
- */ const getPublicKeyFromPrivateKey = async (privateKey, addressType, network = 'mainnet')=>{
-    initEccLib();
-    try {
-        // 1. Decode WIF to hex
-        const privateKeyHex = wifToPrivateKey(privateKey, network);
-        const privateKeyBytes = new Uint8Array(Buffer.from(privateKeyHex, 'hex'));
-        // 2. Import secp256k1 library
-        const ecc = await import('@bitcoinerlab/secp256k1');
-        // 3. Derive public key based on address type
-        if (addressType === 'taproot') {
-            // BIP340/Taproot: Derive x-only public key (32 bytes)
-            // Get the public key point
-            const publicKeyPoint = ecc.pointFromScalar(privateKeyBytes);
-            if (!publicKeyPoint) {
-                throw new Error('Failed to derive public key from private key');
-            }
-            // For Taproot, we need the 32-byte x-only public key
-            // publicKeyPoint is 33 bytes (0x02/0x03 + 32 bytes x), we take the last 32 bytes
-            return Buffer.from(publicKeyPoint.subarray(1)); // Skip prefix, get x-coordinate
-        } else {
-            // NATIVE_SEGWIT (ECDSA): Derive compressed public key (33 bytes)
-            const publicKeyPoint = ecc.pointFromScalar(privateKeyBytes, true); // compressed = true
-            if (!publicKeyPoint) {
-                throw new Error('Failed to derive public key from private key');
-            }
-            return Buffer.from(publicKeyPoint); // 33 bytes compressed
-        }
-    } catch (error) {
-        throw new Error(`Failed to derive public key from private key: ${error instanceof Error ? error.message : String(error)}`);
-    }
-};
-
-/**
- * Converts an ECDSA signature to DER format
- *
- * @param signature - The ECDSA signature
- * @returns The DER encoded signature
- */ const convertSignatureToDER = (signature)=>{
-    // Construct raw 64-byte signature (r + s) using Uint8Array to ensure compatibility
-    const r = signature.r instanceof Uint8Array ? signature.r : new Uint8Array(signature.r);
-    const s = signature.s instanceof Uint8Array ? signature.s : new Uint8Array(signature.s);
-    // Enforce 32-byte length (padding or slicing if needed)
-    const r32 = new Uint8Array(32);
-    const rSource = r.length > 32 ? r.slice(-32) : r;
-    r32.set(rSource, 32 - rSource.length);
-    const s32 = new Uint8Array(32);
-    const sSource = s.length > 32 ? s.slice(-32) : s;
-    s32.set(sSource, 32 - sSource.length);
-    const rawSignature = new Uint8Array(64);
-    rawSignature.set(r32, 0);
-    rawSignature.set(s32, 32);
-    const derSignature = bitcoin__namespace.script.signature.encode(rawSignature, bitcoin__namespace.Transaction.SIGHASH_ALL);
-    return derSignature;
-};
-
-/**
- * Helper to get the default RPC URL
- *
- * @param network - The Bitcoin network
- * @returns The default RPC URL
- */ const getDefaultRpcUrl = (network)=>{
-    return network === 'mainnet' ? 'https://mempool.space/api' : 'https://mempool.space/testnet/api';
-};
-
-/**
- * Fetches UTXOs for a given address using mempool.space API
- *
- * @param address - The address to fetch UTXOs for
- * @param network - The Bitcoin network (default: 'mainnet')
- * @param rpcUrl - Optional custom RPC URL
- * @returns The list of UTXOs
- */ const getUTXOs = async ({ address, network = 'mainnet', rpcUrl })=>{
-    const baseUrl = rpcUrl || getDefaultRpcUrl(network);
-    try {
-        const response = await fetch(`${baseUrl}/address/${address}/utxo`);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch UTXOs: ${response.statusText}`);
-        }
-        const utxos = await response.json();
-        return utxos.map((utxo)=>({
-                txid: utxo.txid,
-                vout: utxo.vout,
-                value: BigInt(utxo.value)
-            }));
-    } catch (error) {
-        throw new Error(`Error fetching UTXOs: ${error}`);
-    }
-};
-
-/**
- * Simple greedy coin selection
- *
- * @param utxos - The list of UTXOs to select from
- * @param amount - The amount to spend
- * @param feeRate - The fee rate in sat/vByte
- * @returns The selected inputs, change amount, and fee
- */ const selectUTXOs = ({ utxos, amount, feeRate })=>{
-    // Sort by value descending
-    const sorted = [
-        ...utxos
-    ].sort((a, b)=>Number(b.value - a.value));
-    const inputs = [];
-    let totalInput = 0n;
-    // Basic fee estimation constants
-    // Optimized for Native SegWit (P2WPKH) only
-    // P2WPKH: ~68 vbytes per input, ~31 vbytes per output
-    // Overhead: ~10 vbytes
-    const INPUT_SIZE = 68;
-    const OUTPUT_SIZE = 31;
-    const OVERHEAD = 10;
-    for (const utxo of sorted){
-        inputs.push(utxo);
-        totalInput += utxo.value;
-        // Calculate fee for current set + 2 outputs (recipient + change)
-        const vbytes = OVERHEAD + inputs.length * INPUT_SIZE + 2 * OUTPUT_SIZE;
-        const fee = BigInt(Math.ceil(vbytes * feeRate));
-        if (totalInput >= amount + fee) {
-            return {
-                inputs,
-                change: totalInput - amount - fee,
-                fee
-            };
-        }
-    }
-    throw new Error('Insufficient funds');
-};
-
-/**
- * Fetches current fee rates from mempool.space
- * Returns fees in sat/vByte
- *
- * @param network - The Bitcoin network (default: 'mainnet')
- * @param rpcUrl - Optional custom RPC URL
- * @returns The fee rates for fast, medium, and slow transactions
- */ const getFeeRates = async ({ network = 'mainnet', rpcUrl })=>{
-    const baseUrl = rpcUrl || getDefaultRpcUrl(network);
-    const response = await fetch(`${baseUrl}/v1/fees/recommended`);
-    if (!response.ok) {
-        throw new Error(`Failed to fetch fee rates: ${response.statusText}`);
-    }
-    const fees = await response.json();
-    return {
-        fast: fees.fastestFee,
-        medium: fees.halfHourFee,
-        slow: fees.hourFee
-    };
-};
-
-/**
- * Calculates the Taproot tweak hash for BIP340 signing
- * @param pubKey - The normalized public key (32-byte x-only for Taproot)
- * @returns The tweak hash as a hex string (64 hex chars = 32 bytes)
- */ const calculateTaprootTweak = (pubKey)=>{
-    const tweakHash = bitcoin__namespace.crypto.taggedHash('TapTweak', pubKey);
-    return Buffer.from(tweakHash).toString('hex');
-};
-
-/**
- * Converts a signature to a Buffer format suitable for Taproot (BIP340/Schnorr)
- * Taproot signatures are 64 bytes (r|s concatenated)
- * @param signature - The signature from MPC (can be Uint8Array, Buffer, or EcdsaSignature object)
- * @returns A Buffer containing the 64-byte Schnorr signature
- */ const convertSignatureToTaprootBuffer = (signature)=>{
-    if (signature instanceof Uint8Array || Buffer.isBuffer(signature)) {
-        return Buffer.from(signature);
-    }
-    // ECDSA signature object - concat r and s for Schnorr
-    const r = signature.r;
-    const s = signature.s;
-    const rBuf = Buffer.isBuffer(r) ? r : Buffer.from(r);
-    const sBuf = Buffer.isBuffer(s) ? s : Buffer.from(s);
-    return Buffer.concat([
-        rBuf,
-        sBuf
-    ]);
-};
-
-/**
- * Collects prevOutScripts and values from all PSBT inputs
- * Required for Taproot (BIP-341) hashForWitnessV1 calculation
- * @param psbt - The PSBT to collect input data from
- * @returns An object containing arrays of prevOutScripts and values
- * @throws Error if any input is missing witnessUtxo
- */ const collectPSBTInputData = (psbt)=>{
-    const prevOutScripts = [];
-    const values = [];
-    psbt.data.inputs.forEach((input, index)=>{
-        if (!input.witnessUtxo) {
-            throw new Error(`Input ${index} missing witnessUtxo`);
-        }
-        prevOutScripts.push(Buffer.isBuffer(input.witnessUtxo.script) ? input.witnessUtxo.script : Buffer.from(input.witnessUtxo.script));
-        values.push(input.witnessUtxo.value);
-    });
-    return {
-        prevOutScripts,
-        values
-    };
-};
-
-/**
- * Checks if a PSBT input belongs to a specific address
- * @param input - The PSBT input (from psbt.data.inputs)
- * @param address - The address to check against
- * @param network - The Bitcoin network
- * @returns True if the input belongs to the address, false otherwise
- */ const doesInputBelongToAddress = (input, address, network)=>{
-    if (!input.witnessUtxo) {
-        return false;
-    }
-    const script = Buffer.isBuffer(input.witnessUtxo.script) ? input.witnessUtxo.script : Buffer.from(input.witnessUtxo.script);
-    const bitcoinNetwork = getBitcoinNetwork(network);
-    try {
-        // Try P2WPKH (Native SegWit) - script is OP_0 <20-byte hash>
-        if (script.length === 22 && script[0] === 0x00 && script[1] === 0x14) {
-            const p2wpkh = bitcoin__namespace.payments.p2wpkh({
-                output: script,
-                network: bitcoinNetwork
-            });
-            return p2wpkh.address === address;
-        }
-        // Try P2TR (Taproot) - script is OP_1 <32-byte x-only pubkey>
-        if (script.length === 34 && script[0] === 0x51 && script[1] === 0x20) {
-            const p2tr = bitcoin__namespace.payments.p2tr({
-                output: script,
-                network: bitcoinNetwork
-            });
-            return p2tr.address === address;
-        }
-        return false;
-    } catch (error) {
-        // eslint-disable-next-line no-console
-        console.log('[doesInputBelongToAddress] Error checking input', {
-            address,
-            network,
-            error: error instanceof Error ? error.message : String(error)
-        });
-        return false;
-    }
-};
-
 /**
  * Parses the derivation path string into a Uint32Array
  * Handles empty strings and empty array strings by returning an empty Uint32Array
@@ -853,7 +135,7 @@ class DynamicBtcWalletClient extends browser.DynamicWalletClient {
                 password,
                 signedSessionId
             });
-            const publicKeyHex = this.extractPublicKeyHex(rawPublicKey);
+            const publicKeyHex = btcUtils.extractPublicKeyHex(rawPublicKey);
             return {
                 accountAddress,
                 publicKeyHex,
@@ -867,22 +149,6 @@ class DynamicBtcWalletClient extends browser.DynamicWalletClient {
         }
     }
     /**
-   * Automatically determines the chain config based on address type
-   * @param rawPublicKey - The raw public key from the server
-   * @returns The public key hex
-   */ extractPublicKeyHex(rawPublicKey) {
-        if (rawPublicKey instanceof Uint8Array) {
-            return Buffer.from(rawPublicKey).toString('hex');
-        }
-        if (rawPublicKey && typeof rawPublicKey === 'object' && typeof rawPublicKey.pubKeyAsHex === 'function') {
-            return rawPublicKey.pubKeyAsHex();
-        }
-        if (typeof rawPublicKey === 'string') {
-            return rawPublicKey;
-        }
-        throw new Error('Invalid public key format');
-    }
-    /**
    * Derives the Bitcoin account address
    * - BIP340 keys (32 bytes x-only): Only for Taproot addresses
    * - ECDSA keys (33/65 bytes): For all other address types (Legacy, SegWit, Native SegWit)
@@ -893,8 +159,8 @@ class DynamicBtcWalletClient extends browser.DynamicWalletClient {
    * @returns The account address
    */ deriveAccountAddress({ rawPublicKey, addressType, network }) {
         // Derive address based on the chosen address type and network
-        const normalizedKey = normalizePublicKey(rawPublicKey, addressType);
-        const accountAddress = publicKeyToBitcoinAddress(normalizedKey, addressType, network);
+        const normalizedKey = btcUtils.normalizePublicKey(rawPublicKey, addressType);
+        const accountAddress = btcUtils.publicKeyToBitcoinAddress(normalizedKey, addressType, network, ecc);
         return {
             accountAddress
         };
@@ -931,7 +197,7 @@ class DynamicBtcWalletClient extends browser.DynamicWalletClient {
             }
             let addressType = walletProperties.addressType;
             if (!addressType) {
-                addressType = getAddressTypeFromDerivationPath(derivationPath);
+                addressType = btcUtils.getAddressTypeFromDerivationPath(derivationPath);
             }
             const clientKeyShares = await this.getClientKeySharesFromStorage({
                 accountAddress
@@ -953,14 +219,14 @@ class DynamicBtcWalletClient extends browser.DynamicWalletClient {
             if (!derivedPublicKey) {
                 throw new Error('Failed to derive public key');
             }
-            const pubKey = normalizePublicKey(derivedPublicKey, addressType);
+            const pubKey = btcUtils.normalizePublicKey(derivedPublicKey, addressType);
             this.verifyWalletAddress(derivedPublicKey, addressType, network, accountAddress);
             // Prepare BIP-322 Transactions and calculate hash
-            const { formattedMessage, toSignPsbt } = calculateBip322Hash(message, pubKey, addressType, network);
+            const { formattedMessage, toSignPsbt } = btcUtils.calculateBip322Hash(message, pubKey, addressType, network, ecc);
             // Prepare tweak for Taproot in case of BIP340
             let tweak;
             if (addressType === browser.BitcoinAddressType.TAPROOT) {
-                tweak = calculateTaprootTweak(pubKey);
+                tweak = btcUtils.calculateTaprootTweak(pubKey);
             }
             // Build complete bitcoinConfig with addressType and tweak
             const completeBitcoinConfig = _extends({}, bitcoinConfig, {
@@ -983,7 +249,7 @@ class DynamicBtcWalletClient extends browser.DynamicWalletClient {
                 onError
             });
             // Encode Final Result
-            const bip322Signature = encodeBip322Signature(toSignPsbt, pubKey, signature, addressType);
+            const bip322Signature = btcUtils.encodeBip322Signature(toSignPsbt, pubKey, signature, addressType);
             this.logger.debug('[BTC Client] signMessage - bip322Signature', {
                 bip322Signature
             });
@@ -1002,8 +268,8 @@ class DynamicBtcWalletClient extends browser.DynamicWalletClient {
    * @param network - The network
    * @param expectedAddress - The expected address
    */ verifyWalletAddress(rawPublicKey, addressType, network, expectedAddress) {
-        const normalizedKey = normalizePublicKey(rawPublicKey, addressType);
-        const derivedAddress = publicKeyToBitcoinAddress(normalizedKey, addressType, network);
+        const normalizedKey = btcUtils.normalizePublicKey(rawPublicKey, addressType);
+        const derivedAddress = btcUtils.publicKeyToBitcoinAddress(normalizedKey, addressType, network, ecc);
         if (derivedAddress !== expectedAddress) {
             throw new Error(`Address verification failed: expected ${expectedAddress}, got ${derivedAddress}`);
         }
@@ -1035,7 +301,7 @@ class DynamicBtcWalletClient extends browser.DynamicWalletClient {
         let addressType = walletProperties.addressType;
         if (!addressType && walletProperties.derivationPath) {
             try {
-                addressType = getAddressTypeFromDerivationPath(walletProperties.derivationPath);
+                addressType = btcUtils.getAddressTypeFromDerivationPath(walletProperties.derivationPath);
             } catch (e) {
                 this.logger.warn('Failed to infer address type from derivation path', e);
             }
@@ -1086,9 +352,9 @@ class DynamicBtcWalletClient extends browser.DynamicWalletClient {
             const ceremonyCompletePromise = new Promise((resolve)=>{
                 ceremonyCeremonyCompleteResolver = resolve;
             });
-            const formattedPrivateKey = wifToPrivateKey(privateKey, network);
+            const formattedPrivateKey = btcUtils.wifToPrivateKey(privateKey, network);
             if (publicAddressCheck) {
-                const derivedPublicKey = await getPublicKeyFromPrivateKey(privateKey, addressTypeEnum, network);
+                const derivedPublicKey = await btcUtils.getPublicKeyFromPrivateKey(privateKey, addressTypeEnum, ecc, network);
                 const { accountAddress } = this.deriveAccountAddress({
                     rawPublicKey: derivedPublicKey,
                     addressType: addressTypeEnum,
@@ -1155,7 +421,7 @@ class DynamicBtcWalletClient extends browser.DynamicWalletClient {
                 password,
                 signedSessionId
             });
-            const publicKeyHex = this.extractPublicKeyHex(rawPublicKey);
+            const publicKeyHex = btcUtils.extractPublicKeyHex(rawPublicKey);
             return {
                 accountAddress,
                 publicKeyHex,
@@ -1175,7 +441,7 @@ class DynamicBtcWalletClient extends browser.DynamicWalletClient {
    * @returns The Bitcoin WIF format
    */ convertPrivateKeyToBitcoinFormat(privateKey, network) {
         try {
-            const wif = privateKeyToWIF(privateKey, network, {
+            const wif = btcUtils.privateKeyToWIF(privateKey, network, {
                 compressed: true,
                 onWarning: (message, data)=>{
                     this.logger.warn(`[BTC Client] convertPrivateKeyToBitcoinFormat - ${message}`, data);
@@ -1230,7 +496,7 @@ class DynamicBtcWalletClient extends browser.DynamicWalletClient {
             }
             let addressType = walletProperties.addressType;
             if (!addressType) {
-                addressType = getAddressTypeFromDerivationPath(derivationPath);
+                addressType = btcUtils.getAddressTypeFromDerivationPath(derivationPath);
             }
             const bitcoinConfig = {
                 addressType,
@@ -1253,13 +519,13 @@ class DynamicBtcWalletClient extends browser.DynamicWalletClient {
             if (!derivedPublicKey) {
                 throw new Error('Failed to derive public key');
             }
-            const pubKey = normalizePublicKey(derivedPublicKey, addressType);
+            const pubKey = btcUtils.normalizePublicKey(derivedPublicKey, addressType);
             const tx = psbt.__CACHE.__TX;
             // Filter inputs to only sign those that belong to the current address
             const inputsToSign = psbt.data.inputs.map((input, i)=>({
                     input,
                     index: i
-                })).filter(({ input })=>doesInputBelongToAddress(input, senderAddress, network));
+                })).filter(({ input })=>btcUtils.doesInputBelongToAddress(input, senderAddress, network));
             this.logger.debug('[BTC Client] signTransaction - Filtering inputs', {
                 totalInputs: psbt.data.inputs.length,
                 inputsToSign: inputsToSign.length,
@@ -1272,12 +538,12 @@ class DynamicBtcWalletClient extends browser.DynamicWalletClient {
                 });
             }
             if (addressType === browser.BitcoinAddressType.TAPROOT) {
-                const tweak = calculateTaprootTweak(pubKey);
+                const tweak = btcUtils.calculateTaprootTweak(pubKey);
                 const completeBitcoinConfig = _extends({}, bitcoinConfig, {
                     addressType: addressType,
                     tweak
                 });
-                const { prevOutScripts, values } = collectPSBTInputData(psbt);
+                const { prevOutScripts, values } = btcUtils.collectPSBTInputData(psbt);
                 await Promise.all(inputsToSign.map(async ({ input, index: i })=>{
                     if (!input.witnessUtxo) {
                         throw new Error(`Input ${i} missing witnessUtxo`);
@@ -1295,7 +561,7 @@ class DynamicBtcWalletClient extends browser.DynamicWalletClient {
                         bitcoinConfig: completeBitcoinConfig,
                         onError
                     });
-                    const sigBuffer = convertSignatureToTaprootBuffer(signature);
+                    const sigBuffer = btcUtils.convertSignatureToTaprootBuffer(signature);
                     psbt.updateInput(i, {
                         tapKeySig: sigBuffer
                     });
@@ -1314,7 +580,7 @@ class DynamicBtcWalletClient extends browser.DynamicWalletClient {
                     const { script, value } = input.witnessUtxo;
                     const p2pkh = bitcoin__namespace.payments.p2pkh({
                         hash: script.slice(2),
-                        network: getBitcoinNetwork(network)
+                        network: btcUtils.getBitcoinNetwork(network)
                     });
                     const scriptCode = p2pkh.output;
                     if (!scriptCode) throw new Error('Failed to generate scriptCode');
@@ -1331,7 +597,7 @@ class DynamicBtcWalletClient extends browser.DynamicWalletClient {
                         bitcoinConfig: completeBitcoinConfig,
                         onError
                     });
-                    const derSignature = convertSignatureToDER(signature);
+                    const derSignature = btcUtils.convertSignatureToDER(signature);
                     psbt.updateInput(i, {
                         partialSig: [
                             {
@@ -1381,7 +647,7 @@ class DynamicBtcWalletClient extends browser.DynamicWalletClient {
         }
         let addressType = walletProperties.addressType;
         if (!addressType && walletProperties.derivationPath) {
-            addressType = getAddressTypeFromDerivationPath(walletProperties.derivationPath);
+            addressType = btcUtils.getAddressTypeFromDerivationPath(walletProperties.derivationPath);
         }
         if (!addressType) {
             throw new Error('Address type not determined');
@@ -1391,17 +657,17 @@ class DynamicBtcWalletClient extends browser.DynamicWalletClient {
         }
         const bitcoinNetwork = network === 'testnet' ? bitcoin__namespace.networks.testnet : bitcoin__namespace.networks.bitcoin;
         // Fetch fee rates
-        const feeRates = await getFeeRates({
+        const feeRates = await btcUtils.getFeeRates({
             network
         });
         const feeRate = feeRates[feeRateLevel];
         // Fetch UTXOs
-        const utxos = await getUTXOs({
+        const utxos = await btcUtils.getUTXOs({
             address: senderAddress,
             network
         });
         // Select UTXOs
-        const { inputs, change, fee } = selectUTXOs({
+        const { inputs, change, fee } = btcUtils.selectUTXOs({
             utxos,
             amount: BigInt(amount),
             feeRate
@@ -1459,7 +725,7 @@ class DynamicBtcWalletClient extends browser.DynamicWalletClient {
    * @param network - The network
    * @returns The transaction hex
    */ async getTxHex(txid, network) {
-        const baseUrl = getDefaultRpcUrl(network);
+        const baseUrl = btcUtils.getDefaultRpcUrl(network);
         const response = await fetch(`${baseUrl}/tx/${txid}/hex`);
         if (!response.ok) {
             throw new Error(`Failed to fetch TX hex: ${response.statusText}`);
@@ -1490,6 +756,8 @@ class DynamicBtcWalletClient extends browser.DynamicWalletClient {
             sdkVersion,
             forwardMPCClient
         }, internalOptions), this.chainName = 'BTC';
+        // Initialize ECC library for bitcoinjs-lib
+        btcUtils.initEccLib(ecc);
     }
 }