@dynamic-labs/bitcoin 4.52.5 → 4.53.0

package/src/services/MempoolApiService.cjs

@@ -0,0 +1,127 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var logger$1 = require('@dynamic-labs/logger');
+var utils = require('@dynamic-labs/utils');
+require('sats-connect');
+require('bitcoinjs-lib');
+require('@dynamic-labs/wallet-connector-core');
+require('@dynamic-labs/wallet-book');
+require('@dynamic-labs/sdk-api-core');
+require('@wallet-standard/app');
+var getMempoolApiUrl = require('../utils/getMempoolApiUrl.cjs');
+var _const = require('../const.cjs');
+require('jsontokens');
+require('../connectors/DynamicWaasBitcoinConnector/DynamicWaasBitcoinConnector.cjs');
+
+const logger = new logger$1.Logger('MempoolApiService');
+/**
+ * Service for interacting with the mempool.space API
+ */
+class MempoolApiService {
+    /**
+     * Gets the base URL for the mempool API based on the address network
+     * @param address - Bitcoin address to determine network
+     * @returns The mempool API base URL
+     */
+    getBaseUrl(address) {
+        return getMempoolApiUrl.getMempoolApiUrl(address);
+    }
+    /**
+     * Gets UTXOs for a Bitcoin address from mempool.space API
+     * @param address - The Bitcoin address to get UTXOs for
+     * @returns Array of UTXOs
+     * @throws {DynamicError} If fetching UTXOs fails
+     */
+    getUTXOs(address) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const baseUrl = this.getBaseUrl(address);
+                const response = yield fetch(`${baseUrl}/address/${address}/utxo`);
+                if (!response.ok) {
+                    throw new utils.DynamicError(`Failed to fetch UTXOs: ${response.statusText}`);
+                }
+                return response.json();
+            }
+            catch (error) {
+                logger.error('Error fetching UTXOs:', error);
+                throw new utils.DynamicError('Failed to fetch UTXOs');
+            }
+        });
+    }
+    /**
+     * Gets fee recommendations from mempool.space API
+     * @param address - The Bitcoin address to determine the network from
+     * @returns Fee recommendation data
+     * @throws {Error} If fetching fee recommendations fails
+     */
+    getFeeRecommendations(address) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const baseUrl = this.getBaseUrl(address);
+            const url = `${baseUrl}/v1/fees/recommended`;
+            const response = yield fetch(url);
+            if (!response.ok) {
+                throw new Error('Failed to fetch fee estimate');
+            }
+            return response.json();
+        });
+    }
+    /**
+     * Estimates transaction fees based on number of inputs and outputs
+     * @param address - The Bitcoin address to determine the network from
+     * @param numInputs - Number of transaction inputs
+     * @param numOutputs - Number of transaction outputs
+     * @returns Estimated fee in satoshis
+     */
+    estimateTransactionFee(address, numInputs, numOutputs) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const feeData = yield this.getFeeRecommendations(address);
+                const feePerByte = feeData.hourFee || feeData.economyFee || 1;
+                const estimatedFee = feePerByte *
+                    (_const.INPUT_BYTE_SIZE_UPPER_BOUND * numInputs +
+                        _const.OUTPUT_BYTE_SIZE_UPPER_BOUND * numOutputs) +
+                    _const.MIN_RELAY_FEE;
+                return estimatedFee;
+            }
+            catch (error) {
+                logger.error('Error fetching fee estimate:', error);
+                // Return a conservative default fee estimate
+                return _const.DEFAULT_FEE_ESTIMATE;
+            }
+        });
+    }
+    /**
+     * Sends a raw Bitcoin transaction to the mempool
+     * @param address - The Bitcoin address to determine the network from
+     * @param rawTransaction - The raw transaction in hex format
+     * @returns The transaction ID
+     * @throws {DynamicError} If no transaction is specified or sending fails
+     */
+    sendRawTransaction(address, rawTransaction) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!rawTransaction) {
+                throw new utils.DynamicError('No transaction specified!');
+            }
+            const baseUrl = this.getBaseUrl(address);
+            const response = yield fetch(`${baseUrl}/tx`, {
+                body: rawTransaction,
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                method: 'POST',
+            });
+            if (!response.ok) {
+                const error = yield response.text();
+                logger.debug(`sendRawTransaction - response not ok: ${JSON.stringify(error)}`);
+                throw new utils.DynamicError('sendRawTransaction - failed to send transaction');
+            }
+            return response.text();
+        });
+    }
+}
+
+exports.MempoolApiService = MempoolApiService;

package/src/services/MempoolApiService.d.ts

@@ -0,0 +1,42 @@
+import type { FeeRecommendations, UTXO } from '../types';
+/**
+ * Service for interacting with the mempool.space API
+ */
+export declare class MempoolApiService {
+    /**
+     * Gets the base URL for the mempool API based on the address network
+     * @param address - Bitcoin address to determine network
+     * @returns The mempool API base URL
+     */
+    private getBaseUrl;
+    /**
+     * Gets UTXOs for a Bitcoin address from mempool.space API
+     * @param address - The Bitcoin address to get UTXOs for
+     * @returns Array of UTXOs
+     * @throws {DynamicError} If fetching UTXOs fails
+     */
+    getUTXOs(address: string): Promise<UTXO[]>;
+    /**
+     * Gets fee recommendations from mempool.space API
+     * @param address - The Bitcoin address to determine the network from
+     * @returns Fee recommendation data
+     * @throws {Error} If fetching fee recommendations fails
+     */
+    getFeeRecommendations(address: string): Promise<FeeRecommendations>;
+    /**
+     * Estimates transaction fees based on number of inputs and outputs
+     * @param address - The Bitcoin address to determine the network from
+     * @param numInputs - Number of transaction inputs
+     * @param numOutputs - Number of transaction outputs
+     * @returns Estimated fee in satoshis
+     */
+    estimateTransactionFee(address: string, numInputs: number, numOutputs: number): Promise<number>;
+    /**
+     * Sends a raw Bitcoin transaction to the mempool
+     * @param address - The Bitcoin address to determine the network from
+     * @param rawTransaction - The raw transaction in hex format
+     * @returns The transaction ID
+     * @throws {DynamicError} If no transaction is specified or sending fails
+     */
+    sendRawTransaction(address: string, rawTransaction: string): Promise<string>;
+}

package/src/services/MempoolApiService.js

@@ -0,0 +1,123 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+import { Logger } from '@dynamic-labs/logger';
+import { DynamicError } from '@dynamic-labs/utils';
+import 'sats-connect';
+import 'bitcoinjs-lib';
+import '@dynamic-labs/wallet-connector-core';
+import '@dynamic-labs/wallet-book';
+import '@dynamic-labs/sdk-api-core';
+import '@wallet-standard/app';
+import { getMempoolApiUrl } from '../utils/getMempoolApiUrl.js';
+import { INPUT_BYTE_SIZE_UPPER_BOUND, OUTPUT_BYTE_SIZE_UPPER_BOUND, MIN_RELAY_FEE, DEFAULT_FEE_ESTIMATE } from '../const.js';
+import 'jsontokens';
+import '../connectors/DynamicWaasBitcoinConnector/DynamicWaasBitcoinConnector.js';
+
+const logger = new Logger('MempoolApiService');
+/**
+ * Service for interacting with the mempool.space API
+ */
+class MempoolApiService {
+    /**
+     * Gets the base URL for the mempool API based on the address network
+     * @param address - Bitcoin address to determine network
+     * @returns The mempool API base URL
+     */
+    getBaseUrl(address) {
+        return getMempoolApiUrl(address);
+    }
+    /**
+     * Gets UTXOs for a Bitcoin address from mempool.space API
+     * @param address - The Bitcoin address to get UTXOs for
+     * @returns Array of UTXOs
+     * @throws {DynamicError} If fetching UTXOs fails
+     */
+    getUTXOs(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const baseUrl = this.getBaseUrl(address);
+                const response = yield fetch(`${baseUrl}/address/${address}/utxo`);
+                if (!response.ok) {
+                    throw new DynamicError(`Failed to fetch UTXOs: ${response.statusText}`);
+                }
+                return response.json();
+            }
+            catch (error) {
+                logger.error('Error fetching UTXOs:', error);
+                throw new DynamicError('Failed to fetch UTXOs');
+            }
+        });
+    }
+    /**
+     * Gets fee recommendations from mempool.space API
+     * @param address - The Bitcoin address to determine the network from
+     * @returns Fee recommendation data
+     * @throws {Error} If fetching fee recommendations fails
+     */
+    getFeeRecommendations(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const baseUrl = this.getBaseUrl(address);
+            const url = `${baseUrl}/v1/fees/recommended`;
+            const response = yield fetch(url);
+            if (!response.ok) {
+                throw new Error('Failed to fetch fee estimate');
+            }
+            return response.json();
+        });
+    }
+    /**
+     * Estimates transaction fees based on number of inputs and outputs
+     * @param address - The Bitcoin address to determine the network from
+     * @param numInputs - Number of transaction inputs
+     * @param numOutputs - Number of transaction outputs
+     * @returns Estimated fee in satoshis
+     */
+    estimateTransactionFee(address, numInputs, numOutputs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const feeData = yield this.getFeeRecommendations(address);
+                const feePerByte = feeData.hourFee || feeData.economyFee || 1;
+                const estimatedFee = feePerByte *
+                    (INPUT_BYTE_SIZE_UPPER_BOUND * numInputs +
+                        OUTPUT_BYTE_SIZE_UPPER_BOUND * numOutputs) +
+                    MIN_RELAY_FEE;
+                return estimatedFee;
+            }
+            catch (error) {
+                logger.error('Error fetching fee estimate:', error);
+                // Return a conservative default fee estimate
+                return DEFAULT_FEE_ESTIMATE;
+            }
+        });
+    }
+    /**
+     * Sends a raw Bitcoin transaction to the mempool
+     * @param address - The Bitcoin address to determine the network from
+     * @param rawTransaction - The raw transaction in hex format
+     * @returns The transaction ID
+     * @throws {DynamicError} If no transaction is specified or sending fails
+     */
+    sendRawTransaction(address, rawTransaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!rawTransaction) {
+                throw new DynamicError('No transaction specified!');
+            }
+            const baseUrl = this.getBaseUrl(address);
+            const response = yield fetch(`${baseUrl}/tx`, {
+                body: rawTransaction,
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                method: 'POST',
+            });
+            if (!response.ok) {
+                const error = yield response.text();
+                logger.debug(`sendRawTransaction - response not ok: ${JSON.stringify(error)}`);
+                throw new DynamicError('sendRawTransaction - failed to send transaction');
+            }
+            return response.text();
+        });
+    }
+}
+
+export { MempoolApiService };

package/src/services/PsbtBuilderService.cjs

@@ -0,0 +1,132 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var ecc = require('@bitcoinerlab/secp256k1');
+var ecpair = require('ecpair');
+var bitcoinjsLib = require('bitcoinjs-lib');
+var logger$1 = require('@dynamic-labs/logger');
+var utils = require('@dynamic-labs/utils');
+var _const = require('../const.cjs');
+var getBitcoinNetwork = require('../utils/getBitcoinNetwork/getBitcoinNetwork.cjs');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var ecc__default = /*#__PURE__*/_interopDefaultLegacy(ecc);
+
+const logger = new logger$1.Logger('PsbtBuilderService');
+/**
+ * Service for building Bitcoin PSBTs
+ */
+class PsbtBuilderService {
+    constructor(mempoolApiService) {
+        this.mempoolApiService = mempoolApiService;
+    }
+    /**
+     * Builds a PSBT for a Bitcoin transaction with real UTXOs
+     * @param options - Options for building the PSBT
+     * @returns A PSBT in Base64 format
+     * @throws {DynamicError} If insufficient funds, no UTXOs, or other errors
+     */
+    buildPsbt(options) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const { accountAddress, recipientAddress, amountInSatoshis, publicKeyHex, network, } = options;
+            if (amountInSatoshis <= BigInt(0)) {
+                throw new utils.DynamicError('Amount must be greater than 0');
+            }
+            // Get UTXOs for the account address
+            const utxos = yield this.mempoolApiService.getUTXOs(accountAddress);
+            if (utxos.length === 0) {
+                throw new utils.DynamicError('No UTXOs found for this address');
+            }
+            // Get public key for creating output scripts
+            const publicKeyBuffer = Buffer.from(publicKeyHex, 'hex');
+            // Use ECPair to ensure the public key is properly formatted for bitcoinjs-lib
+            const ECPair = ecpair.ECPairFactory(ecc__default["default"]);
+            const publicKeyPair = ECPair.fromPublicKey(publicKeyBuffer, {
+                compressed: true,
+            });
+            // Calculate total available
+            const totalToSpend = utxos.reduce((total, utxo) => total + utxo.value, 0);
+            // Initial fee estimate with 1 output (recipient only)
+            let feeEstimate = yield this.mempoolApiService.estimateTransactionFee(accountAddress, utxos.length, 1);
+            // Calculate change amount with 1-output fee estimate
+            let maxToSpend = totalToSpend - feeEstimate;
+            let changeAmount = BigInt(maxToSpend) - amountInSatoshis;
+            // If change will be above dust limit, re-estimate fees for 2 outputs
+            if (changeAmount > 0 && Number(changeAmount) >= _const.DUST_LIMIT) {
+                feeEstimate = yield this.mempoolApiService.estimateTransactionFee(accountAddress, utxos.length, 2);
+                maxToSpend = totalToSpend - feeEstimate;
+                changeAmount = BigInt(maxToSpend) - amountInSatoshis;
+            }
+            if (maxToSpend < Number(amountInSatoshis)) {
+                const amountInSatoshisNumber = Number(amountInSatoshis);
+                throw new utils.DynamicError(`Insufficient funds. Available: ${maxToSpend / _const.SATOSHIS_PER_BTC} BTC (${maxToSpend} satoshis), Required: ${amountInSatoshisNumber / _const.SATOSHIS_PER_BTC} BTC (${amountInSatoshisNumber} satoshis)`);
+            }
+            // Create PSBT
+            const psbt = new bitcoinjsLib.Psbt({ network });
+            // Add inputs from UTXOs (only supporting native SegWit P2WPKH)
+            for (const utxo of utxos) {
+                // SegWit (P2WPKH) addresses
+                // For SegWit, we need the public key to construct the witness output script
+                const outputScript = bitcoinjsLib.payments.p2wpkh({
+                    network,
+                    pubkey: publicKeyPair.publicKey,
+                }).output;
+                if (!outputScript) {
+                    throw new utils.DynamicError('Failed to create segwit output script');
+                }
+                // Convert txid from hex string to Buffer and reverse it (Bitcoin uses little-endian)
+                // The txid from the API is in big-endian format, but bitcoinjs-lib expects little-endian
+                const txidBuffer = Buffer.from(utxo.txid, 'hex').reverse();
+                psbt.addInput({
+                    hash: txidBuffer,
+                    index: utxo.vout,
+                    witnessUtxo: {
+                        script: outputScript,
+                        value: utxo.value,
+                    },
+                });
+            }
+            // Add recipient output
+            const amountInSatoshisNumber = Number(amountInSatoshis);
+            if (amountInSatoshisNumber < _const.DUST_LIMIT) {
+                throw new utils.DynamicError(`Amount is below dust limit of ${_const.DUST_LIMIT} satoshis (${_const.DUST_LIMIT / _const.SATOSHIS_PER_BTC} BTC)`);
+            }
+            psbt.addOutput({
+                script: bitcoinjsLib.address.toOutputScript(recipientAddress, network),
+                value: amountInSatoshisNumber,
+            });
+            // Add change output if needed
+            const changeAmountNumber = Number(changeAmount);
+            if (changeAmount > 0 && changeAmountNumber >= _const.DUST_LIMIT) {
+                psbt.addOutput({
+                    script: bitcoinjsLib.address.toOutputScript(accountAddress, network),
+                    value: changeAmountNumber,
+                });
+            }
+            logger.debug(`buildPsbt created PSBT for recipientAddress: ${recipientAddress}, amount: ${amountInSatoshisNumber} satoshis (${amountInSatoshisNumber / _const.SATOSHIS_PER_BTC} BTC), change: ${changeAmountNumber} satoshis`);
+            return psbt.toBase64();
+        });
+    }
+    /**
+     * Helper method to create BuildPsbtOptions from transaction and account details
+     * @param accountAddress - The account address
+     * @param transaction - The Bitcoin transaction
+     * @param publicKeyHex - The public key in hex format
+     * @returns BuildPsbtOptions
+     */
+    static createBuildOptions(accountAddress, transaction, publicKeyHex) {
+        return {
+            accountAddress,
+            amountInSatoshis: transaction.amount,
+            network: getBitcoinNetwork.getBitcoinNetwork(accountAddress),
+            publicKeyHex,
+            recipientAddress: transaction.recipientAddress,
+        };
+    }
+}
+
+exports.PsbtBuilderService = PsbtBuilderService;

package/src/services/PsbtBuilderService.d.ts

@@ -0,0 +1,27 @@
+import type { BuildPsbtOptions } from '../types';
+import { MempoolApiService } from './MempoolApiService';
+/**
+ * Service for building Bitcoin PSBTs
+ */
+export declare class PsbtBuilderService {
+    private mempoolApiService;
+    constructor(mempoolApiService: MempoolApiService);
+    /**
+     * Builds a PSBT for a Bitcoin transaction with real UTXOs
+     * @param options - Options for building the PSBT
+     * @returns A PSBT in Base64 format
+     * @throws {DynamicError} If insufficient funds, no UTXOs, or other errors
+     */
+    buildPsbt(options: BuildPsbtOptions): Promise<string>;
+    /**
+     * Helper method to create BuildPsbtOptions from transaction and account details
+     * @param accountAddress - The account address
+     * @param transaction - The Bitcoin transaction
+     * @param publicKeyHex - The public key in hex format
+     * @returns BuildPsbtOptions
+     */
+    static createBuildOptions(accountAddress: string, transaction: {
+        amount: bigint;
+        recipientAddress: string;
+    }, publicKeyHex: string): BuildPsbtOptions;
+}

package/src/services/PsbtBuilderService.js

@@ -0,0 +1,124 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+import ecc from '@bitcoinerlab/secp256k1';
+import { ECPairFactory } from 'ecpair';
+import { Psbt, payments, address } from 'bitcoinjs-lib';
+import { Logger } from '@dynamic-labs/logger';
+import { DynamicError } from '@dynamic-labs/utils';
+import { DUST_LIMIT, SATOSHIS_PER_BTC } from '../const.js';
+import { getBitcoinNetwork } from '../utils/getBitcoinNetwork/getBitcoinNetwork.js';
+
+const logger = new Logger('PsbtBuilderService');
+/**
+ * Service for building Bitcoin PSBTs
+ */
+class PsbtBuilderService {
+    constructor(mempoolApiService) {
+        this.mempoolApiService = mempoolApiService;
+    }
+    /**
+     * Builds a PSBT for a Bitcoin transaction with real UTXOs
+     * @param options - Options for building the PSBT
+     * @returns A PSBT in Base64 format
+     * @throws {DynamicError} If insufficient funds, no UTXOs, or other errors
+     */
+    buildPsbt(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { accountAddress, recipientAddress, amountInSatoshis, publicKeyHex, network, } = options;
+            if (amountInSatoshis <= BigInt(0)) {
+                throw new DynamicError('Amount must be greater than 0');
+            }
+            // Get UTXOs for the account address
+            const utxos = yield this.mempoolApiService.getUTXOs(accountAddress);
+            if (utxos.length === 0) {
+                throw new DynamicError('No UTXOs found for this address');
+            }
+            // Get public key for creating output scripts
+            const publicKeyBuffer = Buffer.from(publicKeyHex, 'hex');
+            // Use ECPair to ensure the public key is properly formatted for bitcoinjs-lib
+            const ECPair = ECPairFactory(ecc);
+            const publicKeyPair = ECPair.fromPublicKey(publicKeyBuffer, {
+                compressed: true,
+            });
+            // Calculate total available
+            const totalToSpend = utxos.reduce((total, utxo) => total + utxo.value, 0);
+            // Initial fee estimate with 1 output (recipient only)
+            let feeEstimate = yield this.mempoolApiService.estimateTransactionFee(accountAddress, utxos.length, 1);
+            // Calculate change amount with 1-output fee estimate
+            let maxToSpend = totalToSpend - feeEstimate;
+            let changeAmount = BigInt(maxToSpend) - amountInSatoshis;
+            // If change will be above dust limit, re-estimate fees for 2 outputs
+            if (changeAmount > 0 && Number(changeAmount) >= DUST_LIMIT) {
+                feeEstimate = yield this.mempoolApiService.estimateTransactionFee(accountAddress, utxos.length, 2);
+                maxToSpend = totalToSpend - feeEstimate;
+                changeAmount = BigInt(maxToSpend) - amountInSatoshis;
+            }
+            if (maxToSpend < Number(amountInSatoshis)) {
+                const amountInSatoshisNumber = Number(amountInSatoshis);
+                throw new DynamicError(`Insufficient funds. Available: ${maxToSpend / SATOSHIS_PER_BTC} BTC (${maxToSpend} satoshis), Required: ${amountInSatoshisNumber / SATOSHIS_PER_BTC} BTC (${amountInSatoshisNumber} satoshis)`);
+            }
+            // Create PSBT
+            const psbt = new Psbt({ network });
+            // Add inputs from UTXOs (only supporting native SegWit P2WPKH)
+            for (const utxo of utxos) {
+                // SegWit (P2WPKH) addresses
+                // For SegWit, we need the public key to construct the witness output script
+                const outputScript = payments.p2wpkh({
+                    network,
+                    pubkey: publicKeyPair.publicKey,
+                }).output;
+                if (!outputScript) {
+                    throw new DynamicError('Failed to create segwit output script');
+                }
+                // Convert txid from hex string to Buffer and reverse it (Bitcoin uses little-endian)
+                // The txid from the API is in big-endian format, but bitcoinjs-lib expects little-endian
+                const txidBuffer = Buffer.from(utxo.txid, 'hex').reverse();
+                psbt.addInput({
+                    hash: txidBuffer,
+                    index: utxo.vout,
+                    witnessUtxo: {
+                        script: outputScript,
+                        value: utxo.value,
+                    },
+                });
+            }
+            // Add recipient output
+            const amountInSatoshisNumber = Number(amountInSatoshis);
+            if (amountInSatoshisNumber < DUST_LIMIT) {
+                throw new DynamicError(`Amount is below dust limit of ${DUST_LIMIT} satoshis (${DUST_LIMIT / SATOSHIS_PER_BTC} BTC)`);
+            }
+            psbt.addOutput({
+                script: address.toOutputScript(recipientAddress, network),
+                value: amountInSatoshisNumber,
+            });
+            // Add change output if needed
+            const changeAmountNumber = Number(changeAmount);
+            if (changeAmount > 0 && changeAmountNumber >= DUST_LIMIT) {
+                psbt.addOutput({
+                    script: address.toOutputScript(accountAddress, network),
+                    value: changeAmountNumber,
+                });
+            }
+            logger.debug(`buildPsbt created PSBT for recipientAddress: ${recipientAddress}, amount: ${amountInSatoshisNumber} satoshis (${amountInSatoshisNumber / SATOSHIS_PER_BTC} BTC), change: ${changeAmountNumber} satoshis`);
+            return psbt.toBase64();
+        });
+    }
+    /**
+     * Helper method to create BuildPsbtOptions from transaction and account details
+     * @param accountAddress - The account address
+     * @param transaction - The Bitcoin transaction
+     * @param publicKeyHex - The public key in hex format
+     * @returns BuildPsbtOptions
+     */
+    static createBuildOptions(accountAddress, transaction, publicKeyHex) {
+        return {
+            accountAddress,
+            amountInSatoshis: transaction.amount,
+            network: getBitcoinNetwork(accountAddress),
+            publicKeyHex,
+            recipientAddress: transaction.recipientAddress,
+        };
+    }
+}
+
+export { PsbtBuilderService };

package/src/types.d.ts

@@ -1,7 +1,11 @@
 import { BitcoinProvider, InputToSign as SatsConnectInputToSign } from 'sats-connect';
 import { SignPsbtResponse as BtcKitSignPsbtResponse } from '@btckit/types';
 import { IdentifierString, WalletAccount } from '@wallet-standard/base';
+import type { Network } from 'bitcoinjs-lib';
+import type { WalletUiUtils } from '@dynamic-labs/types';
+import type { InternalWalletConnector } from '@dynamic-labs/wallet-connector-core';
 import type { WalletAdditionalAddress } from '@dynamic-labs/sdk-api-core';
+import type { BitcoinWalletConnectorOpts } from './connectors';
 import { SATSCONNECT_FEATURE } from './const';
 export type ErrorWithCode = Error & {
     code: string;
@@ -137,4 +141,43 @@ interface ProviderBalance {
 export interface ProviderWithBalance {
     getBalance: () => Promise<ProviderBalance>;
 }
+export type DynamicWaasBitcoinConnectorProps = BitcoinWalletConnectorOpts & {
+    walletUiUtils: WalletUiUtils<InternalWalletConnector>;
+};
+export interface UTXO {
+    txid: string;
+    vout: number;
+    value: number;
+    status?: {
+        confirmed: boolean;
+    };
+}
+export interface FeeRecommendations {
+    fastestFee?: number;
+    halfHourFee?: number;
+    hourFee?: number;
+    economyFee?: number;
+    minimumFee?: number;
+}
+export interface ParsedTransactionInput {
+    txid: string;
+    vout: number;
+    address?: string;
+    value?: number;
+}
+export interface ParsedTransactionOutput {
+    address?: string;
+    value: number;
+}
+export interface ParsedTransaction {
+    inputs: ParsedTransactionInput[];
+    outputs: ParsedTransactionOutput[];
+}
+export interface BuildPsbtOptions {
+    accountAddress: string;
+    recipientAddress: string;
+    amountInSatoshis: bigint;
+    publicKeyHex: string;
+    network: Network;
+}
 export {};

package/src/utils/btcToSatoshis/btcToSatoshis.cjs

@@ -0,0 +1,24 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('@dynamic-labs/utils');
+var _const = require('../../const.cjs');
+
+/**
+ * Helper function to convert BTC amount to satoshis
+ * @param btcAmount - The Bitcoin amount to convert (number)
+ * @returns The amount in satoshis as a BigInt
+ * @throws {DynamicError} If the amount is negative
+ */
+const btcToSatoshis = (btcAmount) => {
+    if (btcAmount < 0) {
+        throw new utils.DynamicError('BTC amount cannot be negative');
+    }
+    // Convert to satoshis and return as BigInt
+    const satoshis = Math.floor(btcAmount * _const.SATOSHIS_PER_BTC);
+    return BigInt(satoshis);
+};
+
+exports.btcToSatoshis = btcToSatoshis;

package/src/utils/btcToSatoshis/btcToSatoshis.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Helper function to convert BTC amount to satoshis
+ * @param btcAmount - The Bitcoin amount to convert (number)
+ * @returns The amount in satoshis as a BigInt
+ * @throws {DynamicError} If the amount is negative
+ */
+export declare const btcToSatoshis: (btcAmount: number) => bigint;