@dynamic-labs-sdk/bitcoin 0.5.0 → 0.7.0

package/dist/index.esm.js

@@ -1,10 +1,554 @@
-import { a as name, i as getMempoolApiUrl, n as InvalidPsbtError, o as version, r as registerBitcoinNetworkProviderBuilder, t as addBitcoinInjectedWalletsExtension } from "./addBitcoinInjectedWalletsExtension-BjijCDrr.esm.js";
+import { a as name, i as getMempoolApiUrl, n as InvalidPsbtError, o as version, r as registerBitcoinNetworkProviderBuilder, t as addBitcoinInjectedWalletsExtension } from "./addBitcoinInjectedWalletsExtension-B2EklxuR.esm.js";
 import { assertPackageVersion } from "@dynamic-labs-sdk/assert-package-version";
-import { MethodNotImplementedError, WalletProviderPriority, assertDefined, formatWalletProviderGroupKey, formatWalletProviderKey, getActiveNetworkIdFromLastKnownRegistry, getCore, getDefaultClient, getWalletProviderFromWalletAccount, getWalletProviderRegistry, hasExtension, registerExtension, switchActiveNetworkInLastKnownRegistry } from "@dynamic-labs-sdk/client/core";
+import { MethodNotImplementedError, WalletProviderPriority, assertDefined, consumeMfaTokenIfRequiredForAction, formatWalletProviderGroupKey, formatWalletProviderKey, getActiveNetworkIdFromLastKnownRegistry, getBuffer, getCore, getDefaultClient, getSignedSessionId, getWalletProviderFromWalletAccount, getWalletProviderRegistry, hasExtension, registerExtension, switchActiveNetworkInLastKnownRegistry } from "@dynamic-labs-sdk/client/core";
 import { BaseError, getDefaultClient as getDefaultClient$1 } from "@dynamic-labs-sdk/client";
-import { WalletProviderEnum } from "@dynamic-labs/sdk-api-core";
+import { MFAAction, WalletProviderEnum } from "@dynamic-labs/sdk-api-core";
+import { Psbt, address, networks, payments } from "bitcoinjs-lib";
 import { DYNAMIC_WAAS_METADATA, createWaasProvider, getAllUserWaasAddressesForChain } from "@dynamic-labs-sdk/client/waas/core";
+import ecc from "@bitcoinerlab/secp256k1";
+import { ECPairFactory } from "ecpair";
 
+//#region src/errors/TransactionBroadcastFailedError.ts
+var TransactionBroadcastFailedError = class extends 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 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 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 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 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 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 = payments.p2wpkh({
+			network,
+			pubkey: publicKeyPair.publicKey
+		}).output;
+		if (!outputScript) throw new SegwitOutputScriptError();
+		const txidBuffer = new Uint8Array(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: address.toOutputScript(recipientAddress, network),
+		value: BigInt(amountInSatoshis)
+	});
+	if (hasChangeOutput) psbt.addOutput({
+		script: address.toOutputScript(accountAddress, network),
+		value: BigInt(changeAmount)
+	});
+};
+
+//#endregion
+//#region src/errors/FeeRecommendationsFetchError.ts
+var FeeRecommendationsFetchError = class extends 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 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 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(getBuffer().from(publicKeyHex, "hex"));
+	const publicKeyPair = ECPairFactory(ecc).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 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 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 = 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";
@@ -30,23 +574,77 @@ const createWalletProviderForWaasBitcoin = (sdkClient) => {
 	const getConnectedAddresses = async () => {
 		return { addresses: getAllUserWaasAddressesForChain({ chain }, sdkClient) };
 	};
-	const signPsbt$1 = async ({ request: _request, walletAccount }) => {
+	const signPsbt$1 = async ({ request, walletAccount }) => {
 		assertDefined(walletAccount, "Wallet account is required");
-		throw new MethodNotImplementedError("signPsbt");
+		const waasClient = await waasProvider.getWaasClient();
+		const { signature: signedSessionId } = await getSignedSessionId(sdkClient);
+		const mfaToken = await consumeMfaTokenIfRequiredForAction({ mfaAction: 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: _requests, walletAccount: _walletAccount }) => {
-		throw new MethodNotImplementedError("signPsbts");
+	const signPsbts$1 = async ({ requests, walletAccount }) => {
+		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 sendBitcoin$1 = async ({ transaction: _transaction, walletAccount }) => {
+	const signMessage = async ({ message, walletAccount }) => {
 		assertDefined(walletAccount, "Wallet account is required");
-		throw new MethodNotImplementedError("sendBitcoin");
+		const waasClient = await waasProvider.getWaasClient();
+		const { signature: signedSessionId } = await getSignedSessionId(sdkClient);
+		const mfaToken = await consumeMfaTokenIfRequiredForAction({ mfaAction: MFAAction.WalletWaasSign }, sdkClient);
+		return { signature: await waasClient.signMessage({
+			accountAddress: walletAccount.address,
+			authToken: sdkClient.token ?? void 0,
+			bitcoinConfig: { network: "mainnet" },
+			message,
+			mfaToken,
+			signedSessionId
+		}) };
 	};
-	const signMessage = async ({ message: _message, walletAccount, addressType: _addressType, protocol: _protocol }) => {
+	const buildPsbt$1 = async ({ transaction, walletAccount }) => {
 		assertDefined(walletAccount, "Wallet account is required");
-		throw new MethodNotImplementedError("signMessage");
+		const publicKeyHex = getPublicKeyForWalletAccount(walletAccount, sdkClient);
+		return buildPsbt({
+			accountAddress: walletAccount.address,
+			amountInSatoshis: transaction.amount,
+			feePriority: transaction.feePriority ?? "medium",
+			network: networks.bitcoin,
+			publicKeyHex,
+			recipientAddress: transaction.recipientAddress
+		});
+	};
+	const sendBitcoin$1 = async ({ transaction, walletAccount }) => {
+		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 = Psbt.fromBase64(signedPsbt, { network: networks.bitcoin });
+		psbt.finalizeAllInputs();
+		return { transactionId: await broadcastTransaction(psbt.extractTransaction().toHex()) };
 	};
 	return {
 		...waasProvider,
+		buildPsbt: buildPsbt$1,
 		chain,
 		getActiveNetworkId,
 		getConnectedAddresses,
@@ -105,37 +703,6 @@ const addBitcoinExtension = (client = getDefaultClient()) => {
 	addWaasBitcoinExtension(client);
 };
 
-//#endregion
-//#region src/errors/TransactionBroadcastFailedError.ts
-var TransactionBroadcastFailedError = class extends 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 BaseError {
-	constructor() {
-		super({
-			cause: null,
-			code: "transaction_required_error",
-			docsUrl: null,
-			name: "TransactionRequiredError",
-			shortMessage: "No transaction specified for broadcast"
-		});
-	}
-};
-
 //#endregion
 //#region src/isBitcoinNetworkProvider/isBitcoinNetworkProvider.ts
 /**