@dynamic-labs-sdk/bitcoin 0.4.0 → 0.6.0

package/dist/index.cjs.js

@@ -1,19 +1,734 @@
-const require_addBitcoinInjectedWalletsExtension = require('./addBitcoinInjectedWalletsExtension-C_-dWLm4.cjs.js');
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const require_addBitcoinInjectedWalletsExtension = require('./addBitcoinInjectedWalletsExtension-BRn8yV6c.cjs.js');
 let _dynamic_labs_sdk_assert_package_version = require("@dynamic-labs-sdk/assert-package-version");
 let _dynamic_labs_sdk_client_core = require("@dynamic-labs-sdk/client/core");
 let _dynamic_labs_sdk_client = require("@dynamic-labs-sdk/client");
+let _dynamic_labs_sdk_api_core = require("@dynamic-labs/sdk-api-core");
+let bitcoinjs_lib = require("bitcoinjs-lib");
+let _dynamic_labs_sdk_client_waas_core = require("@dynamic-labs-sdk/client/waas/core");
+let _bitcoinerlab_secp256k1 = require("@bitcoinerlab/secp256k1");
+_bitcoinerlab_secp256k1 = __toESM(_bitcoinerlab_secp256k1);
+let ecpair = require("ecpair");
+
+//#region src/errors/TransactionBroadcastFailedError.ts
+var TransactionBroadcastFailedError = class extends _dynamic_labs_sdk_client.BaseError {
+	response;
+	constructor({ response }) {
+		super({
+			cause: null,
+			code: "transaction_broadcast_failed_error",
+			details: `Status: ${response.status} ${response.statusText}`,
+			docsUrl: null,
+			name: "TransactionBroadcastFailedError",
+			shortMessage: "Failed to broadcast transaction to mempool"
+		});
+		this.response = response;
+	}
+};
+
+//#endregion
+//#region src/errors/TransactionRequiredError.ts
+var TransactionRequiredError = class extends _dynamic_labs_sdk_client.BaseError {
+	constructor() {
+		super({
+			cause: null,
+			code: "transaction_required_error",
+			docsUrl: null,
+			name: "TransactionRequiredError",
+			shortMessage: "No transaction specified for broadcast"
+		});
+	}
+};
+
+//#endregion
+//#region src/waas/constants.ts
+/**
+* Mempool.space API URL for mainnet
+*/
+const MEMPOOL_API_URL = "https://mempool.space/api";
+/**
+* Number of satoshis per Bitcoin
+*/
+const SATOSHIS_PER_BTC = 1e8;
+/**
+* Bitcoin's dust limit in satoshis
+* Outputs below this value are considered "dust" and will be rejected by nodes
+*/
+const DUST_LIMIT = 546;
+/**
+* Accurate vSize constants for Native SegWit (P2WPKH) transactions
+* Used for precise fee estimation
+*/
+const VSIZE_OVERHEAD = 10.5;
+const VSIZE_INPUT_P2WPKH = 68;
+const VSIZE_OUTPUT_P2WPKH = 31;
+/**
+* Minimum relay fee in satoshis
+* Added to fee estimate to ensure transaction propagation
+*/
+const MIN_RELAY_FEE = 111;
+/**
+* Conservative default fee estimate in satoshis
+* Used as fallback when fee estimation fails
+*/
+const DEFAULT_FEE_ESTIMATE = 1e3;
+/**
+* RBF (Replace-By-Fee) sequence number
+* 0xfffffffd = 4294967293 (enables RBF, not final)
+*/
+const RBF_SEQUENCE = 4294967293;
+
+//#endregion
+//#region src/waas/utils/broadcastTransaction/broadcastTransaction.ts
+/**
+* Sends a raw Bitcoin transaction to the mempool
+*
+* @param rawTransaction - The raw transaction in hex format
+* @returns The transaction ID
+* @throws {TransactionRequiredError} if no transaction is specified
+* @throws {TransactionBroadcastFailedError} if broadcasting fails
+*/
+const broadcastTransaction = async (rawTransaction) => {
+	if (!rawTransaction) throw new TransactionRequiredError();
+	const response = await fetch(`${MEMPOOL_API_URL}/tx`, {
+		body: rawTransaction,
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		method: "POST"
+	});
+	if (!response.ok) throw new TransactionBroadcastFailedError({ response });
+	return response.text();
+};
+
+//#endregion
+//#region src/errors/InsufficientFundsError.ts
+var InsufficientFundsError = class extends _dynamic_labs_sdk_client.BaseError {
+	availableSatoshis;
+	requiredSatoshis;
+	constructor({ availableSatoshis, requiredSatoshis }) {
+		const availableBtc = availableSatoshis / SATOSHIS_PER_BTC;
+		const requiredBtc = requiredSatoshis / SATOSHIS_PER_BTC;
+		super({
+			cause: null,
+			code: "insufficient_funds_error",
+			details: `Available: ${availableBtc} BTC (${availableSatoshis} satoshis), Required: ${requiredBtc} BTC (${requiredSatoshis} satoshis)`,
+			docsUrl: null,
+			name: "InsufficientFundsError",
+			shortMessage: "Insufficient funds for transaction"
+		});
+		this.availableSatoshis = availableSatoshis;
+		this.requiredSatoshis = requiredSatoshis;
+	}
+};
 
+//#endregion
+//#region src/errors/InvalidAmountError.ts
+var InvalidAmountError = class extends _dynamic_labs_sdk_client.BaseError {
+	amountInSatoshis;
+	constructor({ amountInSatoshis, reason }) {
+		super({
+			cause: null,
+			code: "invalid_amount_error",
+			details: `Amount: ${amountInSatoshis} satoshis`,
+			docsUrl: null,
+			name: "InvalidAmountError",
+			shortMessage: reason
+		});
+		this.amountInSatoshis = amountInSatoshis;
+	}
+};
+
+//#endregion
+//#region src/errors/NoUTXOsFoundError.ts
+var NoUTXOsFoundError = class extends _dynamic_labs_sdk_client.BaseError {
+	address;
+	constructor({ address: address$1 }) {
+		super({
+			cause: null,
+			code: "no_utxos_found_error",
+			details: `Address: ${address$1}`,
+			docsUrl: null,
+			name: "NoUTXOsFoundError",
+			shortMessage: "No UTXOs found for this address"
+		});
+		this.address = address$1;
+	}
+};
+
+//#endregion
+//#region src/errors/SegwitOutputScriptError.ts
+var SegwitOutputScriptError = class extends _dynamic_labs_sdk_client.BaseError {
+	constructor() {
+		super({
+			cause: null,
+			code: "segwit_output_script_error",
+			docsUrl: null,
+			name: "SegwitOutputScriptError",
+			shortMessage: "Failed to create segwit output script"
+		});
+	}
+};
+
+//#endregion
+//#region src/waas/utils/addInputsToPsbt/addInputsToPsbt.ts
+/**
+* Adds inputs to PSBT from selected UTXOs
+*
+* @param options.network - Bitcoin network configuration (mainnet or testnet)
+* @param options.psbt - The PSBT instance to add inputs to
+* @param options.publicKeyPair - Key pair containing the public key for witness script
+* @param options.selectedUTXOs - Array of UTXOs to add as inputs
+*/
+const addInputsToPsbt = (options) => {
+	const { network, psbt, publicKeyPair, selectedUTXOs } = options;
+	for (const utxo of selectedUTXOs) {
+		const outputScript = bitcoinjs_lib.payments.p2wpkh({
+			network,
+			pubkey: publicKeyPair.publicKey
+		}).output;
+		if (!outputScript) throw new SegwitOutputScriptError();
+		const txidBuffer = new Uint8Array((0, _dynamic_labs_sdk_client_core.getBuffer)().from(utxo.txid, "hex").reverse());
+		psbt.addInput({
+			hash: txidBuffer,
+			index: utxo.vout,
+			sequence: RBF_SEQUENCE,
+			witnessUtxo: {
+				script: outputScript,
+				value: BigInt(utxo.value)
+			}
+		});
+	}
+};
+
+//#endregion
+//#region src/waas/utils/addOutputsToPsbt/addOutputsToPsbt.ts
+/**
+* Adds outputs to PSBT (recipient and optionally change)
+*
+* @param options.accountAddress - The sender's address for receiving change
+* @param options.amountInSatoshis - Amount to send to the recipient in satoshis
+* @param options.changeAmount - Amount to return as change in satoshis
+* @param options.hasChangeOutput - Whether to include a change output
+* @param options.network - Bitcoin network configuration (mainnet or testnet)
+* @param options.psbt - The PSBT instance to add outputs to
+* @param options.recipientAddress - The recipient's Bitcoin address
+*/
+const addOutputsToPsbt = (options) => {
+	const { accountAddress, amountInSatoshis, changeAmount, hasChangeOutput, network, psbt, recipientAddress } = options;
+	if (amountInSatoshis < DUST_LIMIT) throw new InvalidAmountError({
+		amountInSatoshis,
+		reason: `Amount is below dust limit of ${DUST_LIMIT} satoshis (${DUST_LIMIT / SATOSHIS_PER_BTC} BTC)`
+	});
+	psbt.addOutput({
+		script: bitcoinjs_lib.address.toOutputScript(recipientAddress, network),
+		value: BigInt(amountInSatoshis)
+	});
+	if (hasChangeOutput) psbt.addOutput({
+		script: bitcoinjs_lib.address.toOutputScript(accountAddress, network),
+		value: BigInt(changeAmount)
+	});
+};
+
+//#endregion
+//#region src/errors/FeeRecommendationsFetchError.ts
+var FeeRecommendationsFetchError = class extends _dynamic_labs_sdk_client.BaseError {
+	response;
+	constructor({ response }) {
+		super({
+			cause: null,
+			code: "fee_recommendations_fetch_error",
+			details: `Status: ${response.status} ${response.statusText}`,
+			docsUrl: null,
+			name: "FeeRecommendationsFetchError",
+			shortMessage: "Failed to fetch fee recommendations from mempool"
+		});
+		this.response = response;
+	}
+};
+
+//#endregion
+//#region src/waas/utils/getFeeRecommendations/getFeeRecommendations.ts
+/**
+* Gets fee recommendations from mempool.space API
+*
+* @returns Fee recommendation data with rates in sat/vB
+* @throws FeeRecommendationsFetchError if fetching fee recommendations fails
+*/
+const getFeeRecommendations = async () => {
+	const response = await fetch(`${MEMPOOL_API_URL}/v1/fees/recommended`);
+	if (!response.ok) throw new FeeRecommendationsFetchError({ response });
+	return response.json();
+};
+
+//#endregion
+//#region src/waas/utils/estimateTransactionFee/estimateTransactionFee.ts
+/**
+* Estimates transaction fees based on number of inputs and outputs using accurate vSize
+*
+* @param options.feePriority - Priority level for fee estimation ('low', 'medium', or 'high')
+* @param options.numInputs - Number of transaction inputs (UTXOs being spent)
+* @param options.numOutputs - Number of transaction outputs
+* @returns Estimated fee in satoshis
+*/
+const estimateTransactionFee = async ({ feePriority = "medium", numInputs, numOutputs }) => {
+	try {
+		const feeData = await getFeeRecommendations();
+		let feePerByte;
+		if (feePriority === "high") feePerByte = feeData.fastestFee ?? feeData.halfHourFee ?? 1;
+		else if (feePriority === "low") feePerByte = feeData.economyFee ?? feeData.hourFee ?? 1;
+		else feePerByte = feeData.halfHourFee ?? feeData.hourFee ?? feeData.economyFee ?? 1;
+		const vSize = VSIZE_OVERHEAD + numInputs * VSIZE_INPUT_P2WPKH + numOutputs * VSIZE_OUTPUT_P2WPKH;
+		return Math.ceil(feePerByte * vSize) + MIN_RELAY_FEE;
+	} catch {
+		return DEFAULT_FEE_ESTIMATE;
+	}
+};
+
+//#endregion
+//#region src/waas/utils/calculateFeeAndChange/calculateFeeAndChange.ts
+/**
+* Calculates fee estimate and change amount, handling dust limit
+*
+* @param options.amountInSatoshis - Amount to send in satoshis
+* @param options.feePriority - Priority level for fee estimation ('low', 'medium', or 'high')
+* @param options.selectedTotalValue - Total value of selected UTXOs in satoshis
+* @param options.selectedUTXOs - Array of selected UTXOs for the transaction
+* @returns Object with feeEstimate, changeAmountNumber, and hasChangeOutput
+*/
+const calculateFeeAndChange = async ({ amountInSatoshis, feePriority, selectedTotalValue, selectedUTXOs }) => {
+	let feeEstimate = await estimateTransactionFee({
+		feePriority,
+		numInputs: selectedUTXOs.length,
+		numOutputs: 1
+	});
+	let maxToSpend = selectedTotalValue - feeEstimate;
+	let changeAmount = BigInt(maxToSpend) - amountInSatoshis;
+	if (changeAmount > 0 && Number(changeAmount) >= DUST_LIMIT) {
+		feeEstimate = await estimateTransactionFee({
+			feePriority,
+			numInputs: selectedUTXOs.length,
+			numOutputs: 2
+		});
+		maxToSpend = selectedTotalValue - feeEstimate;
+		changeAmount = BigInt(maxToSpend) - amountInSatoshis;
+	}
+	const finalChangeAmountNumber = Number(changeAmount);
+	const hasChangeOutput = changeAmount > 0 && finalChangeAmountNumber >= DUST_LIMIT;
+	if (changeAmount > 0 && finalChangeAmountNumber < DUST_LIMIT) feeEstimate += finalChangeAmountNumber;
+	return {
+		changeAmountNumber: finalChangeAmountNumber,
+		feeEstimate,
+		hasChangeOutput
+	};
+};
+
+//#endregion
+//#region src/waas/utils/calculateUTXOTotal/calculateUTXOTotal.ts
+/**
+* Calculates the total value of UTXOs
+*
+* @param utxos - Array of UTXOs
+* @returns Total value in satoshis
+*/
+const calculateUTXOTotal = (utxos) => utxos.reduce((total, utxo) => total + utxo.value, 0);
+
+//#endregion
+//#region src/errors/UTXOsFetchError.ts
+var UTXOsFetchError = class extends _dynamic_labs_sdk_client.BaseError {
+	address;
+	response;
+	constructor({ address: address$1, response }) {
+		super({
+			cause: null,
+			code: "utxos_fetch_error",
+			details: `Address: ${address$1}, Status: ${response.status} ${response.statusText}`,
+			docsUrl: null,
+			name: "UTXOsFetchError",
+			shortMessage: "Failed to fetch UTXOs from mempool"
+		});
+		this.address = address$1;
+		this.response = response;
+	}
+};
+
+//#endregion
+//#region src/waas/utils/getUTXOs/getUTXOs.ts
+/**
+* Gets UTXOs for a Bitcoin address from mempool.space API
+*
+* @param address - The Bitcoin address to get UTXOs for
+* @returns Array of UTXOs
+* @throws UTXOsFetchError if fetching UTXOs fails
+*/
+const getUTXOs = async (address$1) => {
+	const response = await fetch(`${MEMPOOL_API_URL}/address/${address$1}/utxo`);
+	if (!response.ok) throw new UTXOsFetchError({
+		address: address$1,
+		response
+	});
+	return response.json();
+};
+
+//#endregion
+//#region src/waas/utils/selectUTXOsLargestFirst/selectUTXOsLargestFirst.ts
+/**
+* Selects UTXOs using Largest-First (Accumulator) strategy
+* Sorts UTXOs by value (descending) and selects until we have enough to cover amount + fees
+*
+* @param options.targetAmount - Target amount in satoshis (amount + fees + dust limit)
+* @param options.utxos - Array of available UTXOs to select from
+* @returns Selected UTXOs
+*/
+const selectUTXOsLargestFirst = (options) => {
+	const { targetAmount, utxos } = options;
+	const sortedUTXOs = [...utxos].sort((a, b) => b.value - a.value);
+	const selected = [];
+	let total = 0;
+	for (const utxo of sortedUTXOs) {
+		selected.push(utxo);
+		total += utxo.value;
+		if (total >= targetAmount) break;
+	}
+	return selected;
+};
+
+//#endregion
+//#region src/waas/utils/validateAndSelectUTXOs/validateAndSelectUTXOs.ts
+/**
+* Validates and ensures sufficient funds for the transaction
+*
+* @param options.allUTXOs - Complete array of available UTXOs for the address
+* @param options.amountInSatoshis - Amount to send in satoshis
+* @param options.feeEstimate - Estimated transaction fee in satoshis
+* @param options.selectedTotal - Total value of initially selected UTXOs in satoshis
+* @param options.selectedUTXOs - Array of initially selected UTXOs
+* @returns Validated selected UTXOs
+* @throws InsufficientFundsError if insufficient funds
+*/
+const validateAndSelectUTXOs = (options) => {
+	const { allUTXOs, amountInSatoshis, feeEstimate, selectedTotal, selectedUTXOs } = options;
+	const requiredAmount = amountInSatoshis + feeEstimate;
+	if (selectedTotal >= requiredAmount) return selectedUTXOs;
+	if (selectedUTXOs.length < allUTXOs.length) {
+		const allTotal = calculateUTXOTotal(allUTXOs);
+		if (allTotal < requiredAmount) throw new InsufficientFundsError({
+			availableSatoshis: allTotal,
+			requiredSatoshis: amountInSatoshis
+		});
+		return allUTXOs;
+	}
+	throw new InsufficientFundsError({
+		availableSatoshis: selectedTotal,
+		requiredSatoshis: amountInSatoshis
+	});
+};
+
+//#endregion
+//#region src/errors/TaprootAddressNotSupportedError.ts
+var TaprootAddressNotSupportedError = class extends _dynamic_labs_sdk_client.BaseError {
+	constructor() {
+		super({
+			cause: null,
+			code: "taproot_address_not_supported",
+			docsUrl: null,
+			name: "TaprootAddressNotSupportedError",
+			shortMessage: "Taproot addresses are not supported for PSBT building. Only Native SegWit (P2WPKH) addresses are allowed."
+		});
+	}
+};
+
+//#endregion
+//#region src/waas/utils/validateNotTaproot/validateNotTaproot.ts
+/**
+* Validates that the address is not a Taproot address
+* Only Native SegWit (P2WPKH) is supported for PSBT building
+*
+* @param accountAddress - The account address to check
+* @throws TaprootAddressNotSupportedError if address is Taproot
+*/
+const validateNotTaproot = (accountAddress) => {
+	if (accountAddress.toLowerCase().startsWith("bc1p") || accountAddress.toLowerCase().startsWith("tb1p")) throw new TaprootAddressNotSupportedError();
+};
+
+//#endregion
+//#region src/waas/utils/buildPsbt/buildPsbt.ts
+/**
+* Builds a PSBT for a Bitcoin transaction with real UTXOs
+* Uses Largest-First UTXO selection strategy with accurate vSize fee estimation
+*
+* @param options.accountAddress - The sender's Bitcoin address
+* @param options.amountInSatoshis - Amount to send in satoshis
+* @param options.feePriority - Priority level for fee estimation ('low', 'medium', or 'high')
+* @param options.network - Bitcoin network configuration (mainnet or testnet)
+* @param options.publicKeyHex - The sender's public key in hexadecimal format
+* @param options.recipientAddress - The recipient's Bitcoin address
+* @returns A PSBT in Base64 format
+* @throws Error if insufficient funds, no UTXOs, or other errors
+*/
+const buildPsbt = async ({ accountAddress, amountInSatoshis, feePriority = "medium", network, publicKeyHex, recipientAddress }) => {
+	if (amountInSatoshis <= BigInt(0)) throw new InvalidAmountError({
+		amountInSatoshis: Number(amountInSatoshis),
+		reason: "Amount must be greater than 0"
+	});
+	validateNotTaproot(accountAddress);
+	const allUTXOs = await getUTXOs(accountAddress);
+	if (allUTXOs.length === 0) throw new NoUTXOsFoundError({ address: accountAddress });
+	const publicKeyBuffer = new Uint8Array((0, _dynamic_labs_sdk_client_core.getBuffer)().from(publicKeyHex, "hex"));
+	const publicKeyPair = (0, ecpair.ECPairFactory)(_bitcoinerlab_secp256k1.default).fromPublicKey(publicKeyBuffer, { compressed: true });
+	const amountInSatoshisNumber = Number(amountInSatoshis);
+	const initialFeeEstimate = await estimateTransactionFee({
+		feePriority,
+		numInputs: 1,
+		numOutputs: 1
+	});
+	let selectedUTXOs = selectUTXOsLargestFirst({
+		targetAmount: amountInSatoshisNumber + initialFeeEstimate + DUST_LIMIT,
+		utxos: allUTXOs
+	});
+	selectedUTXOs = validateAndSelectUTXOs({
+		allUTXOs,
+		amountInSatoshis: amountInSatoshisNumber,
+		feeEstimate: initialFeeEstimate,
+		selectedTotal: calculateUTXOTotal(selectedUTXOs),
+		selectedUTXOs
+	});
+	const selectedTotalValue = calculateUTXOTotal(selectedUTXOs);
+	const { changeAmountNumber, feeEstimate, hasChangeOutput } = await calculateFeeAndChange({
+		amountInSatoshis,
+		feePriority,
+		selectedTotalValue,
+		selectedUTXOs
+	});
+	const maxToSpend = selectedTotalValue - feeEstimate;
+	if (maxToSpend < amountInSatoshisNumber) throw new InsufficientFundsError({
+		availableSatoshis: maxToSpend,
+		requiredSatoshis: amountInSatoshisNumber
+	});
+	const psbt = new bitcoinjs_lib.Psbt({ network });
+	addInputsToPsbt({
+		network,
+		psbt,
+		publicKeyPair,
+		selectedUTXOs
+	});
+	addOutputsToPsbt({
+		accountAddress,
+		amountInSatoshis: amountInSatoshisNumber,
+		changeAmount: changeAmountNumber,
+		hasChangeOutput,
+		network,
+		psbt,
+		recipientAddress
+	});
+	return psbt.toBase64();
+};
+
+//#endregion
+//#region src/errors/PublicKeyNotFoundError.ts
+var PublicKeyNotFoundError = class extends _dynamic_labs_sdk_client.BaseError {
+	constructor(address$1) {
+		super({
+			cause: null,
+			code: "public_key_not_found_error",
+			docsUrl: null,
+			name: "PublicKeyNotFoundError",
+			shortMessage: `No public key found for address ${address$1}`
+		});
+	}
+};
+
+//#endregion
+//#region src/waas/utils/getPublicKeyForWalletAccount/getPublicKeyForWalletAccount.ts
+/**
+* Gets the public key for a wallet account from the user's verified credentials
+*/
+const getPublicKeyForWalletAccount = (walletAccount, client) => {
+	const user = (0, _dynamic_labs_sdk_client_core.getCore)(client).state.get().user;
+	for (const credential of user?.verifiedCredentials ?? []) {
+		const additionalAddress = credential.walletAdditionalAddresses?.find((addr) => addr.address === walletAccount.address);
+		if (additionalAddress?.publicKey) return additionalAddress.publicKey;
+	}
+	throw new PublicKeyNotFoundError(walletAccount.address);
+};
+
+//#endregion
+//#region src/waas/utils/createWalletProviderForWaasBitcoin/createWalletProviderForWaasBitcoin.ts
+const createWalletProviderForWaasBitcoin = (sdkClient) => {
+	const chain = "BTC";
+	const walletProviderType = _dynamic_labs_sdk_api_core.WalletProviderEnum.EmbeddedWallet;
+	const key = (0, _dynamic_labs_sdk_client_core.formatWalletProviderKey)({
+		chain,
+		displayName: _dynamic_labs_sdk_client_waas_core.DYNAMIC_WAAS_METADATA.displayName,
+		walletProviderType
+	});
+	const waasProvider = (0, _dynamic_labs_sdk_client_waas_core.createWaasProvider)({
+		chain,
+		sdkClient
+	});
+	const getActiveNetworkId = async () => (0, _dynamic_labs_sdk_client_core.getActiveNetworkIdFromLastKnownRegistry)({
+		client: sdkClient,
+		walletProviderKey: key
+	});
+	const switchActiveNetwork = async ({ networkId }) => (0, _dynamic_labs_sdk_client_core.switchActiveNetworkInLastKnownRegistry)({
+		client: sdkClient,
+		networkId,
+		walletProviderKey: key
+	});
+	const getConnectedAddresses = async () => {
+		return { addresses: (0, _dynamic_labs_sdk_client_waas_core.getAllUserWaasAddressesForChain)({ chain }, sdkClient) };
+	};
+	const signPsbt$1 = async ({ request, walletAccount }) => {
+		(0, _dynamic_labs_sdk_client_core.assertDefined)(walletAccount, "Wallet account is required");
+		const waasClient = await waasProvider.getWaasClient();
+		const { signature: signedSessionId } = await (0, _dynamic_labs_sdk_client_core.getSignedSessionId)(sdkClient);
+		const mfaToken = await (0, _dynamic_labs_sdk_client_core.consumeMfaTokenIfRequiredForAction)({ mfaAction: _dynamic_labs_sdk_api_core.MFAAction.WalletWaasSign }, sdkClient);
+		return { signedPsbt: await waasClient.signTransaction({
+			authToken: sdkClient.token ?? void 0,
+			mfaToken,
+			senderAddress: walletAccount.address,
+			signedSessionId,
+			transaction: request.unsignedPsbtBase64
+		}) };
+	};
+	const signPsbts$1 = async ({ requests, walletAccount }) => {
+		(0, _dynamic_labs_sdk_client_core.assertDefined)(walletAccount, "Wallet account is required");
+		return { signedPsbts: await Promise.all(requests.map(async (request) => {
+			const { signedPsbt } = await signPsbt$1({
+				request,
+				walletAccount
+			});
+			return signedPsbt;
+		})) };
+	};
+	const signMessage = async ({ message, walletAccount }) => {
+		(0, _dynamic_labs_sdk_client_core.assertDefined)(walletAccount, "Wallet account is required");
+		const waasClient = await waasProvider.getWaasClient();
+		const { signature: signedSessionId } = await (0, _dynamic_labs_sdk_client_core.getSignedSessionId)(sdkClient);
+		const mfaToken = await (0, _dynamic_labs_sdk_client_core.consumeMfaTokenIfRequiredForAction)({ mfaAction: _dynamic_labs_sdk_api_core.MFAAction.WalletWaasSign }, sdkClient);
+		return { signature: await waasClient.signMessage({
+			accountAddress: walletAccount.address,
+			authToken: sdkClient.token ?? void 0,
+			bitcoinConfig: { network: "mainnet" },
+			message,
+			mfaToken,
+			signedSessionId
+		}) };
+	};
+	const buildPsbt$1 = async ({ transaction, walletAccount }) => {
+		(0, _dynamic_labs_sdk_client_core.assertDefined)(walletAccount, "Wallet account is required");
+		const publicKeyHex = getPublicKeyForWalletAccount(walletAccount, sdkClient);
+		return buildPsbt({
+			accountAddress: walletAccount.address,
+			amountInSatoshis: transaction.amount,
+			feePriority: transaction.feePriority ?? "medium",
+			network: bitcoinjs_lib.networks.bitcoin,
+			publicKeyHex,
+			recipientAddress: transaction.recipientAddress
+		});
+	};
+	const sendBitcoin$1 = async ({ transaction, walletAccount }) => {
+		(0, _dynamic_labs_sdk_client_core.assertDefined)(walletAccount, "Wallet account is required");
+		const { signedPsbt } = await signPsbt$1({
+			request: {
+				allowedSighash: [],
+				unsignedPsbtBase64: await buildPsbt$1({
+					transaction: {
+						amount: transaction.amount,
+						recipientAddress: transaction.recipientAddress
+					},
+					walletAccount
+				})
+			},
+			walletAccount
+		});
+		const psbt = bitcoinjs_lib.Psbt.fromBase64(signedPsbt, { network: bitcoinjs_lib.networks.bitcoin });
+		psbt.finalizeAllInputs();
+		return { transactionId: await broadcastTransaction(psbt.extractTransaction().toHex()) };
+	};
+	return {
+		...waasProvider,
+		buildPsbt: buildPsbt$1,
+		chain,
+		getActiveNetworkId,
+		getConnectedAddresses,
+		groupKey: (0, _dynamic_labs_sdk_client_core.formatWalletProviderGroupKey)(_dynamic_labs_sdk_client_waas_core.DYNAMIC_WAAS_METADATA.displayName),
+		key,
+		metadata: {
+			displayName: _dynamic_labs_sdk_client_waas_core.DYNAMIC_WAAS_METADATA.displayName,
+			icon: _dynamic_labs_sdk_client_waas_core.DYNAMIC_WAAS_METADATA.icon
+		},
+		sendBitcoin: sendBitcoin$1,
+		signMessage,
+		signPsbt: signPsbt$1,
+		signPsbts: signPsbts$1,
+		switchActiveNetwork,
+		walletProviderType
+	};
+};
+
+//#endregion
+//#region src/waas/addWaasBitcoinExtension/addWaasBitcoinExtension.ts
+const WAAS_BITCOIN_EXTENSION_KEY = "waasBitcoin";
+/**
+* Adds the Dynamic WaaS (Wallet as a Service) Bitcoin extension to the Dynamic client.
+*
+* This extension enables embedded wallet functionality for Bitcoin blockchain,
+* allowing users to have wallets managed by Dynamic's infrastructure.
+*
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+*/
+const addWaasBitcoinExtension = (client = (0, _dynamic_labs_sdk_client_core.getDefaultClient)()) => {
+	if ((0, _dynamic_labs_sdk_client_core.hasExtension)({ extensionKey: WAAS_BITCOIN_EXTENSION_KEY }, client)) return;
+	(0, _dynamic_labs_sdk_client_core.registerExtension)({ extensionKey: WAAS_BITCOIN_EXTENSION_KEY }, client);
+	require_addBitcoinInjectedWalletsExtension.registerBitcoinNetworkProviderBuilder(client);
+	const walletProviderRegistry = (0, _dynamic_labs_sdk_client_core.getWalletProviderRegistry)(client);
+	const walletProvider = createWalletProviderForWaasBitcoin(client);
+	walletProviderRegistry.register({
+		priority: _dynamic_labs_sdk_client_core.WalletProviderPriority.WALLET_SDK,
+		walletProvider
+	});
+};
+
+//#endregion
 //#region src/addBitcoinExtension/addBitcoinExtension.ts
 /**
 * Adds the Bitcoin extension to the Dynamic client.
 *
-* This is a convenience function that adds support for a variety of Bitcoin wallets,
-* like MagicEden, Xverse, Unisat, and more.
+* This is a convenience function that adds both the Bitcoin Injected Wallets extension
+* and the Dynamic WaaS Bitcoin extension, enabling support for all Bitcoin wallet types
+* including injected wallets (MagicEden, Xverse, Unisat, and more) and embedded wallets
+* managed by Dynamic's infrastructure.
 *
 * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
 */
 const addBitcoinExtension = (client = (0, _dynamic_labs_sdk_client_core.getDefaultClient)()) => {
 	require_addBitcoinInjectedWalletsExtension.addBitcoinInjectedWalletsExtension(client);
+	addWaasBitcoinExtension(client);
 };
 
 //#endregion
@@ -183,6 +898,9 @@ const signPsbts = async ({ walletAccount, requests }, client = (0, _dynamic_labs
 
 //#endregion
 exports.InvalidPsbtError = require_addBitcoinInjectedWalletsExtension.InvalidPsbtError;
+exports.TransactionBroadcastFailedError = TransactionBroadcastFailedError;
+exports.TransactionRequiredError = TransactionRequiredError;
+exports.__toESM = __toESM;
 exports.addBitcoinExtension = addBitcoinExtension;
 exports.isBitcoinNetworkProvider = isBitcoinNetworkProvider;
 exports.isBitcoinWalletAccount = isBitcoinWalletAccount;