@dynamic-labs/bitcoin 4.53.1 → 4.53.2

package/CHANGELOG.md

@@ -1,4 +1,20 @@
 
+### [4.53.2](https://github.com/dynamic-labs/dynamic-auth/compare/v4.53.1...v4.53.2) (2026-01-16)
+
+
+### Features
+
+* add iCloud backup functionality ([#10219](https://github.com/dynamic-labs/dynamic-auth/issues/10219)) ([44e95e5](https://github.com/dynamic-labs/dynamic-auth/commit/44e95e5a5dc99f83918a382ab1c69d452359c346))
+* update PSBT building with Largest-First UTXO selection and fee priorities (high/medium/low) ([#10227](https://github.com/dynamic-labs/dynamic-auth/issues/10227)) ([94c5f5c](https://github.com/dynamic-labs/dynamic-auth/commit/94c5f5cb97432bb97374b754cb95bc23290dd184))
+
+
+### Bug Fixes
+
+* allow late registered solana wallets to appear in the wallet list ([#10224](https://github.com/dynamic-labs/dynamic-auth/issues/10224)) ([2f418d4](https://github.com/dynamic-labs/dynamic-auth/commit/2f418d4f3e0543bdd829a45807329f89da1e41a7))
+* correctly show app name in wallet app for wallet connect evm connections ([#10218](https://github.com/dynamic-labs/dynamic-auth/issues/10218)) ([fec0009](https://github.com/dynamic-labs/dynamic-auth/commit/fec0009177439baa67015050b4ad799119615f4f))
+* destructure wallets from getWalletStandardWallets before calling find ([#10234](https://github.com/dynamic-labs/dynamic-auth/issues/10234)) ([b59617a](https://github.com/dynamic-labs/dynamic-auth/commit/b59617a8579b9c7d8a5f744a2ea9363ccb4aee58))
+* **react-native:** filter connectors by enabled chains and add chain parameter to connectWallet ([#10230](https://github.com/dynamic-labs/dynamic-auth/issues/10230)) ([a2bbd03](https://github.com/dynamic-labs/dynamic-auth/commit/a2bbd03ece52950711d2eda18cb2345df15710dd))
+
 ### [4.53.1](https://github.com/dynamic-labs/dynamic-auth/compare/v4.53.0...v4.53.1) (2026-01-14)
 
 ## [4.53.0](https://github.com/dynamic-labs/dynamic-auth/compare/v4.52.5...v4.53.0) (2026-01-13)

package/package.cjs

@@ -3,6 +3,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var version = "4.53.1";
+var version = "4.53.2";
 
 exports.version = version;

package/package.js

@@ -1,4 +1,4 @@
 'use client'
-var version = "4.53.1";
+var version = "4.53.2";
 
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/bitcoin",
-  "version": "4.53.1",
+  "version": "4.53.2",
   "description": "A React SDK for implementing wallet web3 authentication and authorization to your website.",
   "author": "Dynamic Labs, Inc.",
   "license": "MIT",
@@ -18,23 +18,23 @@
   },
   "homepage": "https://www.dynamic.xyz/",
   "dependencies": {
-    "@dynamic-labs-wallet/browser-wallet-client": "0.0.237",
+    "@dynamic-labs-wallet/browser-wallet-client": "0.0.245",
     "@bitcoinerlab/secp256k1": "1.1.1",
     "@btckit/types": "0.0.19",
-    "@dynamic-labs/sdk-api-core": "0.0.843",
+    "@dynamic-labs/sdk-api-core": "0.0.855",
     "@wallet-standard/app": "1.0.1",
     "@wallet-standard/base": "1.0.1",
     "bitcoinjs-lib": "6.1.5",
     "ecpair": "2.1.0",
     "sats-connect": "4.2.0",
     "jsontokens": "4.0.1",
-    "@dynamic-labs/assert-package-version": "4.53.1",
-    "@dynamic-labs/logger": "4.53.1",
-    "@dynamic-labs/types": "4.53.1",
-    "@dynamic-labs/utils": "4.53.1",
-    "@dynamic-labs/waas": "4.53.1",
-    "@dynamic-labs/wallet-book": "4.53.1",
-    "@dynamic-labs/wallet-connector-core": "4.53.1",
+    "@dynamic-labs/assert-package-version": "4.53.2",
+    "@dynamic-labs/logger": "4.53.2",
+    "@dynamic-labs/types": "4.53.2",
+    "@dynamic-labs/utils": "4.53.2",
+    "@dynamic-labs/waas": "4.53.2",
+    "@dynamic-labs/wallet-book": "4.53.2",
+    "@dynamic-labs/wallet-connector-core": "4.53.2",
     "eventemitter3": "5.0.1"
   },
   "peerDependencies": {}

package/src/connectors/DynamicWaasBitcoinConnector/DynamicWaasBitcoinConnector.cjs

@@ -128,11 +128,15 @@ class DynamicWaasBitcoinConnector extends waas.withDynamicWaas(BitcoinWalletConn
         });
     }
     /**
-     * Signs a Partially Signed Bitcoin Transaction (PSBT)
-     * @param request - The PSBT signing request containing the unsigned PSBT
-     * @returns The signed PSBT response
+     * Signs a Partially Signed Bitcoin Transaction (PSBT) for embedded wallets
+     *
+     * Embedded wallets only support PSBT format and automatically sign all inputs
+     * that belong to the wallet address. Always uses SIGHASH_ALL (0x01).
+     *
+     * @param request - The PSBT signing request. Only unsignedPsbtBase64 is required.
+     * @returns The signed (but not finalized) PSBT response
      * @throws {DynamicError} If active account address is not set
-     * @throws {DynamicError} If signed session ID is not available or signature is provided
+     * @throws {DynamicError} If signed session ID is not available
      */
     signPsbt(request) {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
@@ -148,9 +152,6 @@ class DynamicWaasBitcoinConnector extends waas.withDynamicWaas(BitcoinWalletConn
             const mfaToken = yield ((_b = this.getMfaToken) === null || _b === void 0 ? void 0 : _b.call(this, {
                 mfaAction: sdkApiCore.MFAAction.WalletWaasSign,
             }));
-            if (request.signature && request.signature.length > 0) {
-                throw new utils.DynamicError('Signature is not supported for waas at the moment');
-            }
             const signedTransaction = yield walletClient.signTransaction({
                 authToken: (_c = this.getAuthToken) === null || _c === void 0 ? void 0 : _c.call(this),
                 mfaToken,
@@ -192,9 +193,7 @@ class DynamicWaasBitcoinConnector extends waas.withDynamicWaas(BitcoinWalletConn
             // Step 1: Build the PSBT
             const unsignedPsbt = yield this.buildPsbt(transaction);
             // Step 2: Sign the PSBT
-            // SIGHASH_ALL (0x01) is the most common sighash type for Bitcoin transactions (Eventually can be configurable)
             const signedPsbtResponse = yield this.signPsbt({
-                allowedSighash: [0x01],
                 unsignedPsbtBase64: unsignedPsbt,
             });
             if (!signedPsbtResponse) {
@@ -337,7 +336,7 @@ class DynamicWaasBitcoinConnector extends waas.withDynamicWaas(BitcoinWalletConn
     }
     /**
      * Builds a PSBT for a Bitcoin transaction with real UTXOs
-     * @param transaction - The Bitcoin transaction containing recipient address and amount in satoshis to send
+     * @param transaction - Bitcoin transaction with recipient address, amount in satoshis, and optional fee priority
      * @returns A PSBT in Base64 format
      * @throws {DynamicError} If no active account address, insufficient funds, or other errors
      */
@@ -347,7 +346,7 @@ class DynamicWaasBitcoinConnector extends waas.withDynamicWaas(BitcoinWalletConn
                 throw new utils.DynamicError('Active account address is required');
             }
             const publicKeyHex = yield this.getPublicKey();
-            const buildOptions = PsbtBuilderService.PsbtBuilderService.createBuildOptions(this.activeAccountAddress, transaction, publicKeyHex);
+            const buildOptions = PsbtBuilderService.PsbtBuilderService.createBuildOptions(this.activeAccountAddress, transaction, publicKeyHex, transaction.feePriority || 'medium');
             return this.psbtBuilderService.buildPsbt(buildOptions);
         });
     }

package/src/connectors/DynamicWaasBitcoinConnector/DynamicWaasBitcoinConnector.d.ts

@@ -2,8 +2,8 @@ import { BitcoinConfig, BitcoinNetwork } from '@dynamic-labs-wallet/browser-wall
 import { JwtVerifiedCredential, MFAAction, SignMessageContext } from '@dynamic-labs/sdk-api-core';
 import { Logger } from '@dynamic-labs/logger';
 import { WalletUiUtils } from '@dynamic-labs/types';
-import { IDynamicWaasConnector, InternalWalletConnector, Chain, BitcoinSignPsbtRequest, BitcoinSignPsbtResponse } from '@dynamic-labs/wallet-connector-core';
-import { BitcoinTransaction } from '../../types';
+import { IDynamicWaasConnector, InternalWalletConnector, Chain, BitcoinSignPsbtResponse } from '@dynamic-labs/wallet-connector-core';
+import { BitcoinTransaction, EmbeddedWalletSignPsbtRequest } from '../../types';
 import { BitcoinWalletConnector } from '../BitcoinWalletConnector';
 import type { ParsedTransaction, DynamicWaasBitcoinConnectorProps } from '../../types';
 declare const DynamicWaasBitcoinConnector_base: (abstract new (...args: any[]) => {
@@ -35,7 +35,10 @@ declare const DynamicWaasBitcoinConnector_base: (abstract new (...args: any[]) =
     setBaseApiUrl(baseApiUrl: string): void;
     setBaseClientKeysharesRelayApiUrl(baseClientKeysharesRelayApiUrl?: string | undefined): void;
     setRelayUrl(relayUrl: string): void;
-    setGetSignedSessionIdFunction(getSignedSessionId: () => Promise<string>): void;
+    setGetSignedSessionIdFunction(getSignedSessionId: () => Promise<string>): void; /**
+     * The primary/active verified credential (first from the filtered array)
+     * This is used for the active account address
+     */
     delegateKeyShares({ accountAddress, password, }: {
         accountAddress: string;
         password?: string | undefined;
@@ -56,7 +59,11 @@ declare const DynamicWaasBitcoinConnector_base: (abstract new (...args: any[]) =
         privateKey: string;
         thresholdSignatureScheme?: string | undefined;
         publicAddressCheck?: string | undefined;
-        addressType?: string | undefined;
+        addressType?: string | undefined; /**
+         * Override setVerifiedCredentials to filter and set Bitcoin WaaS credentials
+         * Filters for credentials with walletName === 'dynamicwaas' and chain === 'bip122'
+         * The base class already has verifiedCredentials property, so we just filter and set it
+         */
     }): Promise<void>;
     exportPrivateKey({ accountAddress, displayContainer, password, }?: {
         accountAddress?: string | undefined;
@@ -78,6 +85,15 @@ declare const DynamicWaasBitcoinConnector_base: (abstract new (...args: any[]) =
         accountAddress: string;
         password?: string | undefined;
     }): Promise<void>;
+    backupKeySharesToICloud({ accountAddress, password, }: {
+        accountAddress: string;
+        password?: string | undefined;
+    }): Promise<void>;
+    displayICloudSignIn({ displayContainer, }: {
+        displayContainer: HTMLElement;
+    }): Promise<void>;
+    hideICloudSignIn(): Promise<void>;
+    isICloudAuthenticated(): Promise<boolean>;
     refreshWalletAccountShares({ accountAddress, password, }: {
         accountAddress: string;
         password?: string | undefined;
@@ -169,13 +185,17 @@ export declare class DynamicWaasBitcoinConnector extends DynamicWaasBitcoinConne
      */
     signMessage(message: string): Promise<string>;
     /**
-     * Signs a Partially Signed Bitcoin Transaction (PSBT)
-     * @param request - The PSBT signing request containing the unsigned PSBT
-     * @returns The signed PSBT response
+     * Signs a Partially Signed Bitcoin Transaction (PSBT) for embedded wallets
+     *
+     * Embedded wallets only support PSBT format and automatically sign all inputs
+     * that belong to the wallet address. Always uses SIGHASH_ALL (0x01).
+     *
+     * @param request - The PSBT signing request. Only unsignedPsbtBase64 is required.
+     * @returns The signed (but not finalized) PSBT response
      * @throws {DynamicError} If active account address is not set
-     * @throws {DynamicError} If signed session ID is not available or signature is provided
+     * @throws {DynamicError} If signed session ID is not available
      */
-    signPsbt(request: BitcoinSignPsbtRequest): Promise<BitcoinSignPsbtResponse>;
+    signPsbt(request: EmbeddedWalletSignPsbtRequest): Promise<BitcoinSignPsbtResponse>;
     /**
      * Sends a raw Bitcoin transaction to the mempool
      * @param rawTransaction - The raw transaction in hex format
@@ -258,7 +278,7 @@ export declare class DynamicWaasBitcoinConnector extends DynamicWaasBitcoinConne
     }): Promise<string>;
     /**
      * Builds a PSBT for a Bitcoin transaction with real UTXOs
-     * @param transaction - The Bitcoin transaction containing recipient address and amount in satoshis to send
+     * @param transaction - Bitcoin transaction with recipient address, amount in satoshis, and optional fee priority
      * @returns A PSBT in Base64 format
      * @throws {DynamicError} If no active account address, insufficient funds, or other errors
      */

package/src/connectors/DynamicWaasBitcoinConnector/DynamicWaasBitcoinConnector.js

@@ -124,11 +124,15 @@ class DynamicWaasBitcoinConnector extends withDynamicWaas(BitcoinWalletConnector
         });
     }
     /**
-     * Signs a Partially Signed Bitcoin Transaction (PSBT)
-     * @param request - The PSBT signing request containing the unsigned PSBT
-     * @returns The signed PSBT response
+     * Signs a Partially Signed Bitcoin Transaction (PSBT) for embedded wallets
+     *
+     * Embedded wallets only support PSBT format and automatically sign all inputs
+     * that belong to the wallet address. Always uses SIGHASH_ALL (0x01).
+     *
+     * @param request - The PSBT signing request. Only unsignedPsbtBase64 is required.
+     * @returns The signed (but not finalized) PSBT response
      * @throws {DynamicError} If active account address is not set
-     * @throws {DynamicError} If signed session ID is not available or signature is provided
+     * @throws {DynamicError} If signed session ID is not available
      */
     signPsbt(request) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -144,9 +148,6 @@ class DynamicWaasBitcoinConnector extends withDynamicWaas(BitcoinWalletConnector
             const mfaToken = yield ((_b = this.getMfaToken) === null || _b === void 0 ? void 0 : _b.call(this, {
                 mfaAction: MFAAction.WalletWaasSign,
             }));
-            if (request.signature && request.signature.length > 0) {
-                throw new DynamicError('Signature is not supported for waas at the moment');
-            }
             const signedTransaction = yield walletClient.signTransaction({
                 authToken: (_c = this.getAuthToken) === null || _c === void 0 ? void 0 : _c.call(this),
                 mfaToken,
@@ -188,9 +189,7 @@ class DynamicWaasBitcoinConnector extends withDynamicWaas(BitcoinWalletConnector
             // Step 1: Build the PSBT
             const unsignedPsbt = yield this.buildPsbt(transaction);
             // Step 2: Sign the PSBT
-            // SIGHASH_ALL (0x01) is the most common sighash type for Bitcoin transactions (Eventually can be configurable)
             const signedPsbtResponse = yield this.signPsbt({
-                allowedSighash: [0x01],
                 unsignedPsbtBase64: unsignedPsbt,
             });
             if (!signedPsbtResponse) {
@@ -333,7 +332,7 @@ class DynamicWaasBitcoinConnector extends withDynamicWaas(BitcoinWalletConnector
     }
     /**
      * Builds a PSBT for a Bitcoin transaction with real UTXOs
-     * @param transaction - The Bitcoin transaction containing recipient address and amount in satoshis to send
+     * @param transaction - Bitcoin transaction with recipient address, amount in satoshis, and optional fee priority
      * @returns A PSBT in Base64 format
      * @throws {DynamicError} If no active account address, insufficient funds, or other errors
      */
@@ -343,7 +342,7 @@ class DynamicWaasBitcoinConnector extends withDynamicWaas(BitcoinWalletConnector
                 throw new DynamicError('Active account address is required');
             }
             const publicKeyHex = yield this.getPublicKey();
-            const buildOptions = PsbtBuilderService.createBuildOptions(this.activeAccountAddress, transaction, publicKeyHex);
+            const buildOptions = PsbtBuilderService.createBuildOptions(this.activeAccountAddress, transaction, publicKeyHex, transaction.feePriority || 'medium');
             return this.psbtBuilderService.buildPsbt(buildOptions);
         });
     }

package/src/const.cjs

@@ -12,20 +12,28 @@ const MEMPOOL_API_URL_TESTNET = 'https://mempool.space/testnet/api';
 // WaaS Bitcoin constants
 const SATOSHIS_PER_BTC = 100000000;
 const DUST_LIMIT = 546; // Bitcoin's dust limit in satoshis
-const INPUT_BYTE_SIZE_UPPER_BOUND = 90;
-const OUTPUT_BYTE_SIZE_UPPER_BOUND = 45;
+// Accurate vSize constants for Native SegWit (P2WPKH) transactions
+// These are used for precise fee estimation
+const VSIZE_OVERHEAD = 10.5; // Base transaction overhead in vBytes
+const VSIZE_INPUT_P2WPKH = 68; // Each P2WPKH input in vBytes
+const VSIZE_OUTPUT_P2WPKH = 31; // Each P2WPKH output in vBytes
 const MIN_RELAY_FEE = 111;
 const DEFAULT_FEE_ESTIMATE = 1000; // Conservative default fee estimate in satoshis
+// RBF (Replace-By-Fee) sequence number
+// 0xfffffffd = 4294967293 (enables RBF, not final)
+const RBF_SEQUENCE = 0xfffffffd;
 
 exports.BTCKIT_INTERFACE = BTCKIT_INTERFACE;
 exports.DEFAULT_FEE_ESTIMATE = DEFAULT_FEE_ESTIMATE;
 exports.DUST_LIMIT = DUST_LIMIT;
 exports.HTTP_STATUS_NOT_FOUND = HTTP_STATUS_NOT_FOUND;
 exports.HTTP_STATUS_TOO_MANY_REQUESTS = HTTP_STATUS_TOO_MANY_REQUESTS;
-exports.INPUT_BYTE_SIZE_UPPER_BOUND = INPUT_BYTE_SIZE_UPPER_BOUND;
 exports.MEMPOOL_API_URL = MEMPOOL_API_URL;
 exports.MEMPOOL_API_URL_TESTNET = MEMPOOL_API_URL_TESTNET;
 exports.MIN_RELAY_FEE = MIN_RELAY_FEE;
-exports.OUTPUT_BYTE_SIZE_UPPER_BOUND = OUTPUT_BYTE_SIZE_UPPER_BOUND;
+exports.RBF_SEQUENCE = RBF_SEQUENCE;
 exports.SATOSHIS_PER_BTC = SATOSHIS_PER_BTC;
 exports.SATSCONNECT_FEATURE = SATSCONNECT_FEATURE;
+exports.VSIZE_INPUT_P2WPKH = VSIZE_INPUT_P2WPKH;
+exports.VSIZE_OUTPUT_P2WPKH = VSIZE_OUTPUT_P2WPKH;
+exports.VSIZE_OVERHEAD = VSIZE_OVERHEAD;

package/src/const.d.ts

@@ -7,7 +7,9 @@ export declare const MEMPOOL_API_URL = "https://mempool.space/api";
 export declare const MEMPOOL_API_URL_TESTNET = "https://mempool.space/testnet/api";
 export declare const SATOSHIS_PER_BTC = 100000000;
 export declare const DUST_LIMIT = 546;
-export declare const INPUT_BYTE_SIZE_UPPER_BOUND = 90;
-export declare const OUTPUT_BYTE_SIZE_UPPER_BOUND = 45;
+export declare const VSIZE_OVERHEAD = 10.5;
+export declare const VSIZE_INPUT_P2WPKH = 68;
+export declare const VSIZE_OUTPUT_P2WPKH = 31;
 export declare const MIN_RELAY_FEE = 111;
 export declare const DEFAULT_FEE_ESTIMATE = 1000;
+export declare const RBF_SEQUENCE = 4294967293;

package/src/const.js

@@ -8,9 +8,15 @@ const MEMPOOL_API_URL_TESTNET = 'https://mempool.space/testnet/api';
 // WaaS Bitcoin constants
 const SATOSHIS_PER_BTC = 100000000;
 const DUST_LIMIT = 546; // Bitcoin's dust limit in satoshis
-const INPUT_BYTE_SIZE_UPPER_BOUND = 90;
-const OUTPUT_BYTE_SIZE_UPPER_BOUND = 45;
+// Accurate vSize constants for Native SegWit (P2WPKH) transactions
+// These are used for precise fee estimation
+const VSIZE_OVERHEAD = 10.5; // Base transaction overhead in vBytes
+const VSIZE_INPUT_P2WPKH = 68; // Each P2WPKH input in vBytes
+const VSIZE_OUTPUT_P2WPKH = 31; // Each P2WPKH output in vBytes
 const MIN_RELAY_FEE = 111;
 const DEFAULT_FEE_ESTIMATE = 1000; // Conservative default fee estimate in satoshis
+// RBF (Replace-By-Fee) sequence number
+// 0xfffffffd = 4294967293 (enables RBF, not final)
+const RBF_SEQUENCE = 0xfffffffd;
 
-export { BTCKIT_INTERFACE, DEFAULT_FEE_ESTIMATE, DUST_LIMIT, HTTP_STATUS_NOT_FOUND, HTTP_STATUS_TOO_MANY_REQUESTS, INPUT_BYTE_SIZE_UPPER_BOUND, MEMPOOL_API_URL, MEMPOOL_API_URL_TESTNET, MIN_RELAY_FEE, OUTPUT_BYTE_SIZE_UPPER_BOUND, SATOSHIS_PER_BTC, SATSCONNECT_FEATURE };
+export { BTCKIT_INTERFACE, DEFAULT_FEE_ESTIMATE, DUST_LIMIT, HTTP_STATUS_NOT_FOUND, HTTP_STATUS_TOO_MANY_REQUESTS, MEMPOOL_API_URL, MEMPOOL_API_URL_TESTNET, MIN_RELAY_FEE, RBF_SEQUENCE, SATOSHIS_PER_BTC, SATSCONNECT_FEATURE, VSIZE_INPUT_P2WPKH, VSIZE_OUTPUT_P2WPKH, VSIZE_OVERHEAD };

package/src/index.d.ts

@@ -1,6 +1,6 @@
 import { OkxConnector } from './connectors';
 export { BitcoinWalletConnector, type BitcoinWalletConnectorOpts, } from './connectors';
-export type { BitcoinTransaction, BitcoinSignProtocol, BitcoinSignPsbtRequest, BitcoinSignPsbtResponse, BitcoinWalletStandardMethods, SignPsbtOptions, } from './types';
+export type { BitcoinTransaction, BitcoinSignProtocol, BitcoinSignPsbtRequest, BitcoinSignPsbtResponse, BitcoinWalletStandardMethods, SignPsbtOptions, EmbeddedWalletSignPsbtRequest, } from './types';
 export * from './utils';
 export * from './wallet';
 export { UnisatConnector, BitcoinSatsConnectConnector, DynamicWaasBitcoinConnector, } from './connectors';

package/src/services/MempoolApiService.cjs

@@ -70,21 +70,44 @@ class MempoolApiService {
         });
     }
     /**
-     * Estimates transaction fees based on number of inputs and outputs
+     * Estimates transaction fees based on number of inputs and outputs using accurate vSize
      * @param address - The Bitcoin address to determine the network from
      * @param numInputs - Number of transaction inputs
      * @param numOutputs - Number of transaction outputs
+     * @param feePriority - Fee priority level (high/medium/low)
      * @returns Estimated fee in satoshis
      */
-    estimateTransactionFee(address, numInputs, numOutputs) {
-        return _tslib.__awaiter(this, void 0, void 0, function* () {
+    estimateTransactionFee(address_1, numInputs_1, numOutputs_1) {
+        return _tslib.__awaiter(this, arguments, void 0, function* (address, numInputs, numOutputs, feePriority = 'medium') {
             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;
+                // High (Fastest): fastestFee -> Block 1
+                // Medium (Fast): halfHourFee -> Blocks 2-3
+                // Low (Eco): economyFee (preferred) or hourFee -> Blocks 6+
+                let feePerByte;
+                switch (feePriority) {
+                    case 'high':
+                        feePerByte =
+                            feeData.fastestFee || feeData.halfHourFee || feeData.hourFee || 1;
+                        break;
+                    case 'low':
+                        feePerByte = feeData.economyFee || feeData.hourFee || 1;
+                        break;
+                    case 'medium':
+                    default:
+                        feePerByte =
+                            feeData.halfHourFee || feeData.hourFee || feeData.economyFee || 1;
+                        break;
+                }
+                logger.debug(`Fee estimation - Priority: ${feePriority}, fastestFee: ${feeData.fastestFee}, halfHourFee: ${feeData.halfHourFee}, hourFee: ${feeData.hourFee}, economyFee: ${feeData.economyFee}, selected: ${feePerByte} sat/vB`);
+                // Use accurate vSize calculation for Native SegWit (P2WPKH)
+                // Formula: overhead + (inputs × 68) + (outputs × 31)
+                const vSize = _const.VSIZE_OVERHEAD +
+                    numInputs * _const.VSIZE_INPUT_P2WPKH +
+                    numOutputs * _const.VSIZE_OUTPUT_P2WPKH;
+                const estimatedFee = Math.ceil(feePerByte * vSize) + _const.MIN_RELAY_FEE;
+                logger.debug(`Fee calculation - Priority: ${feePriority}, vSize: ${vSize}, feePerByte: ${feePerByte} sat/vB, estimatedFee: ${estimatedFee} satoshis`);
+                logger.debug(`[MempoolApiService] Fee Priority: ${feePriority}, Selected Rate: ${feePerByte} sat/vB, vSize: ${vSize}, Estimated Fee: ${estimatedFee} satoshis`);
                 return estimatedFee;
             }
             catch (error) {

package/src/services/MempoolApiService.d.ts

@@ -24,13 +24,14 @@ export declare class MempoolApiService {
      */
     getFeeRecommendations(address: string): Promise<FeeRecommendations>;
     /**
-     * Estimates transaction fees based on number of inputs and outputs
+     * Estimates transaction fees based on number of inputs and outputs using accurate vSize
      * @param address - The Bitcoin address to determine the network from
      * @param numInputs - Number of transaction inputs
      * @param numOutputs - Number of transaction outputs
+     * @param feePriority - Fee priority level (high/medium/low)
      * @returns Estimated fee in satoshis
      */
-    estimateTransactionFee(address: string, numInputs: number, numOutputs: number): Promise<number>;
+    estimateTransactionFee(address: string, numInputs: number, numOutputs: number, feePriority?: 'high' | 'medium' | 'low'): Promise<number>;
     /**
      * Sends a raw Bitcoin transaction to the mempool
      * @param address - The Bitcoin address to determine the network from

package/src/services/MempoolApiService.js

@@ -9,7 +9,7 @@ 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 { VSIZE_OVERHEAD, VSIZE_INPUT_P2WPKH, VSIZE_OUTPUT_P2WPKH, MIN_RELAY_FEE, DEFAULT_FEE_ESTIMATE } from '../const.js';
 import 'jsontokens';
 import '../connectors/DynamicWaasBitcoinConnector/DynamicWaasBitcoinConnector.js';
 
@@ -66,21 +66,44 @@ class MempoolApiService {
         });
     }
     /**
-     * Estimates transaction fees based on number of inputs and outputs
+     * Estimates transaction fees based on number of inputs and outputs using accurate vSize
      * @param address - The Bitcoin address to determine the network from
      * @param numInputs - Number of transaction inputs
      * @param numOutputs - Number of transaction outputs
+     * @param feePriority - Fee priority level (high/medium/low)
      * @returns Estimated fee in satoshis
      */
-    estimateTransactionFee(address, numInputs, numOutputs) {
-        return __awaiter(this, void 0, void 0, function* () {
+    estimateTransactionFee(address_1, numInputs_1, numOutputs_1) {
+        return __awaiter(this, arguments, void 0, function* (address, numInputs, numOutputs, feePriority = 'medium') {
             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;
+                // High (Fastest): fastestFee -> Block 1
+                // Medium (Fast): halfHourFee -> Blocks 2-3
+                // Low (Eco): economyFee (preferred) or hourFee -> Blocks 6+
+                let feePerByte;
+                switch (feePriority) {
+                    case 'high':
+                        feePerByte =
+                            feeData.fastestFee || feeData.halfHourFee || feeData.hourFee || 1;
+                        break;
+                    case 'low':
+                        feePerByte = feeData.economyFee || feeData.hourFee || 1;
+                        break;
+                    case 'medium':
+                    default:
+                        feePerByte =
+                            feeData.halfHourFee || feeData.hourFee || feeData.economyFee || 1;
+                        break;
+                }
+                logger.debug(`Fee estimation - Priority: ${feePriority}, fastestFee: ${feeData.fastestFee}, halfHourFee: ${feeData.halfHourFee}, hourFee: ${feeData.hourFee}, economyFee: ${feeData.economyFee}, selected: ${feePerByte} sat/vB`);
+                // Use accurate vSize calculation for Native SegWit (P2WPKH)
+                // Formula: overhead + (inputs × 68) + (outputs × 31)
+                const vSize = VSIZE_OVERHEAD +
+                    numInputs * VSIZE_INPUT_P2WPKH +
+                    numOutputs * VSIZE_OUTPUT_P2WPKH;
+                const estimatedFee = Math.ceil(feePerByte * vSize) + MIN_RELAY_FEE;
+                logger.debug(`Fee calculation - Priority: ${feePriority}, vSize: ${vSize}, feePerByte: ${feePerByte} sat/vB, estimatedFee: ${estimatedFee} satoshis`);
+                logger.debug(`[MempoolApiService] Fee Priority: ${feePriority}, Selected Rate: ${feePerByte} sat/vB, vSize: ${vSize}, Estimated Fee: ${estimatedFee} satoshis`);
                 return estimatedFee;
             }
             catch (error) {

package/src/services/PsbtBuilderService.cjs

@@ -24,104 +24,234 @@ class PsbtBuilderService {
     constructor(mempoolApiService) {
         this.mempoolApiService = mempoolApiService;
     }
+    /**
+     * Filters out Taproot (P2TR) UTXOs to prevent accidental spending of Ordinals/Runes
+     * Since we only support Native SegWit (P2WPKH), we ensure the account address is not Taproot
+     * @param accountAddress - The account address to check
+     * @param utxos - Array of UTXOs to filter
+     * @returns Filtered array of UTXOs (only P2WPKH compatible)
+     */
+    filterTaprootUTXOs(accountAddress, utxos) {
+        // Safety check: Ensure account address is not Taproot (bc1p...)
+        if (accountAddress.toLowerCase().startsWith('bc1p') ||
+            accountAddress.toLowerCase().startsWith('tb1p')) {
+            logger.warn(`Account address ${accountAddress} appears to be Taproot. Only Native SegWit (P2WPKH) is supported.`);
+            throw new utils.DynamicError('Taproot addresses are not supported. Only Native SegWit (P2WPKH) addresses are allowed.');
+        }
+        return utxos;
+    }
+    /**
+     * Selects UTXOs using Largest-First (Accumulator) strategy
+     * Sorts UTXOs by value (descending) and selects until we have enough to cover amount + fees
+     * @param utxos - Available UTXOs
+     * @param targetAmount - Target amount including fees and dust limit
+     * @returns Selected UTXOs
+     */
+    selectUTXOsLargestFirst(utxos, targetAmount) {
+        // Sort UTXOs by value (largest first)
+        const sortedUTXOs = [...utxos].sort((a, b) => b.value - a.value);
+        // Accumulate UTXOs until we have enough
+        const selected = [];
+        let total = 0;
+        for (const utxo of sortedUTXOs) {
+            selected.push(utxo);
+            total += utxo.value;
+            // Stop when we have enough to cover the target amount
+            if (total >= targetAmount) {
+                break;
+            }
+        }
+        return selected;
+    }
+    /**
+     * Calculates the total value of UTXOs
+     * @param utxos - Array of UTXOs
+     * @returns Total value in satoshis
+     */
+    calculateUTXOTotal(utxos) {
+        return utxos.reduce((total, utxo) => total + utxo.value, 0);
+    }
+    /**
+     * Validates and ensures sufficient funds for the transaction
+     * @param selectedUTXOs - Initially selected UTXOs
+     * @param allUTXOs - All available UTXOs
+     * @param selectedTotal - Total value of selected UTXOs
+     * @param amountInSatoshisNumber - Transaction amount
+     * @param feeEstimate - Estimated fee
+     * @returns Validated selected UTXOs
+     * @throws {DynamicError} If insufficient funds
+     */
+    validateAndSelectUTXOs(selectedUTXOs, allUTXOs, selectedTotal, amountInSatoshisNumber, feeEstimate) {
+        const requiredAmount = amountInSatoshisNumber + feeEstimate;
+        if (selectedTotal >= requiredAmount) {
+            return selectedUTXOs;
+        }
+        // Try with all UTXOs if selection wasn't enough
+        if (selectedUTXOs.length < allUTXOs.length) {
+            const allTotal = this.calculateUTXOTotal(allUTXOs);
+            if (allTotal < requiredAmount) {
+                throw new utils.DynamicError(`Insufficient funds. Available: ${allTotal / _const.SATOSHIS_PER_BTC} BTC (${allTotal} satoshis), Required: ${amountInSatoshisNumber / _const.SATOSHIS_PER_BTC} BTC (${amountInSatoshisNumber} satoshis) + fees`);
+            }
+            return allUTXOs;
+        }
+        throw new utils.DynamicError(`Insufficient funds. Available: ${selectedTotal / _const.SATOSHIS_PER_BTC} BTC (${selectedTotal} satoshis), Required: ${amountInSatoshisNumber / _const.SATOSHIS_PER_BTC} BTC (${amountInSatoshisNumber} satoshis) + fees`);
+    }
+    /**
+     * Calculates fee estimate and change amount, handling dust limit
+     * @param accountAddress - Account address for fee estimation
+     * @param selectedUTXOs - Selected UTXOs
+     * @param selectedTotalValue - Total value of selected UTXOs
+     * @param amountInSatoshis - Transaction amount
+     * @param feePriority - Fee priority level
+     * @returns Object with feeEstimate, changeAmount, changeAmountNumber, and hasChangeOutput
+     */
+    calculateFeeAndChange(accountAddress, selectedUTXOs, selectedTotalValue, amountInSatoshis, feePriority) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            // Re-estimate fee with actual number of inputs
+            let feeEstimate = yield this.mempoolApiService.estimateTransactionFee(accountAddress, selectedUTXOs.length, 1, // Start with 1 output (recipient only)
+            feePriority);
+            let maxToSpend = selectedTotalValue - feeEstimate;
+            let changeAmount = BigInt(maxToSpend) - amountInSatoshis;
+            // If change will be above dust limit, re-estimate fees for 2 outputs
+            const changeAmountNumber = Number(changeAmount);
+            if (changeAmount > 0 && changeAmountNumber >= _const.DUST_LIMIT) {
+                feeEstimate = yield this.mempoolApiService.estimateTransactionFee(accountAddress, selectedUTXOs.length, 2, // recipient + change output
+                feePriority);
+                maxToSpend = selectedTotalValue - feeEstimate;
+                changeAmount = BigInt(maxToSpend) - amountInSatoshis;
+            }
+            const finalChangeAmountNumber = Number(changeAmount);
+            const hasChangeOutput = changeAmount > 0 && finalChangeAmountNumber >= _const.DUST_LIMIT;
+            // Final fee adjustment: if change < dust limit, add it to fee
+            if (changeAmount > 0 && finalChangeAmountNumber < _const.DUST_LIMIT) {
+                feeEstimate += finalChangeAmountNumber;
+            }
+            return {
+                changeAmount,
+                changeAmountNumber: finalChangeAmountNumber,
+                feeEstimate,
+                hasChangeOutput,
+            };
+        });
+    }
+    /**
+     * Adds inputs to PSBT from selected UTXOs
+     * @param psbt - PSBT to add inputs to
+     * @param selectedUTXOs - Selected UTXOs
+     * @param publicKeyPair - ECPair public key pair
+     * @param network - Bitcoin network
+     */
+    addInputsToPsbt(psbt, selectedUTXOs, publicKeyPair, network) {
+        for (const utxo of selectedUTXOs) {
+            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,
+                sequence: _const.RBF_SEQUENCE, // Enable RBF (Replace-By-Fee)
+                witnessUtxo: {
+                    script: outputScript,
+                    value: utxo.value,
+                },
+            });
+        }
+    }
+    /**
+     * Adds outputs to PSBT (recipient and optionally change)
+     * @param psbt - PSBT to add outputs to
+     * @param recipientAddress - Recipient address
+     * @param accountAddress - Account address for change
+     * @param amountInSatoshisNumber - Transaction amount
+     * @param changeAmountNumber - Change amount
+     * @param hasChangeOutput - Whether to include change output
+     * @param network - Bitcoin network
+     */
+    addOutputsToPsbt(psbt, recipientAddress, accountAddress, amountInSatoshisNumber, changeAmountNumber, hasChangeOutput, network) {
+        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,
+        });
+        if (hasChangeOutput) {
+            psbt.addOutput({
+                script: bitcoinjsLib.address.toOutputScript(accountAddress, network),
+                value: changeAmountNumber,
+            });
+        }
+    }
     /**
      * Builds a PSBT for a Bitcoin transaction with real UTXOs
+     * Uses Largest-First UTXO selection strategy with accurate vSize fee estimation
      * @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;
+            const { accountAddress, recipientAddress, amountInSatoshis, publicKeyHex, network, feePriority = 'medium', } = options;
+            logger.debug(`buildPsbt called with feePriority: ${feePriority}, amount: ${amountInSatoshis} satoshis`);
             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) {
+            const allUTXOs = yield this.mempoolApiService.getUTXOs(accountAddress);
+            if (allUTXOs.length === 0) {
                 throw new utils.DynamicError('No UTXOs found for this address');
             }
-            // Get public key for creating output scripts
+            const utxos = this.filterTaprootUTXOs(accountAddress, allUTXOs);
             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);
+            const amountInSatoshisNumber = Number(amountInSatoshis);
+            // Initial fee estimate with 1 input and 1 output
+            const initialFeeEstimate = yield this.mempoolApiService.estimateTransactionFee(accountAddress, 1, 1, feePriority);
+            // Target amount: transaction amount + fee + dust limit (for change output safety)
+            const targetAmount = amountInSatoshisNumber + initialFeeEstimate + _const.DUST_LIMIT;
+            // Select UTXOs using Largest-First strategy
+            let selectedUTXOs = this.selectUTXOsLargestFirst(utxos, targetAmount);
+            const selectedTotal = this.calculateUTXOTotal(selectedUTXOs);
+            // Validate and ensure sufficient funds
+            selectedUTXOs = this.validateAndSelectUTXOs(selectedUTXOs, utxos, selectedTotal, amountInSatoshisNumber, initialFeeEstimate);
+            const selectedTotalValue = this.calculateUTXOTotal(selectedUTXOs);
+            // Calculate fee and change with proper dust limit handling
+            const { feeEstimate, changeAmountNumber, hasChangeOutput } = yield this.calculateFeeAndChange(accountAddress, selectedUTXOs, selectedTotalValue, amountInSatoshis, feePriority);
+            // Final check: ensure we have enough after final fee calculation
+            const maxToSpend = selectedTotalValue - feeEstimate;
+            if (maxToSpend < amountInSatoshisNumber) {
                 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
+            // Create PSBT and add inputs/outputs
             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`);
+            this.addInputsToPsbt(psbt, selectedUTXOs, publicKeyPair, network);
+            this.addOutputsToPsbt(psbt, recipientAddress, accountAddress, amountInSatoshisNumber, changeAmountNumber, hasChangeOutput, network);
+            logger.debug(`buildPsbt created PSBT for recipientAddress: ${recipientAddress}, amount: ${amountInSatoshisNumber} satoshis (${amountInSatoshisNumber / _const.SATOSHIS_PER_BTC} BTC), change: ${changeAmountNumber} satoshis, estimated fee: ${feeEstimate} satoshis, feePriority: ${feePriority}, inputs: ${selectedUTXOs.length}`);
             return psbt.toBase64();
         });
     }
     /**
      * Helper method to create BuildPsbtOptions from transaction and account details
      * @param accountAddress - The account address
-     * @param transaction - The Bitcoin transaction
+     * @param transaction - The Bitcoin transaction (must have amount and recipientAddress)
      * @param publicKeyHex - The public key in hex format
+     * @param feePriority - Optional fee priority (defaults to 'medium')
      * @returns BuildPsbtOptions
      */
-    static createBuildOptions(accountAddress, transaction, publicKeyHex) {
+    static createBuildOptions(accountAddress, transaction, publicKeyHex, feePriority = 'medium') {
         return {
             accountAddress,
             amountInSatoshis: transaction.amount,
+            feePriority,
             network: getBitcoinNetwork.getBitcoinNetwork(accountAddress),
             publicKeyHex,
             recipientAddress: transaction.recipientAddress,

package/src/services/PsbtBuilderService.d.ts

@@ -6,8 +6,71 @@ import { MempoolApiService } from './MempoolApiService';
 export declare class PsbtBuilderService {
     private mempoolApiService;
     constructor(mempoolApiService: MempoolApiService);
+    /**
+     * Filters out Taproot (P2TR) UTXOs to prevent accidental spending of Ordinals/Runes
+     * Since we only support Native SegWit (P2WPKH), we ensure the account address is not Taproot
+     * @param accountAddress - The account address to check
+     * @param utxos - Array of UTXOs to filter
+     * @returns Filtered array of UTXOs (only P2WPKH compatible)
+     */
+    private filterTaprootUTXOs;
+    /**
+     * Selects UTXOs using Largest-First (Accumulator) strategy
+     * Sorts UTXOs by value (descending) and selects until we have enough to cover amount + fees
+     * @param utxos - Available UTXOs
+     * @param targetAmount - Target amount including fees and dust limit
+     * @returns Selected UTXOs
+     */
+    private selectUTXOsLargestFirst;
+    /**
+     * Calculates the total value of UTXOs
+     * @param utxos - Array of UTXOs
+     * @returns Total value in satoshis
+     */
+    private calculateUTXOTotal;
+    /**
+     * Validates and ensures sufficient funds for the transaction
+     * @param selectedUTXOs - Initially selected UTXOs
+     * @param allUTXOs - All available UTXOs
+     * @param selectedTotal - Total value of selected UTXOs
+     * @param amountInSatoshisNumber - Transaction amount
+     * @param feeEstimate - Estimated fee
+     * @returns Validated selected UTXOs
+     * @throws {DynamicError} If insufficient funds
+     */
+    private validateAndSelectUTXOs;
+    /**
+     * Calculates fee estimate and change amount, handling dust limit
+     * @param accountAddress - Account address for fee estimation
+     * @param selectedUTXOs - Selected UTXOs
+     * @param selectedTotalValue - Total value of selected UTXOs
+     * @param amountInSatoshis - Transaction amount
+     * @param feePriority - Fee priority level
+     * @returns Object with feeEstimate, changeAmount, changeAmountNumber, and hasChangeOutput
+     */
+    private calculateFeeAndChange;
+    /**
+     * Adds inputs to PSBT from selected UTXOs
+     * @param psbt - PSBT to add inputs to
+     * @param selectedUTXOs - Selected UTXOs
+     * @param publicKeyPair - ECPair public key pair
+     * @param network - Bitcoin network
+     */
+    private addInputsToPsbt;
+    /**
+     * Adds outputs to PSBT (recipient and optionally change)
+     * @param psbt - PSBT to add outputs to
+     * @param recipientAddress - Recipient address
+     * @param accountAddress - Account address for change
+     * @param amountInSatoshisNumber - Transaction amount
+     * @param changeAmountNumber - Change amount
+     * @param hasChangeOutput - Whether to include change output
+     * @param network - Bitcoin network
+     */
+    private addOutputsToPsbt;
     /**
      * Builds a PSBT for a Bitcoin transaction with real UTXOs
+     * Uses Largest-First UTXO selection strategy with accurate vSize fee estimation
      * @param options - Options for building the PSBT
      * @returns A PSBT in Base64 format
      * @throws {DynamicError} If insufficient funds, no UTXOs, or other errors
@@ -16,12 +79,13 @@ export declare class PsbtBuilderService {
     /**
      * Helper method to create BuildPsbtOptions from transaction and account details
      * @param accountAddress - The account address
-     * @param transaction - The Bitcoin transaction
+     * @param transaction - The Bitcoin transaction (must have amount and recipientAddress)
      * @param publicKeyHex - The public key in hex format
+     * @param feePriority - Optional fee priority (defaults to 'medium')
      * @returns BuildPsbtOptions
      */
     static createBuildOptions(accountAddress: string, transaction: {
         amount: bigint;
         recipientAddress: string;
-    }, publicKeyHex: string): BuildPsbtOptions;
+    }, publicKeyHex: string, feePriority?: 'high' | 'medium' | 'low'): BuildPsbtOptions;
 }

package/src/services/PsbtBuilderService.js

@@ -2,10 +2,10 @@
 import { __awaiter } from '../../_virtual/_tslib.js';
 import ecc from '@bitcoinerlab/secp256k1';
 import { ECPairFactory } from 'ecpair';
-import { Psbt, payments, address } from 'bitcoinjs-lib';
+import { payments, address, Psbt } 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 { SATOSHIS_PER_BTC, DUST_LIMIT, RBF_SEQUENCE } from '../const.js';
 import { getBitcoinNetwork } from '../utils/getBitcoinNetwork/getBitcoinNetwork.js';
 
 const logger = new Logger('PsbtBuilderService');
@@ -16,104 +16,234 @@ class PsbtBuilderService {
     constructor(mempoolApiService) {
         this.mempoolApiService = mempoolApiService;
     }
+    /**
+     * Filters out Taproot (P2TR) UTXOs to prevent accidental spending of Ordinals/Runes
+     * Since we only support Native SegWit (P2WPKH), we ensure the account address is not Taproot
+     * @param accountAddress - The account address to check
+     * @param utxos - Array of UTXOs to filter
+     * @returns Filtered array of UTXOs (only P2WPKH compatible)
+     */
+    filterTaprootUTXOs(accountAddress, utxos) {
+        // Safety check: Ensure account address is not Taproot (bc1p...)
+        if (accountAddress.toLowerCase().startsWith('bc1p') ||
+            accountAddress.toLowerCase().startsWith('tb1p')) {
+            logger.warn(`Account address ${accountAddress} appears to be Taproot. Only Native SegWit (P2WPKH) is supported.`);
+            throw new DynamicError('Taproot addresses are not supported. Only Native SegWit (P2WPKH) addresses are allowed.');
+        }
+        return utxos;
+    }
+    /**
+     * Selects UTXOs using Largest-First (Accumulator) strategy
+     * Sorts UTXOs by value (descending) and selects until we have enough to cover amount + fees
+     * @param utxos - Available UTXOs
+     * @param targetAmount - Target amount including fees and dust limit
+     * @returns Selected UTXOs
+     */
+    selectUTXOsLargestFirst(utxos, targetAmount) {
+        // Sort UTXOs by value (largest first)
+        const sortedUTXOs = [...utxos].sort((a, b) => b.value - a.value);
+        // Accumulate UTXOs until we have enough
+        const selected = [];
+        let total = 0;
+        for (const utxo of sortedUTXOs) {
+            selected.push(utxo);
+            total += utxo.value;
+            // Stop when we have enough to cover the target amount
+            if (total >= targetAmount) {
+                break;
+            }
+        }
+        return selected;
+    }
+    /**
+     * Calculates the total value of UTXOs
+     * @param utxos - Array of UTXOs
+     * @returns Total value in satoshis
+     */
+    calculateUTXOTotal(utxos) {
+        return utxos.reduce((total, utxo) => total + utxo.value, 0);
+    }
+    /**
+     * Validates and ensures sufficient funds for the transaction
+     * @param selectedUTXOs - Initially selected UTXOs
+     * @param allUTXOs - All available UTXOs
+     * @param selectedTotal - Total value of selected UTXOs
+     * @param amountInSatoshisNumber - Transaction amount
+     * @param feeEstimate - Estimated fee
+     * @returns Validated selected UTXOs
+     * @throws {DynamicError} If insufficient funds
+     */
+    validateAndSelectUTXOs(selectedUTXOs, allUTXOs, selectedTotal, amountInSatoshisNumber, feeEstimate) {
+        const requiredAmount = amountInSatoshisNumber + feeEstimate;
+        if (selectedTotal >= requiredAmount) {
+            return selectedUTXOs;
+        }
+        // Try with all UTXOs if selection wasn't enough
+        if (selectedUTXOs.length < allUTXOs.length) {
+            const allTotal = this.calculateUTXOTotal(allUTXOs);
+            if (allTotal < requiredAmount) {
+                throw new DynamicError(`Insufficient funds. Available: ${allTotal / SATOSHIS_PER_BTC} BTC (${allTotal} satoshis), Required: ${amountInSatoshisNumber / SATOSHIS_PER_BTC} BTC (${amountInSatoshisNumber} satoshis) + fees`);
+            }
+            return allUTXOs;
+        }
+        throw new DynamicError(`Insufficient funds. Available: ${selectedTotal / SATOSHIS_PER_BTC} BTC (${selectedTotal} satoshis), Required: ${amountInSatoshisNumber / SATOSHIS_PER_BTC} BTC (${amountInSatoshisNumber} satoshis) + fees`);
+    }
+    /**
+     * Calculates fee estimate and change amount, handling dust limit
+     * @param accountAddress - Account address for fee estimation
+     * @param selectedUTXOs - Selected UTXOs
+     * @param selectedTotalValue - Total value of selected UTXOs
+     * @param amountInSatoshis - Transaction amount
+     * @param feePriority - Fee priority level
+     * @returns Object with feeEstimate, changeAmount, changeAmountNumber, and hasChangeOutput
+     */
+    calculateFeeAndChange(accountAddress, selectedUTXOs, selectedTotalValue, amountInSatoshis, feePriority) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Re-estimate fee with actual number of inputs
+            let feeEstimate = yield this.mempoolApiService.estimateTransactionFee(accountAddress, selectedUTXOs.length, 1, // Start with 1 output (recipient only)
+            feePriority);
+            let maxToSpend = selectedTotalValue - feeEstimate;
+            let changeAmount = BigInt(maxToSpend) - amountInSatoshis;
+            // If change will be above dust limit, re-estimate fees for 2 outputs
+            const changeAmountNumber = Number(changeAmount);
+            if (changeAmount > 0 && changeAmountNumber >= DUST_LIMIT) {
+                feeEstimate = yield this.mempoolApiService.estimateTransactionFee(accountAddress, selectedUTXOs.length, 2, // recipient + change output
+                feePriority);
+                maxToSpend = selectedTotalValue - feeEstimate;
+                changeAmount = BigInt(maxToSpend) - amountInSatoshis;
+            }
+            const finalChangeAmountNumber = Number(changeAmount);
+            const hasChangeOutput = changeAmount > 0 && finalChangeAmountNumber >= DUST_LIMIT;
+            // Final fee adjustment: if change < dust limit, add it to fee
+            if (changeAmount > 0 && finalChangeAmountNumber < DUST_LIMIT) {
+                feeEstimate += finalChangeAmountNumber;
+            }
+            return {
+                changeAmount,
+                changeAmountNumber: finalChangeAmountNumber,
+                feeEstimate,
+                hasChangeOutput,
+            };
+        });
+    }
+    /**
+     * Adds inputs to PSBT from selected UTXOs
+     * @param psbt - PSBT to add inputs to
+     * @param selectedUTXOs - Selected UTXOs
+     * @param publicKeyPair - ECPair public key pair
+     * @param network - Bitcoin network
+     */
+    addInputsToPsbt(psbt, selectedUTXOs, publicKeyPair, network) {
+        for (const utxo of selectedUTXOs) {
+            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,
+                sequence: RBF_SEQUENCE, // Enable RBF (Replace-By-Fee)
+                witnessUtxo: {
+                    script: outputScript,
+                    value: utxo.value,
+                },
+            });
+        }
+    }
+    /**
+     * Adds outputs to PSBT (recipient and optionally change)
+     * @param psbt - PSBT to add outputs to
+     * @param recipientAddress - Recipient address
+     * @param accountAddress - Account address for change
+     * @param amountInSatoshisNumber - Transaction amount
+     * @param changeAmountNumber - Change amount
+     * @param hasChangeOutput - Whether to include change output
+     * @param network - Bitcoin network
+     */
+    addOutputsToPsbt(psbt, recipientAddress, accountAddress, amountInSatoshisNumber, changeAmountNumber, hasChangeOutput, network) {
+        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,
+        });
+        if (hasChangeOutput) {
+            psbt.addOutput({
+                script: address.toOutputScript(accountAddress, network),
+                value: changeAmountNumber,
+            });
+        }
+    }
     /**
      * Builds a PSBT for a Bitcoin transaction with real UTXOs
+     * Uses Largest-First UTXO selection strategy with accurate vSize fee estimation
      * @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;
+            const { accountAddress, recipientAddress, amountInSatoshis, publicKeyHex, network, feePriority = 'medium', } = options;
+            logger.debug(`buildPsbt called with feePriority: ${feePriority}, amount: ${amountInSatoshis} satoshis`);
             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) {
+            const allUTXOs = yield this.mempoolApiService.getUTXOs(accountAddress);
+            if (allUTXOs.length === 0) {
                 throw new DynamicError('No UTXOs found for this address');
             }
-            // Get public key for creating output scripts
+            const utxos = this.filterTaprootUTXOs(accountAddress, allUTXOs);
             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);
+            const amountInSatoshisNumber = Number(amountInSatoshis);
+            // Initial fee estimate with 1 input and 1 output
+            const initialFeeEstimate = yield this.mempoolApiService.estimateTransactionFee(accountAddress, 1, 1, feePriority);
+            // Target amount: transaction amount + fee + dust limit (for change output safety)
+            const targetAmount = amountInSatoshisNumber + initialFeeEstimate + DUST_LIMIT;
+            // Select UTXOs using Largest-First strategy
+            let selectedUTXOs = this.selectUTXOsLargestFirst(utxos, targetAmount);
+            const selectedTotal = this.calculateUTXOTotal(selectedUTXOs);
+            // Validate and ensure sufficient funds
+            selectedUTXOs = this.validateAndSelectUTXOs(selectedUTXOs, utxos, selectedTotal, amountInSatoshisNumber, initialFeeEstimate);
+            const selectedTotalValue = this.calculateUTXOTotal(selectedUTXOs);
+            // Calculate fee and change with proper dust limit handling
+            const { feeEstimate, changeAmountNumber, hasChangeOutput } = yield this.calculateFeeAndChange(accountAddress, selectedUTXOs, selectedTotalValue, amountInSatoshis, feePriority);
+            // Final check: ensure we have enough after final fee calculation
+            const maxToSpend = selectedTotalValue - feeEstimate;
+            if (maxToSpend < amountInSatoshisNumber) {
                 throw new DynamicError(`Insufficient funds. Available: ${maxToSpend / SATOSHIS_PER_BTC} BTC (${maxToSpend} satoshis), Required: ${amountInSatoshisNumber / SATOSHIS_PER_BTC} BTC (${amountInSatoshisNumber} satoshis)`);
             }
-            // Create PSBT
+            // Create PSBT and add inputs/outputs
             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`);
+            this.addInputsToPsbt(psbt, selectedUTXOs, publicKeyPair, network);
+            this.addOutputsToPsbt(psbt, recipientAddress, accountAddress, amountInSatoshisNumber, changeAmountNumber, hasChangeOutput, network);
+            logger.debug(`buildPsbt created PSBT for recipientAddress: ${recipientAddress}, amount: ${amountInSatoshisNumber} satoshis (${amountInSatoshisNumber / SATOSHIS_PER_BTC} BTC), change: ${changeAmountNumber} satoshis, estimated fee: ${feeEstimate} satoshis, feePriority: ${feePriority}, inputs: ${selectedUTXOs.length}`);
             return psbt.toBase64();
         });
     }
     /**
      * Helper method to create BuildPsbtOptions from transaction and account details
      * @param accountAddress - The account address
-     * @param transaction - The Bitcoin transaction
+     * @param transaction - The Bitcoin transaction (must have amount and recipientAddress)
      * @param publicKeyHex - The public key in hex format
+     * @param feePriority - Optional fee priority (defaults to 'medium')
      * @returns BuildPsbtOptions
      */
-    static createBuildOptions(accountAddress, transaction, publicKeyHex) {
+    static createBuildOptions(accountAddress, transaction, publicKeyHex, feePriority = 'medium') {
         return {
             accountAddress,
             amountInSatoshis: transaction.amount,
+            feePriority,
             network: getBitcoinNetwork(accountAddress),
             publicKeyHex,
             recipientAddress: transaction.recipientAddress,

package/src/types.d.ts

@@ -32,6 +32,7 @@ export type BitcoinConnectedAccount = {
 export type BitcoinTransaction = {
     amount: bigint;
     recipientAddress: string;
+    feePriority?: FeePriority;
 };
 export type SignPsbtOptions = {
     autoFinalized: boolean;
@@ -52,6 +53,21 @@ export type BitcoinSignPsbtRequestSignature = {
     signingIndexes: number[] | undefined;
     disableAddressValidation?: boolean;
 };
+/**
+ * PSBT signing request specifically for embedded wallets (DynamicWaasBitcoinConnector)
+ *
+ * Embedded wallets:
+ * - Only support PSBT format (Base64)
+ * - Automatically sign all inputs that belong to the wallet address
+ * - Always use SIGHASH_ALL (0x01)
+ */
+export type EmbeddedWalletSignPsbtRequest = {
+    /**
+     * The unsigned PSBT in Base64 format.
+     * Embedded wallets only support PSBT format, not raw transaction hex.
+     */
+    unsignedPsbtBase64: string;
+};
 export type SatsConnectSignTransactionInput = {
     message?: string;
     psbtBase64: string;
@@ -173,11 +189,13 @@ export interface ParsedTransaction {
     inputs: ParsedTransactionInput[];
     outputs: ParsedTransactionOutput[];
 }
+export type FeePriority = 'high' | 'medium' | 'low';
 export interface BuildPsbtOptions {
     accountAddress: string;
     recipientAddress: string;
     amountInSatoshis: bigint;
     publicKeyHex: string;
     network: Network;
+    feePriority?: FeePriority;
 }
 export {};