@dynamic-labs-wallet/node-btc 0.0.0 → 0.0.255

package/index.esm.js

@@ -0,0 +1,608 @@
+import { DynamicWalletClient, getMPCChainConfig, getExternalServerKeyShareBackupInfo, WalletOperation } from '@dynamic-labs-wallet/node';
+import { handleAxiosError, BitcoinNetwork, BitcoinAddressType } from '@dynamic-labs-wallet/core';
+import { initEccLib, normalizePublicKey, publicKeyToBitcoinAddress, getAddressTypeFromDerivationPath, extractPublicKeyHex, calculateBip322Hash, calculateTaprootTweak, encodeBip322Signature, doesInputBelongToAddress, collectPSBTInputData, convertSignatureToTaprootBuffer, getBitcoinNetwork, convertSignatureToDER, privateKeyToWIF, wifToPrivateKey, getPublicKeyFromPrivateKey } from '@dynamic-labs-wallet/btc-utils';
+import * as bitcoin from 'bitcoinjs-lib';
+import * as ecc from 'tiny-secp256k1';
+import { Logger } from '@dynamic-labs/logger';
+import { AxiosError } from 'axios';
+
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+const logger = new Logger('DynamicWaasWalletClient');
+const logError = ({ message, error, context })=>{
+    if (error instanceof AxiosError) {
+        handleAxiosError(error, message, context, logger);
+    }
+    logger.error('[DynamicWaasWalletClient] Error in node-btc client', {
+        error: error instanceof Error ? error.message : String(error),
+        context
+    });
+};
+
+const ERROR_CREATE_WALLET_ACCOUNT = 'Error creating wallet account';
+const ERROR_ACCOUNT_ADDRESS_REQUIRED = 'Account address is required';
+const ERROR_SIGN_MESSAGE = 'Error signing message';
+const ERROR_SIGN_TRANSACTION = 'Error signing transaction';
+const ERROR_IMPORT_PRIVATE_KEY = 'Error importing private key';
+const ERROR_KEYGEN_FAILED = 'Error with keygen';
+
+// Initialize ECC library with tiny-secp256k1 for Node.js
+initEccLib(ecc);
+class DynamicBtcWalletClient extends DynamicWalletClient {
+    /**
+   * 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)
+   * - Algorithm selection is automatic based on addressType
+   * @param rawPublicKey - The raw public key to derive the account address from
+   * @param addressType - The address type to derive the account address for
+   * @param network - The network to derive the account address for
+   * @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);
+        return {
+            accountAddress
+        };
+    }
+    /**
+   * Gets wallet properties and derivation info for a given account address
+   * @param accountAddress - The account address
+   * @returns The wallet properties, derivation path, and address type
+   */ getWalletDerivationInfo(accountAddress) {
+        const walletProperties = this.walletMap[accountAddress];
+        if (!walletProperties) {
+            throw new Error('Wallet not found in walletMap');
+        }
+        const derivationPath = walletProperties.derivationPath;
+        if (!derivationPath) {
+            throw new Error('Derivation path missing in walletMap');
+        }
+        return {
+            walletProperties,
+            derivationPath,
+            addressType: getAddressTypeFromDerivationPath(derivationPath)
+        };
+    }
+    /**
+   * Verifies that the derived address matches the expected address
+   * @param rawPublicKey - The raw public key
+   * @param addressType - The address type
+   * @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);
+        if (derivedAddress !== expectedAddress) {
+            throw new Error(`Address verification failed: expected ${expectedAddress}, got ${derivedAddress}`);
+        }
+    }
+    /**
+   * Creates a new wallet account and stores the key shares in the wallet map.
+   * @param thresholdSignatureScheme - The threshold signature scheme to use for the wallet.
+   * @param password - The password to use for the wallet.
+   * @param onError - The function to call if an error occurs.
+   * @param backUpToClientShareService - Whether to back up the external server key shares to the client share service. By default, it is false.
+   * @param bitcoinConfig - Bitcoin configuration (addressType, network)
+   * @returns The account address, public key, raw public key, external server key shares, and wallet id.
+   */ async createWalletAccount({ thresholdSignatureScheme, password = undefined, onError, backUpToClientShareService = false, bitcoinConfig }) {
+        try {
+            const { addressType, network = BitcoinNetwork.MAINNET } = bitcoinConfig;
+            if (!addressType) {
+                throw new Error('addressType is required for BTC');
+            }
+            let ceremonyCeremonyCompleteResolver;
+            let ceremonyAccountAddress;
+            const ceremonyCompletePromise = new Promise((resolve)=>{
+                ceremonyCeremonyCompleteResolver = resolve;
+            });
+            // Generate key shares for given threshold signature scheme (TSS)
+            const { rawPublicKey, externalServerKeyShares } = await this.keyGen({
+                chainName: this.chainName,
+                thresholdSignatureScheme,
+                skipLock: true,
+                bitcoinConfig,
+                onError,
+                onCeremonyComplete: (accountAddress, walletId)=>{
+                    // Store the ceremony account address to ensure consistency
+                    ceremonyAccountAddress = accountAddress;
+                    // update wallet map
+                    const chainConfig = getMPCChainConfig(this.chainName, bitcoinConfig);
+                    this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress], {
+                        accountAddress,
+                        walletId,
+                        chainName: this.chainName,
+                        thresholdSignatureScheme,
+                        derivationPath: JSON.stringify(Object.fromEntries(chainConfig.derivationPath.map((value, index)=>[
+                                index,
+                                value
+                            ]))),
+                        externalServerKeySharesBackupInfo: getExternalServerKeyShareBackupInfo()
+                    });
+                    this.logger.debug('walletMap updated for wallet', {
+                        context: {
+                            accountAddress,
+                            walletId,
+                            walletMap: this.walletMap
+                        }
+                    });
+                    ceremonyCeremonyCompleteResolver(undefined);
+                }
+            });
+            await ceremonyCompletePromise;
+            if (!rawPublicKey || !externalServerKeyShares) {
+                throw new Error(ERROR_KEYGEN_FAILED);
+            }
+            const accountAddress = ceremonyAccountAddress || this.deriveAccountAddress({
+                rawPublicKey,
+                addressType,
+                network
+            }).accountAddress;
+            await this.storeEncryptedBackupByWalletWithRetry({
+                accountAddress,
+                externalServerKeyShares,
+                password,
+                backUpToClientShareService
+            });
+            const publicKeyHex = extractPublicKeyHex(rawPublicKey);
+            return {
+                accountAddress,
+                rawPublicKey,
+                publicKeyHex,
+                externalServerKeyShares
+            };
+        } catch (error) {
+            logError({
+                message: ERROR_CREATE_WALLET_ACCOUNT,
+                error: error,
+                context: {}
+            });
+            throw new Error(ERROR_CREATE_WALLET_ACCOUNT);
+        }
+    }
+    /**
+   * Signs a message for BTC using BIP-322 format
+   *
+   * The address type is automatically derived from the wallet's derivation path.
+   * Supports both TAPROOT (BIP-86) and NATIVE_SEGWIT (BIP-84) address types.
+   *
+   * @param message - The message to sign
+   * @param accountAddress - The account address
+   * @param network - The Bitcoin network (MAINNET or TESTNET)
+   * @param password - Optional password for encrypted backup shares
+   * @param externalServerKeyShares - Optional external server key shares
+   * @param context - Optional. Sign message context for API tracking
+   * @param onError - Optional. Error callback function
+   * @returns Promise resolving to the BIP-322 signature as a base64 string
+   * @throws Error if required parameters are missing, derivation path is invalid, or signing fails
+   */ async signMessage({ message, accountAddress, network, password = undefined, externalServerKeyShares, context, onError }) {
+        try {
+            var _this_walletMap_accountAddress;
+            if (!accountAddress) {
+                throw new Error(ERROR_ACCOUNT_ADDRESS_REQUIRED);
+            }
+            const { derivationPath, addressType } = this.getWalletDerivationInfo(accountAddress);
+            // Attempt to recover key shares from backup if not provided
+            await this.ensureKeySharesRecovered({
+                accountAddress,
+                password,
+                walletOperation: WalletOperation.SIGN_MESSAGE,
+                externalServerKeyShares,
+                errorMessage: 'External server key shares are required to sign a message. No backup shares available for recovery.'
+            });
+            const resolvedExternalServerKeyShares = externalServerKeyShares != null ? externalServerKeyShares : (_this_walletMap_accountAddress = this.walletMap[accountAddress]) == null ? void 0 : _this_walletMap_accountAddress.externalServerKeyShares;
+            if (!resolvedExternalServerKeyShares || resolvedExternalServerKeyShares.length === 0) {
+                throw new Error('External server key shares are required to sign a message');
+            }
+            const bitcoinConfig = {
+                addressType,
+                network
+            };
+            const derivedPublicKey = await this.derivePublicKey({
+                chainName: this.chainName,
+                keyShare: resolvedExternalServerKeyShares[0],
+                derivationPath: new Uint32Array(Object.values(JSON.parse(derivationPath))),
+                bitcoinConfig
+            });
+            if (!derivedPublicKey) {
+                throw new Error('Failed to derive public key');
+            }
+            const pubKey = normalizePublicKey(derivedPublicKey, addressType);
+            this.verifyWalletAddress(derivedPublicKey, addressType, network, accountAddress);
+            // Prepare BIP-322 Transactions and calculate hash
+            const { formattedMessage, toSignPsbt } = calculateBip322Hash(message, pubKey, addressType, network, ecc);
+            // Prepare tweak for Taproot in case of BIP340
+            let tweak;
+            if (addressType === BitcoinAddressType.TAPROOT) {
+                tweak = calculateTaprootTweak(pubKey);
+            }
+            // Build complete bitcoinConfig with addressType and tweak
+            const completeBitcoinConfig = _extends({}, bitcoinConfig, {
+                addressType,
+                tweak
+            });
+            // Sign the message using MPC
+            const signature = await this.sign({
+                message: formattedMessage,
+                accountAddress,
+                chainName: this.chainName,
+                password,
+                externalServerKeyShares: resolvedExternalServerKeyShares,
+                isFormatted: true,
+                context: context != null ? context : {
+                    btcMessage: message
+                },
+                bitcoinConfig: completeBitcoinConfig,
+                onError
+            });
+            const bip322Signature = encodeBip322Signature(toSignPsbt, pubKey, signature, addressType);
+            return bip322Signature;
+        } catch (error) {
+            logError({
+                message: ERROR_SIGN_MESSAGE,
+                error: error,
+                context: {
+                    accountAddress
+                }
+            });
+            if (onError) {
+                onError(error);
+            }
+            throw new Error(ERROR_SIGN_MESSAGE);
+        }
+    }
+    /**
+   * Signs a Bitcoin transaction (PSBT)
+   *
+   * The address type is automatically derived from the wallet's derivation path.
+   * Only inputs belonging to the sender address are signed. Supports both TAPROOT
+   * (BIP-341) and Native SegWit (BIP-143) signing methods.
+   *
+   * @param transaction - The PSBT to sign as a base64 string
+   * @param senderAddress - The sender address (must match inputs to be signed)
+   * @param network - The Bitcoin network (MAINNET or TESTNET)
+   * @param password - Optional password for encrypted backup shares
+   * @param externalServerKeyShares - Optional external server key shares
+   * @param context - Optional. Sign message context for API tracking
+   * @param onError - Optional. Error callback function
+   * @returns Promise resolving to the signed PSBT as a base64 string
+   * @throws Error if required parameters are missing, no inputs belong to sender address, or signing fails
+   */ async signTransaction({ transaction, senderAddress, network, password = undefined, externalServerKeyShares, context, onError }) {
+        try {
+            await this.verifyPassword({
+                accountAddress: senderAddress,
+                password,
+                walletOperation: WalletOperation.SIGN_TRANSACTION
+            });
+            if (!senderAddress) {
+                throw new Error(ERROR_ACCOUNT_ADDRESS_REQUIRED);
+            }
+            const { derivationPath, addressType } = this.getWalletDerivationInfo(senderAddress);
+            // Attempt to recover key shares from backup if not provided
+            await this.ensureKeySharesRecovered({
+                accountAddress: senderAddress,
+                password,
+                walletOperation: WalletOperation.SIGN_TRANSACTION,
+                externalServerKeyShares,
+                errorMessage: 'External server key shares are required to sign transaction. No backup shares available for recovery.'
+            });
+            const updatedWalletProperties = this.walletMap[senderAddress];
+            if (!updatedWalletProperties) {
+                throw new Error('Wallet not found in walletMap after key share recovery');
+            }
+            const resolvedExternalServerKeyShares = externalServerKeyShares || updatedWalletProperties.externalServerKeyShares;
+            if (!resolvedExternalServerKeyShares || resolvedExternalServerKeyShares.length === 0) {
+                throw new Error('External server key shares are required to sign transaction. No backup shares available for recovery.');
+            }
+            const bitcoinConfig = {
+                addressType,
+                network
+            };
+            const psbt = bitcoin.Psbt.fromBase64(transaction);
+            const derivedPublicKey = await this.derivePublicKey({
+                chainName: this.chainName,
+                keyShare: resolvedExternalServerKeyShares[0],
+                derivationPath: new Uint32Array(Object.values(JSON.parse(derivationPath))),
+                bitcoinConfig
+            });
+            if (!derivedPublicKey) {
+                throw new Error('Failed to derive public key');
+            }
+            const pubKey = 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));
+            if (inputsToSign.length === 0) {
+                throw new Error('No inputs found that belong to the sender address');
+            }
+            if (addressType === BitcoinAddressType.TAPROOT) {
+                const tweak = calculateTaprootTweak(pubKey);
+                const completeBitcoinConfig = _extends({}, bitcoinConfig, {
+                    addressType,
+                    tweak
+                });
+                const { prevOutScripts, values } = collectPSBTInputData(psbt);
+                await Promise.all(inputsToSign.map(async ({ input, index: i })=>{
+                    if (!input.witnessUtxo) {
+                        throw new Error(`Input ${i} missing witnessUtxo`);
+                    }
+                    const hash = Buffer.from(tx.hashForWitnessV1(i, prevOutScripts, values, bitcoin.Transaction.SIGHASH_DEFAULT));
+                    const signature = await this.sign({
+                        message: new Uint8Array(hash),
+                        accountAddress: senderAddress,
+                        chainName: this.chainName,
+                        password,
+                        externalServerKeyShares: resolvedExternalServerKeyShares,
+                        isFormatted: true,
+                        context,
+                        bitcoinConfig: completeBitcoinConfig,
+                        onError
+                    });
+                    const sigBuffer = convertSignatureToTaprootBuffer(signature);
+                    psbt.updateInput(i, {
+                        tapKeySig: sigBuffer
+                    });
+                }));
+            } else {
+                // Native SegWit (P2WPKH) or other ECDSA-based signing
+                const completeBitcoinConfig = _extends({}, bitcoinConfig, {
+                    addressType
+                });
+                await Promise.all(inputsToSign.map(async ({ input, index: i })=>{
+                    if (!input.witnessUtxo) {
+                        throw new Error(`Input ${i} missing witnessUtxo`);
+                    }
+                    const { script, value } = input.witnessUtxo;
+                    const p2pkh = bitcoin.payments.p2pkh({
+                        hash: script.slice(2),
+                        network: getBitcoinNetwork(network)
+                    });
+                    const scriptCode = p2pkh.output;
+                    if (!scriptCode) {
+                        throw new Error('Failed to generate scriptCode');
+                    }
+                    const hash = tx.hashForWitnessV0(i, scriptCode, value, bitcoin.Transaction.SIGHASH_ALL);
+                    const signature = await this.sign({
+                        message: new Uint8Array(hash),
+                        accountAddress: senderAddress,
+                        chainName: this.chainName,
+                        password,
+                        externalServerKeyShares: resolvedExternalServerKeyShares,
+                        isFormatted: true,
+                        context,
+                        bitcoinConfig: completeBitcoinConfig,
+                        onError
+                    });
+                    const derSignature = convertSignatureToDER(signature);
+                    psbt.updateInput(i, {
+                        partialSig: [
+                            {
+                                pubkey: pubKey,
+                                signature: new Uint8Array(derSignature)
+                            }
+                        ]
+                    });
+                }));
+            }
+            // Return signed PSBT in base64 format (not finalized)
+            return psbt.toBase64();
+        } catch (error) {
+            logError({
+                message: ERROR_SIGN_TRANSACTION,
+                error: error,
+                context: {
+                    senderAddress
+                }
+            });
+            if (onError) {
+                onError(error);
+            }
+            throw error;
+        }
+    }
+    /**
+   * Exports the private key for a wallet
+   * @param accountAddress - The account address to export the private key for
+   * @param password - The password for encrypted backup shares
+   * @param externalServerKeyShares - Optional external server key shares
+   * @returns The private key in WIF format
+   */ async exportPrivateKey({ accountAddress, password = undefined, externalServerKeyShares }) {
+        await this.verifyPassword({
+            accountAddress,
+            password,
+            walletOperation: WalletOperation.EXPORT_PRIVATE_KEY
+        });
+        // Attempt to recover key shares from backup if not provided
+        await this.ensureKeySharesRecovered({
+            accountAddress,
+            password,
+            walletOperation: WalletOperation.EXPORT_PRIVATE_KEY,
+            externalServerKeyShares,
+            errorMessage: 'External server key shares are required to export private key. No backup shares available for recovery.'
+        });
+        // Re-read wallet from map after recovery (it may have been updated with recovered shares)
+        const updatedWalletProperties = this.walletMap[accountAddress];
+        if (!updatedWalletProperties) {
+            throw new Error('Wallet not found in walletMap after recovery');
+        }
+        const derivationPath = updatedWalletProperties.derivationPath;
+        if (!derivationPath) {
+            throw new Error('Derivation path missing in walletMap');
+        }
+        // Derive address type from derivation path for bitcoinConfig
+        const addressType = getAddressTypeFromDerivationPath(derivationPath);
+        const network = BitcoinNetwork.MAINNET; // Default to mainnet, could be derived from wallet
+        const bitcoinConfig = {
+            addressType,
+            network
+        };
+        // Get key shares from wallet map if not provided (recovered from backup)
+        const resolvedExternalServerKeyShares = externalServerKeyShares != null ? externalServerKeyShares : updatedWalletProperties.externalServerKeyShares;
+        const { derivedPrivateKey } = await this.exportKey({
+            accountAddress,
+            chainName: this.chainName,
+            password,
+            externalServerKeyShares: resolvedExternalServerKeyShares,
+            bitcoinConfig
+        });
+        if (!derivedPrivateKey) {
+            throw new Error('Derived private key is undefined');
+        }
+        // Convert private key to WIF format
+        const wifPrivateKey = privateKeyToWIF(derivedPrivateKey, network);
+        return wifPrivateKey;
+    }
+    /**
+   * Exports the private key for a given account address offline using key shares
+   * @param keyShares - The key shares to export the private key for
+   * @param derivationPath - Optional derivation path
+   * @param bitcoinConfig - Bitcoin configuration (address type, network)
+   * @returns The private key in WIF format
+   */ async offlineExportPrivateKey({ keyShares, derivationPath, bitcoinConfig }) {
+        const { derivedPrivateKey } = await this.offlineExportKey({
+            chainName: this.chainName,
+            keyShares,
+            derivationPath
+        });
+        if (!derivedPrivateKey) {
+            throw new Error('Derived private key is undefined');
+        }
+        const network = (bitcoinConfig == null ? void 0 : bitcoinConfig.network) || BitcoinNetwork.MAINNET;
+        // Convert private key to WIF format
+        const wifPrivateKey = privateKeyToWIF(derivedPrivateKey, network);
+        return wifPrivateKey;
+    }
+    /**
+   * Imports a private key and stores the key shares in the wallet map.
+   * @param privateKey - The private key to import (WIF format)
+   * @param chainName - The chain name to use for the wallet
+   * @param thresholdSignatureScheme - The threshold signature scheme to use for the wallet
+   * @param password - The password to use for the wallet
+   * @param onError - The function to call if an error occurs
+   * @param backUpToClientShareService - Whether to back up the external server key shares to the client share service. By default, it is false.
+   * @param bitcoinConfig - Bitcoin configuration (addressType, network)
+   * @returns The account address, public key, raw public key, external server key shares
+   */ async importPrivateKey({ privateKey, chainName, thresholdSignatureScheme, password = undefined, backUpToClientShareService = false, onError, bitcoinConfig }) {
+        try {
+            const { addressType, network = BitcoinNetwork.MAINNET } = bitcoinConfig;
+            if (!addressType) {
+                throw new Error('addressType is required for BTC importPrivateKey');
+            }
+            if (addressType !== BitcoinAddressType.NATIVE_SEGWIT && addressType !== BitcoinAddressType.TAPROOT) {
+                throw new Error(`Invalid addressType: ${addressType}. Must be one of: ${BitcoinAddressType.NATIVE_SEGWIT}, ${BitcoinAddressType.TAPROOT}`);
+            }
+            let ceremonyCeremonyCompleteResolver;
+            let ceremonyAccountAddress;
+            const ceremonyCompletePromise = new Promise((resolve)=>{
+                ceremonyCeremonyCompleteResolver = resolve;
+            });
+            // Convert WIF to private key hex
+            const formattedPrivateKey = wifToPrivateKey(privateKey, network);
+            // Get public key from private key to verify address
+            const derivedPublicKey = await getPublicKeyFromPrivateKey(privateKey, addressType, ecc, network);
+            const { accountAddress: expectedAddress } = this.deriveAccountAddress({
+                rawPublicKey: derivedPublicKey,
+                addressType,
+                network
+            });
+            const { rawPublicKey, externalServerKeyShares } = await this.importRawPrivateKey({
+                chainName,
+                privateKey: formattedPrivateKey,
+                thresholdSignatureScheme,
+                bitcoinConfig,
+                onError,
+                onCeremonyComplete: (accountAddress, walletId)=>{
+                    // Store the ceremony account address to ensure consistency
+                    ceremonyAccountAddress = accountAddress;
+                    // Verify address matches
+                    if (accountAddress !== expectedAddress) {
+                        throw new Error(`Public address mismatch: derived address ${accountAddress} !== expected address ${expectedAddress}`);
+                    }
+                    // update wallet map
+                    const chainConfig = getMPCChainConfig(this.chainName, bitcoinConfig);
+                    this.walletMap[accountAddress] = _extends({}, this.walletMap[accountAddress], {
+                        accountAddress,
+                        walletId,
+                        chainName: this.chainName,
+                        thresholdSignatureScheme,
+                        derivationPath: JSON.stringify(Object.fromEntries(chainConfig.derivationPath.map((value, index)=>[
+                                index,
+                                value
+                            ]))),
+                        externalServerKeySharesBackupInfo: getExternalServerKeyShareBackupInfo()
+                    });
+                    ceremonyCeremonyCompleteResolver(undefined);
+                }
+            });
+            // Wait for the ceremony to complete before proceeding
+            await ceremonyCompletePromise;
+            if (!rawPublicKey || !externalServerKeyShares) {
+                throw new Error('Error creating wallet account');
+            }
+            // Use the ceremony account address if available, otherwise derive it from raw public key
+            const accountAddress = ceremonyAccountAddress || this.deriveAccountAddress({
+                rawPublicKey,
+                addressType,
+                network
+            }).accountAddress;
+            if (accountAddress !== expectedAddress) {
+                throw new Error(`Public address mismatch: derived address ${accountAddress} !== expected address ${expectedAddress}`);
+            }
+            await this.storeEncryptedBackupByWalletWithRetry({
+                accountAddress,
+                externalServerKeyShares,
+                password,
+                backUpToClientShareService
+            });
+            const publicKeyHex = extractPublicKeyHex(rawPublicKey);
+            return {
+                accountAddress,
+                rawPublicKey,
+                publicKeyHex,
+                externalServerKeyShares
+            };
+        } catch (error) {
+            logError({
+                message: ERROR_IMPORT_PRIVATE_KEY,
+                error: error,
+                context: {}
+            });
+            throw new Error(ERROR_IMPORT_PRIVATE_KEY);
+        }
+    }
+    /**
+   * Gets the Bitcoin wallets
+   * @returns The Bitcoin wallets
+   */ async getBitcoinWallets() {
+        const wallets = await this.getWallets(); // NOSONAR
+        const btcWallets = wallets.filter((wallet)=>{
+            var _wallet_chainName;
+            const chainName = (_wallet_chainName = wallet.chainName) == null ? void 0 : _wallet_chainName.toLowerCase();
+            return chainName === 'btc' || chainName === 'bip122';
+        });
+        return btcWallets;
+    }
+    constructor({ environmentId, baseApiUrl, baseMPCRelayApiUrl, enableMPCAccelerator }){
+        super({
+            environmentId,
+            baseApiUrl,
+            baseMPCRelayApiUrl,
+            enableMPCAccelerator
+        }), this.chainName = 'BTC';
+    }
+}
+
+export { DynamicBtcWalletClient, ERROR_ACCOUNT_ADDRESS_REQUIRED, ERROR_CREATE_WALLET_ACCOUNT, ERROR_IMPORT_PRIVATE_KEY, ERROR_KEYGEN_FAILED, ERROR_SIGN_MESSAGE, ERROR_SIGN_TRANSACTION };

package/package.json

@@ -1 +1,43 @@
-{ "name": "@dynamic-labs-wallet/node-btc", "version": "0.0.0" }
+{
+  "name": "@dynamic-labs-wallet/node-btc",
+  "version": "0.0.255",
+  "license": "MIT",
+  "type": "module",
+  "dependencies": {
+    "@dynamic-labs-wallet/core": "0.0.255",
+    "@dynamic-labs-wallet/node": "0.0.255",
+    "@dynamic-labs-wallet/btc-utils": "0.0.255",
+    "@dynamic-labs/logger": "^4.25.3",
+    "@dynamic-labs/sdk-api-core": "^0.0.801",
+    "axios": "1.13.2",
+    "bitcoinjs-lib": "^7.0.0",
+    "tiny-secp256k1": "^2.2.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "nx": {
+    "sourceRoot": "packages/node-btc/src",
+    "projectType": "library",
+    "name": "node-btc",
+    "targets": {
+      "build": {}
+    }
+  },
+  "main": "./index.cjs.js",
+  "module": "./index.esm.js",
+  "types": "./index.esm.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./index.esm.d.ts",
+      "import": "./index.esm.js",
+      "require": "./index.cjs.js"
+    }
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0",
+    "@types/http-errors": "^2.0.0"
+  }
+}