@laceio/sdk 0.1.1-canary.3 → 0.1.1

package/dist/submit-bitcoin-tx-Y0CtvFN7.cjs

@@ -1,1049 +0,0 @@
-const require_rolldown_runtime = require("./rolldown-runtime-Br2OG8yv.cjs");
-const require__polyfill_buffer_patch = require("./_polyfill-buffer-patch-CM8X7JiY.cjs");
-const require_address = require("./address-BXp-mY8H.cjs");
-const require_src$2 = require("./src-BDzYIksE.cjs");
-const require_bytes_vo = require("./bytes.vo-BNRquqaO.cjs");
-const require_sdk = require("./sdk-Dd0MKXFz.cjs");
-const require_asyncoption = require("./asyncoption-i0VbqVTq.cjs");
-const require_store = require("./store-B1Lq3cEf.cjs");
-const require_activity_type = require("./activity-type-Ch6ljxBy.cjs");
-const require_composite_signer_factory = require("./composite-signer-factory-m5cVs9h_.cjs");
-const require_types = require("./types-DWbVZpnF.cjs");
-const require_contract = require("./contract-DevBp9u8.cjs");
-const require_types$1 = require("./types-CLRUYpfe.cjs");
-const require_const = require("./const-BhYOdznB.cjs");
-const require_keyDerivation = require("./keyDerivation-u0nBA93T.cjs");
-const require_side_effects = require("./side-effects-CngaeXi0.cjs");
-const require_sign_bitcoin_transaction_with_seed = require("./sign-bitcoin-transaction-with-seed-DsLYXnCY.cjs");
-let rxjs = require("rxjs");
-let lodash_isEqual = require("lodash/isEqual.js");
-lodash_isEqual = require_rolldown_runtime.__toESM(lodash_isEqual);
-//#region ../../packages/contract/bitcoin-context/src/contract.ts
-const bitcoinProviderContract = require_store.inferContractContext({
-	name: require_sdk.ContractName("bitcoin-provider"),
-	instance: "exactly-one",
-	contractType: "sideEffectDependency"
-});
-const bitcoinFeeMarketProvider = require_store.inferContractContext({
-	name: require_sdk.ContractName("bitcoin-fee-market-provider"),
-	instance: "exactly-one",
-	contractType: "sideEffectDependency"
-});
-//#endregion
-//#region ../../packages/contract/bitcoin-context/src/fee-rate.ts
-const SATOSHIS_PER_BITCOIN = 1e8;
-const BYTES_PER_KILOBYTE = 1e3;
-/**
-* Upper bound for a caller-supplied fee rate, in sat/vB. Far above any real
-* mempool spike, so it catches a unit mix-up (a BTC/kB figure arriving where
-* sat/vB is expected, or a stray exponent) without refusing an urgent send.
-*/
-const MAX_FEE_RATE_SATS_PER_VBYTE = 1e4;
-/**
-* Converts a fee rate given in sat/vB — the unit dApp APIs and the fee input
-* speak — into the BTC-per-kilobyte rate that
-* `BitcoinBlockchainSpecificTxData.feeRate.customFeeRate` carries.
-*
-* Returns `undefined` for a rate that must not be built against: not a finite
-* number, not positive, or above {@link MAX_FEE_RATE_SATS_PER_VBYTE}. Callers
-* are expected to refuse the request rather than substitute a default — a
-* zero rate yields a transaction no node relays, and an unconverted sat/vB
-* figure overpays by five orders of magnitude.
-*/
-const feeRateFromSatsPerVByte = (satsPerVByte) => Number.isFinite(satsPerVByte) && satsPerVByte > 0 && satsPerVByte <= MAX_FEE_RATE_SATS_PER_VBYTE ? satsPerVByte * BYTES_PER_KILOBYTE / SATOSHIS_PER_BITCOIN : void 0;
-//#endregion
-//#region ../../packages/module/blockchain-bitcoin/src/store/index.ts
-var store_default$2 = require_store.inferStoreContext({
-	load: async () => Promise.resolve().then(() => require("./init-CR7BfztQ.cjs")),
-	context: {
-		actions: require_side_effects.bitcoinContextActions,
-		selectors: require_side_effects.bitcoinContextSelectors
-	}
-});
-//#endregion
-//#region ../../packages/module/blockchain-bitcoin/src/input-selection/GreedyInputSelector.ts
-/**
-* A concrete implementation of InputSelector that uses a simple greedy algorithm.
-*/
-var GreedyInputSelector = class {
-	selectInputs(props) {
-		const { changeAddress, utxos, outputs, feeRate, hasOpReturn } = props;
-		const selected = [];
-		const totalOutput = outputs.reduce((accumulator, output) => accumulator + output.value, 0);
-		let inputSum = 0;
-		let fee = 0;
-		for (const utxo of utxos) {
-			selected.push(utxo);
-			inputSum += utxo.satoshis;
-			fee = this.computeFee({
-				inputCount: selected.length,
-				outputCount: outputs.length,
-				feeRate,
-				hasOpReturn
-			});
-			if (inputSum >= totalOutput + fee) break;
-		}
-		if (inputSum < totalOutput + fee) return null;
-		let change = inputSum - totalOutput - fee;
-		if (change > 0 && change < 546) {
-			const { change: newChange, fee: feeDelta } = this.attemptDustRescue({
-				change,
-				feeRate,
-				selected,
-				remaining: utxos.slice(selected.length),
-				inputSum,
-				totalOutput,
-				outputsCount: outputs.length,
-				hasOpReturn
-			});
-			change = newChange;
-			fee += feeDelta;
-			if (change < 546) {
-				fee += change;
-				change = 0;
-			}
-		}
-		const finalOutputs = outputs.map(({ address, value }) => ({
-			address,
-			value
-		}));
-		if (change >= 546) finalOutputs.push({
-			address: changeAddress,
-			value: change
-		});
-		return {
-			selectedUTxOs: selected,
-			outputs: finalOutputs,
-			fee
-		};
-	}
-	/** Estimate the fee for a given input / output count */
-	computeFee(params) {
-		const { inputCount, outputCount, feeRate, hasOpReturn } = params;
-		const size = inputCount * 68 + (outputCount + (hasOpReturn ? 1 : 0)) * 31 + 10;
-		return Math.ceil(size * feeRate);
-	}
-	/**
-	* Try to pull one more UTxO so that change exceeds the dust threshold if
-	* the value rescued is worth more than the added fee.
-	*/
-	attemptDustRescue({ change, feeRate, selected, remaining, inputSum, totalOutput, outputsCount, hasOpReturn }) {
-		if (change === 0 || change >= 546) return {
-			change,
-			fee: 0
-		};
-		const originalChange = change;
-		let feeDelta = 0;
-		for (const utxo of remaining) {
-			const newInputSum = inputSum + utxo.satoshis;
-			const newFee = this.computeFee({
-				inputCount: selected.length + 1,
-				outputCount: outputsCount + 1,
-				feeRate,
-				hasOpReturn
-			});
-			const newChange = newInputSum - totalOutput - newFee;
-			if (newChange - originalChange >= Math.ceil(68 * feeRate) && newChange >= 546) {
-				selected.push(utxo);
-				feeDelta = newFee - this.computeFee({
-					inputCount: selected.length - 1,
-					outputCount: outputsCount + 1,
-					feeRate,
-					hasOpReturn
-				});
-				return {
-					change: newChange,
-					fee: feeDelta
-				};
-			}
-		}
-		return {
-			change,
-			fee: 0
-		};
-	}
-};
-//#endregion
-//#region ../../packages/module/blockchain-bitcoin/src/tx-builder/errors.ts
-/**
-* The reason a Bitcoin payment cannot be built.
-*/
-let BitcoinTxBuildErrorCode = /* @__PURE__ */ function(BitcoinTxBuildErrorCode) {
-	/** The funding UTxO set is empty (e.g. the only UTxO is spent by a pending tx). */
-	BitcoinTxBuildErrorCode["NoUtxos"] = "NoUtxos";
-	/** UTxOs exist but cannot cover the requested amount plus the network fee. */
-	BitcoinTxBuildErrorCode["InsufficientFunds"] = "InsufficientFunds";
-	/** No transaction outputs were provided. */
-	BitcoinTxBuildErrorCode["NoOutputs"] = "NoOutputs";
-	/** Change address was never set (internal invariant). */
-	BitcoinTxBuildErrorCode["ChangeAddressNotSet"] = "ChangeAddressNotSet";
-	/** The change address failed validation. */
-	BitcoinTxBuildErrorCode["InvalidChangeAddress"] = "InvalidChangeAddress";
-	/** A recipient address failed validation. */
-	BitcoinTxBuildErrorCode["InvalidRecipientAddress"] = "InvalidRecipientAddress";
-	/** A selected UTxO's address could not be matched to a known signing address. */
-	BitcoinTxBuildErrorCode["UnresolvedUtxoAddress"] = "UnresolvedUtxoAddress";
-	/** The OP_RETURN message exceeds the 80-byte limit. */
-	BitcoinTxBuildErrorCode["MessageTooLong"] = "MessageTooLong";
-	/** The resolved fee rate is not a positive number, so the tx would pay no fee. */
-	BitcoinTxBuildErrorCode["InvalidFeeRate"] = "InvalidFeeRate";
-	return BitcoinTxBuildErrorCode;
-}({});
-/**
-* The error a Bitcoin payment build fails with, identified by its `code`.
-*/
-var BitcoinTxBuildError = class extends Error {
-	/** The reason the payment cannot be built. */
-	code;
-	constructor(code, message) {
-		super(message);
-		this.name = "BitcoinTxBuildError";
-		this.code = code;
-	}
-};
-BitcoinTxBuildErrorCode.NoUtxos, BitcoinTxBuildErrorCode.InsufficientFunds, BitcoinTxBuildErrorCode.NoOutputs, BitcoinTxBuildErrorCode.ChangeAddressNotSet, BitcoinTxBuildErrorCode.InvalidChangeAddress, BitcoinTxBuildErrorCode.InvalidRecipientAddress, BitcoinTxBuildErrorCode.UnresolvedUtxoAddress, BitcoinTxBuildErrorCode.MessageTooLong, BitcoinTxBuildErrorCode.InvalidFeeRate;
-//#endregion
-//#region ../../packages/module/blockchain-bitcoin/src/tx-builder/TransactionBuilder.ts
-require__polyfill_buffer_patch.init__polyfill_buffer_patch();
-var import_src$1 = /* @__PURE__ */ require_rolldown_runtime.__toESM(require_address.require_src());
-/**
-* A class to build Bitcoin transactions using a flexible input and output management system.
-*/
-var TransactionBuilder = class {
-	psbt;
-	network;
-	feeRate;
-	knownAddresses;
-	outputs = [];
-	utxos = [];
-	changeAddress;
-	changeDerivation;
-	changeMasterFingerprint;
-	signers = [];
-	inputSelector = new GreedyInputSelector();
-	opReturnData;
-	/**
-	* Initializes the transaction builder.
-	*
-	* @param network - The Bitcoin network (Mainnet or Testnet).
-	* @param feeRate - The fee rate in BTC per kilobyte.
-	* @param knownAddresses - The list of known addresses with their public keys.
-	*/
-	constructor(network, feeRate, knownAddresses) {
-		this.feeRate = feeRate;
-		this.knownAddresses = knownAddresses;
-		this.network = network;
-		this.psbt = new import_src$1.Psbt({ network: network === require_types$1.BitcoinNetwork.Mainnet ? import_src$1.networks.bitcoin : import_src$1.networks.testnet });
-	}
-	/**
-	* Sets the UTXO set that will be used to fund the transaction.
-	*
-	* @param utxos - Array of available UTXOs.
-	* @returns The builder instance for chaining.
-	*/
-	setUtxoSet(utxos) {
-		this.utxos = utxos;
-		return this;
-	}
-	/**
-	* Sets the change address where any remaining funds will be sent.
-	*
-	* @param changeAddress - The change address.
-	* @returns The builder instance for chaining.
-	*/
-	setChangeAddress(changeAddress) {
-		if (require_address.validateBitcoinAddress(changeAddress, this.network) !== require_address.AddressValidationResult.Valid) throw new BitcoinTxBuildError(BitcoinTxBuildErrorCode.InvalidChangeAddress, "Invalid change address");
-		this.changeAddress = changeAddress;
-		return this;
-	}
-	/**
-	* Sets the change address together with its derivation and the account master
-	* fingerprint, so the change output can be stamped with a BIP-32 key-origin an
-	* air-gapped device uses to recognize change. When the master fingerprint is
-	* absent (in-memory accounts) no key-origin is stamped.
-	*
-	* @param changeDerivation - The change address and its derivation path/pubkey.
-	* @param masterFingerprint - Device xfp as 8-char hex, or undefined.
-	* @returns The builder instance for chaining.
-	*/
-	setChange(changeDerivation, masterFingerprint) {
-		this.setChangeAddress(changeDerivation.address);
-		this.changeDerivation = changeDerivation;
-		this.changeMasterFingerprint = masterFingerprint;
-		return this;
-	}
-	/**
-	* Sets the input selection strategy.
-	*
-	* @param inputSelector - An implementation of the InputSelector interface.
-	* @returns The builder instance for chaining.
-	*/
-	setInputSelection(inputSelector) {
-		this.inputSelector = inputSelector;
-		return this;
-	}
-	/**
-	* Adds an output to the transaction.
-	*
-	* @param address - The destination address.
-	* @param value - The amount to send (in satoshis as bigint).
-	* @returns The builder instance for chaining.
-	*/
-	addOutput(address, value) {
-		if (require_address.validateBitcoinAddress(address, this.network) !== require_address.AddressValidationResult.Valid) throw new BitcoinTxBuildError(BitcoinTxBuildErrorCode.InvalidRecipientAddress, "Invalid recipient address");
-		this.outputs.push({
-			address,
-			value
-		});
-		return this;
-	}
-	/**
-	* Adds an OP_RETURN message to the transaction.
-	*
-	* @param message - The message to embed (string, UTF-8). Max 80 bytes after encoding.
-	*                  If null, removes any existing OP_RETURN data.
-	* @returns The builder instance for chaining.
-	*/
-	addOpReturnOutput(message) {
-		if (!message?.trim()) {
-			this.opReturnData = void 0;
-			return this;
-		}
-		const data = require__polyfill_buffer_patch.import_buffer.Buffer.from(message, "utf8");
-		if (data.length > 80) throw new BitcoinTxBuildError(BitcoinTxBuildErrorCode.MessageTooLong, `OP_RETURN message exceeds 80 bytes (actual: ${data.length}).`);
-		this.opReturnData = data;
-		return this;
-	}
-	/**
-	* Builds the transaction by selecting UTXOs (using either the provided input selector or a fallback),
-	* adding inputs and outputs (including a change output if needed), and calculating fees.
-	* If the change amount is below the dust threshold, it is added to the fee instead.
-	*
-	* @returns An UnsignedTransaction containing the PSBT context, fee, estimated virtual bytes, signers, and outputs.
-	* @throws Error if funds are insufficient, no UTXOs are set, or if the change address is not provided.
-	*/
-	build() {
-		if (!this.utxos || this.utxos.length === 0) throw new BitcoinTxBuildError(BitcoinTxBuildErrorCode.NoUtxos, "No UTXOs available to fund the transaction.");
-		if (!this.changeAddress) throw new BitcoinTxBuildError(BitcoinTxBuildErrorCode.ChangeAddressNotSet, "Change address not set.");
-		if (this.outputs.length === 0) throw new BitcoinTxBuildError(BitcoinTxBuildErrorCode.NoOutputs, "No outputs have been added.");
-		const feeRateSatoshis = this.feeRate * 1e8 / 1e3;
-		let selectedUTxOs = [];
-		let fee = 0;
-		let coinselectOutputs = [];
-		const result = this.inputSelector.selectInputs({
-			changeAddress: this.changeAddress,
-			utxos: this.utxos,
-			outputs: this.outputs,
-			feeRate: feeRateSatoshis,
-			hasOpReturn: !!this.opReturnData
-		});
-		if (!result) throw new BitcoinTxBuildError(BitcoinTxBuildErrorCode.InsufficientFunds, "Insufficient funds or coin selection failed.");
-		selectedUTxOs = result.selectedUTxOs;
-		fee = result.fee;
-		coinselectOutputs = result.outputs;
-		for (const utxo of selectedUTxOs) {
-			const knownAddr = this.knownAddresses.find((addr) => addr.address === utxo.address);
-			if (!knownAddr) throw new BitcoinTxBuildError(BitcoinTxBuildErrorCode.UnresolvedUtxoAddress, "Unknown address in UTXO set.");
-			this.signers.push(knownAddr);
-			const net = this.network === require_types$1.BitcoinNetwork.Mainnet ? import_src$1.networks.bitcoin : import_src$1.networks.testnet;
-			this.psbt.addInput({
-				hash: utxo.txId,
-				index: utxo.index,
-				witnessUtxo: {
-					script: import_src$1.payments.p2wpkh({
-						pubkey: require__polyfill_buffer_patch.import_buffer.Buffer.from(knownAddr.publicKeyHex, "hex"),
-						network: net
-					}).output,
-					value: utxo.satoshis
-				}
-			});
-		}
-		coinselectOutputs.forEach(({ address, value }) => {
-			if (require_address.isP2trAddress(address)) {
-				const taprootPubKey = require__polyfill_buffer_patch.import_buffer.Buffer.from(import_src$1.address.fromBech32(address).data);
-				this.psbt.addOutput({
-					script: import_src$1.script.compile([import_src$1.opcodes.OP_1, taprootPubKey]),
-					value
-				});
-			} else this.psbt.addOutput({
-				address,
-				value
-			});
-		});
-		if (this.opReturnData) {
-			const embed = import_src$1.payments.embed({ data: [this.opReturnData] });
-			this.psbt.addOutput({
-				script: embed.output,
-				value: 0
-			});
-		}
-		this.stampChangeOutput(coinselectOutputs);
-		const opReturnOutput = this.opReturnData ? 1 : 0;
-		const vBytes = selectedUTxOs.length * 68 + (coinselectOutputs.length + opReturnOutput) * 31 + 10;
-		return {
-			context: this.psbt,
-			toAddress: this.outputs[0].address,
-			fee,
-			amount: this.outputs[0].value,
-			vBytes,
-			signers: this.signers
-		};
-	}
-	/**
-	* Stamps the change output with a BIP-32 key-origin (master fingerprint +
-	* change pubkey + full derivation path) so an air-gapped device recognizes it
-	* as the wallet's own change instead of a third-party spend. No-ops unless a
-	* change output is present, its derivation was provided via setChange, and a
-	* master fingerprint is known (in-memory accounts skip stamping, leaving the
-	* PSBT byte-identical for that path).
-	*
-	* @param finalOutputs - The outputs selected by coin selection, in PSBT order.
-	*/
-	stampChangeOutput(finalOutputs) {
-		const { changeDerivation, changeMasterFingerprint } = this;
-		if (!changeDerivation || !changeMasterFingerprint) return;
-		const changeOutputIndex = finalOutputs.findLastIndex((output) => output.address === changeDerivation.address);
-		if (changeOutputIndex === -1) return;
-		this.psbt.updateOutput(changeOutputIndex, { bip32Derivation: [{
-			masterFingerprint: require__polyfill_buffer_patch.import_buffer.Buffer.from(changeMasterFingerprint, "hex"),
-			pubkey: require__polyfill_buffer_patch.import_buffer.Buffer.from(changeDerivation.publicKeyHex, "hex"),
-			path: require_keyDerivation.bitcoinFullDerivationPath({
-				addressType: changeDerivation.addressType,
-				network: this.network,
-				account: changeDerivation.account,
-				chain: changeDerivation.chain,
-				index: changeDerivation.index
-			})
-		}] });
-	}
-};
-//#endregion
-//#region ../../packages/module/blockchain-bitcoin/src/tx-builder/build-bitcoin-payment.ts
-require__polyfill_buffer_patch.init__polyfill_buffer_patch();
-const getBitcoinInFlight = (activity) => {
-	if (activity.type !== require_activity_type.ActivityType.Pending) return void 0;
-	return activity.blockchainSpecific?.Bitcoin;
-};
-const outpointKey = (ref) => `${ref.txId}#${ref.index}`;
-/**
-* Drops the outpoints consumed by pending transactions from the spendable set.
-* Unconfirmed outputs produced by those transactions are not added: spending
-* unconfirmed Bitcoin outputs is unsafe under RBF and bounded by mempool
-* ancestor limits.
-*
-* @param utxos - The confirmed UTxOs of the account.
-* @param _accountAddresses - The addresses of the account.
-* @param pendingActivities - The pending activities of the account.
-*/
-const applyInFlightUtxoAdjustments = (utxos, _accountAddresses, pendingActivities) => {
-	const spent = /* @__PURE__ */ new Set();
-	for (const activity of pendingActivities) {
-		const inFlight = getBitcoinInFlight(activity);
-		if (!inFlight) continue;
-		for (const input of inFlight.consumedInputs) spent.add(outpointKey(input));
-	}
-	if (spent.size === 0) return [...utxos];
-	return utxos.filter((utxo) => !spent.has(outpointKey(utxo)));
-};
-/**
-* Resolves the rate to build against, in BTC per kilobyte.
-*
-* The market is read ONLY for the three quoted tiers. `Custom` is a rate the
-* user typed and must stay buildable while mempool.space is unreachable, so
-* the fetch must not be hoisted above that branch, or an unreachable market
-* fails every Bitcoin build. A tier build still fails when the market cannot
-* be read.
-*
-* @param feeRate - The chosen option, plus the typed rate when it is `Custom`.
-* @param getCurrentFeeMarket - Fetches the market; called only for a tier.
-*/
-const resolveFeeRate = async (feeRate, getCurrentFeeMarket) => {
-	if (feeRate.feeOption === "Custom") return feeRate.customFeeRate ?? 0;
-	const market = (await (0, rxjs.firstValueFrom)(getCurrentFeeMarket())).unwrap();
-	switch (feeRate.feeOption) {
-		case "Fast": return market.fast.feeRate;
-		case "Average": return market.standard.feeRate;
-		case "Low": return market.slow.feeRate;
-	}
-};
-/**
-* Embeds each input's full previous transaction (nonWitnessUtxo) into the
-* PSBT so it is self-contained for hardware signers: Ledger requires the
-* previous transaction for segwit-v0 inputs and Trezor consumes it as refTxs.
-* Duplicate previous transactions are fetched only once and all fetches run
-* concurrently. Each fetched transaction is verified to hash to the requested
-* txid so a wrong provider response fails the build locally instead of as an
-* opaque device-side rejection. Throws if any fetch fails, failing the build
-* instead of producing a PSBT a device would reject.
-*
-* @param psbt - The freshly built PSBT whose inputs carry only witnessUtxo.
-* @param getRawTransaction - Fetches the raw transaction hex for a tx id.
-*/
-const embedPreviousTransactions = async (psbt, getRawTransaction) => {
-	const inputTxIds = psbt.txInputs.map((input) => require__polyfill_buffer_patch.import_buffer.Buffer.from(input.hash).reverse().toString("hex"));
-	const uniqueTxIds = [...new Set(inputTxIds)];
-	if (uniqueTxIds.length === 0) return;
-	const rawTxResults = await (0, rxjs.firstValueFrom)((0, rxjs.forkJoin)(uniqueTxIds.map((txId) => getRawTransaction(txId))));
-	const rawTxByTxId = /* @__PURE__ */ new Map();
-	uniqueTxIds.forEach((txId, index) => {
-		const rawTx = require__polyfill_buffer_patch.import_buffer.Buffer.from(rawTxResults[index].unwrap(), "hex");
-		if (import_src$1.Transaction.fromBuffer(rawTx).getId() !== txId) throw new Error(`Fetched previous transaction does not match requested txid ${txId}`);
-		rawTxByTxId.set(txId, rawTx);
-	});
-	inputTxIds.forEach((txId, index) => {
-		psbt.updateInput(index, { nonWitnessUtxo: rawTxByTxId.get(txId) });
-	});
-};
-/**
-* Builds an unsigned Bitcoin payment from the account wallet's current UTxOs
-* and addresses. Outpoints consumed by pending activities are not spent
-* again, change goes to the wallet address, and hardware accounts (those with
-* a master fingerprint) get each input's previous transaction embedded.
-*
-* @param params - The wallet, pending activities, recipients, fee option and memo.
-* @returns The serialized unsigned transaction and the fee it pays.
-* @throws {@link BitcoinTxBuildError} when the payment cannot be built, for example
-* when the fee rate is not positive or the funds do not cover it.
-*/
-const buildBitcoinPayment = async ({ wallet, pendingActivities, outputs, feeRate, memo, logger }) => {
-	const network = wallet.network;
-	const utxos = await (0, rxjs.firstValueFrom)(wallet.utxos$);
-	const addresses = await (0, rxjs.firstValueFrom)(wallet.addresses$);
-	const rateToUse = await resolveFeeRate(feeRate, () => wallet.getCurrentFeeMarket());
-	if (!Number.isFinite(rateToUse) || rateToUse <= 0) throw new BitcoinTxBuildError(BitcoinTxBuildErrorCode.InvalidFeeRate, `Invalid fee rate: ${rateToUse}`);
-	logger?.debug(`Bitcoin buildTx: Using fee rate of ${rateToUse} BTC/kB`);
-	const txBuilder = new TransactionBuilder(network, rateToUse, addresses);
-	const adjustedUtxos = applyInFlightUtxoAdjustments(utxos, new Set(addresses.map((a) => a.address)), pendingActivities);
-	txBuilder.setChange(wallet.address, wallet.masterFingerprint).setUtxoSet(adjustedUtxos);
-	for (const output of outputs) {
-		txBuilder.addOutput(output.address, output.amount);
-		logger?.debug(`Bitcoin buildTx: Adding output to address: ${output.address} with amount from txParams: ${output.amount}`);
-	}
-	if (memo) {
-		logger?.debug(`Bitcoin buildTx: Adding OP_RETURN memo: ${memo}`);
-		txBuilder.addOpReturnOutput(memo);
-	}
-	const tx = txBuilder.build();
-	tx.network = network;
-	if (wallet.masterFingerprint) await embedPreviousTransactions(tx.context, (txId) => wallet.getRawTransaction(txId));
-	return {
-		serializedTx: require_sign_bitcoin_transaction_with_seed.encodeUnsignedTxToString(tx),
-		fee: BigInt(tx.fee)
-	};
-};
-//#endregion
-//#region ../../packages/module/blockchain-bitcoin/src/sdk.ts
-const implementsContracts = require_store.combineContracts([
-	require_sdk.inMemoryIntegrationAddonContract,
-	require_sdk.tokensStoreContract,
-	require_sdk.addressesStoreContract,
-	require_sdk.syncStoreContract,
-	require_contract.addressBookAddressValidatorAddonContract,
-	require_contract.tokenIdMapperAddonContract,
-	require_sdk.signerFactoryAddonContract
-]);
-const dependsOnContracts = require_store.combineContracts([
-	bitcoinProviderContract,
-	bitcoinFeeMarketProvider,
-	require_sdk.networkStoreContract,
-	require_sdk.walletRepoStoreContract,
-	require_sdk.walletActiveStateDependencyContract,
-	require_sdk.activitiesStoreContract,
-	require_sdk.tokensStoreContract
-]);
-/**
-* Bitcoin accounts: their addresses, tokens and sync, in-memory wallet
-* creation and signing, without any user interface or send flow. Loads when
-* `BITCOIN_FEATURE_FLAG` is enabled, and needs a Bitcoin provider module such
-* as `m.bitcoinProviderMaestro` and a fee market module such as
-* `m.bitcoinMempoolFeeMarket`.
-*/
-var sdk_default$2 = require_store.inferModuleContext({
-	moduleName: require_sdk.ModuleName("blockchain-bitcoin"),
-	implements: implementsContracts,
-	dependsOn: dependsOnContracts,
-	feature: {
-		willLoad: (featureFlags) => featureFlags.some((flag) => flag.key === require_const.BITCOIN_FEATURE_FLAG),
-		metadata: {
-			name: "Bitcoin",
-			description: "Bitcoin blockchain support"
-		}
-	},
-	store: store_default$2,
-	addons: {
-		loadInMemoryWalletIntegration: async () => Promise.resolve().then(() => require("./in-memory-wallet-integration-B2xzxORj.cjs")),
-		loadAddressBookAddressValidators: async () => Promise.resolve().then(() => require("./address-book-address-validator-DK0dnsRS.cjs")),
-		loadTokenIdMapper: async () => Promise.resolve().then(() => require("./token-id-mapper-Bnds3xKH.cjs")),
-		loadSignerFactory: async () => Promise.resolve().then(() => require("./signer-factory-Cwd6o-lG.cjs"))
-	}
-});
-//#endregion
-//#region ../../packages/module/bitcoin-mempool-fee-market/src/store/index.ts
-var store_default$1 = require_store.inferStoreContext({
-	load: async () => Promise.resolve().then(() => require("./init-DHrCbpkW.cjs")),
-	context: {
-		actions: {},
-		selectors: {}
-	}
-});
-//#endregion
-//#region ../../packages/module/bitcoin-mempool-fee-market/src/sdk.ts
-/**
-* Bitcoin fee rate estimates from mempool.space. Loads when
-* `BITCOIN_MEMPOOL_FEE_MARKET_FEATURE_FLAG` is enabled.
-*/
-var sdk_default$1 = require_store.inferModuleContext({
-	moduleName: require_sdk.ModuleName("bitcoin-mempool-fee-market"),
-	dependsOn: require_store.combineContracts([]),
-	implements: require_store.combineContracts([bitcoinFeeMarketProvider]),
-	store: store_default$1,
-	feature: {
-		willLoad: (featureFlags) => featureFlags.some((flag) => flag.key === require_const.BITCOIN_MEMPOOL_FEE_MARKET_FEATURE_FLAG),
-		metadata: {
-			name: "Mempool.space fee market provider",
-			description: "Mempool.space fee market provider for Bitcoin"
-		}
-	},
-	addons: {}
-});
-//#endregion
-//#region ../../packages/module/bitcoin-provider-maestro/src/store/index.ts
-var store_default = require_store.inferStoreContext({
-	load: async () => Promise.resolve().then(() => require("./init-GsT2AEa4.cjs")),
-	context: {
-		actions: {},
-		selectors: {}
-	}
-});
-//#endregion
-//#region ../../packages/module/bitcoin-provider-maestro/src/sdk.ts
-/**
-* Bitcoin chain data through Maestro: UTxOs, transactions and fee estimates.
-* Loads when `BITCOIN_FEATURE_FLAG` is enabled.
-*/
-var sdk_default = require_store.inferModuleContext({
-	moduleName: require_sdk.ModuleName("bitcoin-provider-maestro"),
-	dependsOn: require_store.combineContracts([]),
-	implements: require_store.combineContracts([bitcoinProviderContract]),
-	store: store_default,
-	feature: {
-		willLoad: (featureFlags) => featureFlags.some((flag) => flag.key === require_const.BITCOIN_FEATURE_FLAG),
-		metadata: {
-			name: "Maestro",
-			description: "Maestro provider for Bitcoin"
-		}
-	},
-	addons: {}
-});
-//#endregion
-//#region src/bitcoin/modules.ts
-var modules_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
-	bitcoinMempoolFeeMarket: () => sdk_default$1,
-	bitcoinProviderMaestro: () => sdk_default,
-	blockchainBitcoin: () => sdk_default$2,
-	featureDev: () => require_sdk.sdk_default$2,
-	storageInMemory: () => require_sdk.sdk_default$1,
-	storageWebIndexeddb: () => require_sdk.sdk_default
-});
-//#endregion
-//#region src/bitcoin/bitcoin-lazy-in-memory-signer-factory.ts
-var import_src = /* @__PURE__ */ require_rolldown_runtime.__toESM(require_src$2.require_src(), 1);
-/**
-* Signer factory for {@link WalletType.LazyInMemory} Bitcoin accounts.
-*
-* The seed is never persisted by Lace: each signature asks for the recovery
-* words, derives the seed, and wipes it once signing settles. The words must
-* derive the account's stored extended public keys, regardless of their
-* source, or nothing is signed.
-*
-* Like the Cardano lazy signer, each signature first asks the user to confirm
-* through `auth.authenticate()`. The auth secret is never read, because there
-* is no encrypted seed to open.
-*/
-var BitcoinLazyInMemorySignerFactory = class {
-	#withMnemonicWords;
-	constructor(props) {
-		this.#withMnemonicWords = props.withMnemonicWords;
-	}
-	canSign(account) {
-		return account.accountType === "LazyInMemory" && account.blockchainName === "Bitcoin";
-	}
-	createTransactionSigner(context) {
-		const accountProps = this.#extractAccountProps(context);
-		const { auth } = context;
-		return { sign: (request) => this.#sign(request, accountProps, auth) };
-	}
-	/**
-	* Message signing is not offered for lazy Bitcoin accounts.
-	*
-	* @throws Always.
-	*/
-	createDataSigner(_context) {
-		throw new Error("Data signing is not supported for lazy Bitcoin accounts.");
-	}
-	#sign(request, accountProps, auth) {
-		return auth.authenticate().pipe((0, rxjs.switchMap)((confirmed) => {
-			if (!confirmed) return (0, rxjs.throwError)(() => new require_types.AuthenticationCancelledError());
-			return this.#signWithWords(request, accountProps);
-		}));
-	}
-	#signWithWords(request, accountProps) {
-		return new rxjs.Observable((subscriber) => {
-			const assertActive = () => {
-				if (subscriber.closed) throw new Error("Signing request cancelled.");
-			};
-			this.#withMnemonicWords(async (words) => {
-				assertActive();
-				const seed = await import_src.mnemonicToSeed(words.join(" "));
-				try {
-					assertActive();
-					const derivedKeys = require_keyDerivation.getExtendedPubKeys(seed, accountProps.accountIndex);
-					if (!(0, lodash_isEqual.default)(accountProps.network === require_types$1.BitcoinNetwork.Mainnet ? derivedKeys.mainnet : derivedKeys.testnet4, accountProps.extendedAccountPublicKeys)) throw new require_contract.LazyWalletMismatchError();
-					return require_sign_bitcoin_transaction_with_seed.signBitcoinTransactionWithSeed(request.serializedTx, seed);
-				} finally {
-					seed.fill(0);
-				}
-			}).then((result) => {
-				if (!subscriber.closed) {
-					subscriber.next(result);
-					subscriber.complete();
-				}
-			}, (error) => {
-				if (!subscriber.closed) subscriber.error(error);
-			});
-		});
-	}
-	#extractAccountProps(context) {
-		const account = context.wallet.accounts.find((a) => a.accountId === context.accountId);
-		if (!account || !this.canSign(account)) throw new Error(`BitcoinLazyInMemorySignerFactory does not support account type: ${account?.accountType ?? "unknown"}`);
-		const { accountIndex, extendedAccountPublicKeys, networkId } = account.blockchainSpecific;
-		const network = require_address.BitcoinNetworkId.getBitcoinNetwork(networkId ?? account.blockchainNetworkId);
-		if (!network) throw new Error(`Cannot resolve Bitcoin network from networkId: ${String(networkId ?? account.blockchainNetworkId)}`);
-		return {
-			accountIndex,
-			network,
-			extendedAccountPublicKeys
-		};
-	}
-};
-//#endregion
-//#region src/bitcoin/create-bitcoin-lazy-in-memory-vault-module.ts
-/**
-* Builds a vault module that signs for {@link WalletType.LazyInMemory}
-* Bitcoin accounts by asking `withMnemonicWords` for the recovery words at
-* each signature. The words must derive the account's stored extended public
-* keys, or signing fails with `LazyWalletMismatchError`. The seed derived
-* from the words is wiped once each signature settles. Only transactions are
-* signed: lazy Bitcoin accounts do not sign messages.
-*
-* Pass the returned module to `createLaceWallet({ modules: [...] })`. Only the
-* `signer-factory-addon` contract is implemented, because the SDK has no
-* encrypted vault to expose to features such as account management or
-* password verification.
-*
-* @param props - The source of the recovery words.
-* @returns A module for the `modules` array of `createLaceWallet`.
-*/
-const createBitcoinLazyInMemoryVaultModule = (props) => {
-	const signerFactory = new BitcoinLazyInMemorySignerFactory(props);
-	const implementsContracts = require_store.combineContracts([require_sdk.signerFactoryAddonContract]);
-	return require_store.inferModuleContext({
-		moduleName: require_sdk.ModuleName("bitcoin-lazy-in-memory-vault"),
-		implements: implementsContracts,
-		addons: { loadSignerFactory: async () => ({ default: () => signerFactory }) }
-	});
-};
-//#endregion
-//#region src/bitcoin/resolve-bitcoin-account.ts
-/**
-* Picks the Bitcoin account a transaction is for, among the accounts of
-* `wallets` on the active networks: the requested one, or the only one when
-* none is requested.
-*
-* @param wallets - The wallet entities whose accounts may be picked.
-* @param activeNetworkIds - The networks the wallet is on.
-* @param requestedAccountId - The account asked for, if any.
-* @returns `Ok` with the account and its wallet entity, or `Err` when the
-*   requested account is not found, or no account or several accounts match.
-*/
-const resolveBitcoinAccount = (wallets, activeNetworkIds, requestedAccountId) => {
-	const bitcoinAccounts = wallets.flatMap((walletEntity) => walletEntity.accounts.filter((account) => account.blockchainName === "Bitcoin" && activeNetworkIds.includes(account.blockchainNetworkId)).map((account) => ({
-		account,
-		walletEntity
-	})));
-	if (requestedAccountId) {
-		const found = bitcoinAccounts.find(({ account }) => account.accountId === requestedAccountId);
-		return found ? require_asyncoption.Ok(found) : require_asyncoption.Err(/* @__PURE__ */ new Error(`Bitcoin account "${requestedAccountId}" not found on the active network`));
-	}
-	if (bitcoinAccounts.length === 0) return require_asyncoption.Err(/* @__PURE__ */ new Error("No Bitcoin accounts found on the active network"));
-	if (bitcoinAccounts.length > 1) return require_asyncoption.Err(/* @__PURE__ */ new Error(`Multiple Bitcoin accounts found (${bitcoinAccounts.length}): specify accountId to disambiguate`));
-	return require_asyncoption.Ok(bitcoinAccounts[0]);
-};
-/**
-* Picks the Bitcoin account a transaction is for from the wallet's current
-* state, by the rules of {@link resolveBitcoinAccount}.
-*
-* @param stateObservables - The wallet's wallets and networks.
-* @param requestedAccountId - The account asked for, if any.
-* @returns `Ok` with the account id, or `Err` when no single account matches.
-*/
-const resolveBitcoinAccountId = async (stateObservables, requestedAccountId) => {
-	const resolved = resolveBitcoinAccount(await (0, rxjs.firstValueFrom)(stateObservables.wallets.selectAll$), await (0, rxjs.firstValueFrom)(stateObservables.network.selectAllActiveNetworkIds$), requestedAccountId);
-	return resolved.isErr() ? require_asyncoption.Err(resolved.error) : require_asyncoption.Ok(resolved.value.account.accountId);
-};
-/**
-* Finds the Bitcoin wallet that syncs an account. Every wallet in a
-* JavaScript realm registers its accounts in one shared registry, so an
-* account must be loaded by at most one wallet per realm.
-*
-* @param accountId - The account to find.
-* @returns `Ok` with the account's Bitcoin wallet, or `Err` when the account
-*   has not started syncing yet.
-*/
-const findBitcoinAccountWallet = (accountId) => {
-	const accountWallet = require_side_effects.bitcoinAccountWallets$.value[accountId];
-	return accountWallet ? require_asyncoption.Ok(accountWallet) : require_asyncoption.Err(/* @__PURE__ */ new Error(`Bitcoin account "${accountId}" has not started syncing yet`));
-};
-//#endregion
-//#region src/bitcoin/build-bitcoin-tx.ts
-const isPositiveSatoshiAmount = (amount) => Number.isSafeInteger(amount) && amount > 0;
-const validateRecipients = (recipients) => {
-	if (recipients.length === 0) return require_asyncoption.Err(/* @__PURE__ */ new Error("At least one recipient is required"));
-	const invalid = recipients.find(({ amount }) => !isPositiveSatoshiAmount(amount));
-	if (invalid) return require_asyncoption.Err(/* @__PURE__ */ new Error(`Invalid amount ${invalid.amount} for ${invalid.address}: amounts are positive whole numbers of satoshis`));
-	const dust = recipients.find(({ amount }) => amount < 546);
-	return dust ? require_asyncoption.Err(/* @__PURE__ */ new Error(`Amount ${dust.amount} for ${dust.address} is below the dust limit of 546 satoshis`)) : require_asyncoption.Ok(void 0);
-};
-const toPaymentFeeRate = (feeRate) => {
-	if (feeRate.feeOption !== "Custom") return require_asyncoption.Ok(feeRate);
-	const customFeeRate = feeRateFromSatsPerVByte(feeRate.satsPerVByte);
-	return customFeeRate === void 0 ? require_asyncoption.Err(/* @__PURE__ */ new Error(`Invalid fee rate ${feeRate.satsPerVByte}: custom rates are positive numbers of satoshis per virtual byte, at most 10,000`)) : require_asyncoption.Ok({
-		feeOption: "Custom",
-		customFeeRate
-	});
-};
-/**
-* Builds an unsigned Bitcoin payment from the account's synced UTxOs. Outputs
-* spent by the account's pending transactions are not spent again, and the
-* change goes back to the account. The account is `props.accountId`, or the
-* only Bitcoin account on the active network.
-*
-* The account must have synced first: await
-* {@link waitForBitcoinAccountSync} after adding the wallet. A Bitcoin
-* account must be loaded by at most one wallet per JavaScript realm, since
-* the account's synced state is shared across the realm by account id.
-*
-* @param wallet - A wallet holding the paying account (see
-*   {@link WalletWithBitcoinTxBuilding}).
-* @param props - The recipients, with amounts in satoshis, the fee rate, and
-*   the account and memo when needed.
-* @returns `Ok` with the unsigned transaction and its fee, or `Err` when an
-*   amount is not a positive whole number of satoshis or is below the dust
-*   limit of 546 satoshis, a custom fee rate is out of range, no account
-*   matches, the account has not started syncing, or the payment cannot be
-*   built, for example when the funds do not cover it. It never rejects.
-*/
-const buildBitcoinTx = async (wallet, props) => {
-	const { accountId: requestedAccountId, recipients, feeRate, memo } = props;
-	try {
-		const validRecipients = validateRecipients(recipients);
-		if (validRecipients.isErr()) return require_asyncoption.Err(validRecipients.error);
-		const paymentFeeRate = toPaymentFeeRate(feeRate);
-		if (paymentFeeRate.isErr()) return require_asyncoption.Err(paymentFeeRate.error);
-		const accountId = await resolveBitcoinAccountId(wallet.stateObservables, requestedAccountId);
-		if (accountId.isErr()) return require_asyncoption.Err(accountId.error);
-		const accountWallet = findBitcoinAccountWallet(accountId.value);
-		if (accountWallet.isErr()) return require_asyncoption.Err(accountWallet.error);
-		const pendingActivities = await (0, rxjs.firstValueFrom)(wallet.stateObservables.activities.selectPendingActivitiesByAccount$);
-		const { serializedTx, fee } = await buildBitcoinPayment({
-			wallet: accountWallet.value,
-			pendingActivities: pendingActivities[accountId.value] ?? [],
-			outputs: recipients,
-			feeRate: paymentFeeRate.value,
-			memo
-		});
-		return require_asyncoption.Ok({
-			serializedTx,
-			fee
-		});
-	} catch (error) {
-		return require_asyncoption.Err(error instanceof Error ? error : new Error(String(error)));
-	}
-};
-/**
-* Returns a promise that resolves once a Bitcoin account is on the active
-* network and has synced its UTxOs with the provider. Await it after adding
-* a wallet, before {@link buildBitcoinTx}, so the build sees the account's
-* funds. A Bitcoin account must be loaded by at most one wallet per
-* JavaScript realm: with two, the promise may resolve on the other wallet's
-* sync.
-*
-* @param wallet - A wallet holding the account (see
-*   {@link WalletWithBitcoinTxBuilding}).
-* @param options - Optional configuration.
-* @returns A promise that resolves once the account has synced.
-* @throws A `TimeoutError` when the account has not synced within
-*   `options.timeout`.
-*/
-const waitForBitcoinAccountSync = async (wallet, options) => {
-	const { wallets, network } = wallet.stateObservables;
-	await (0, rxjs.firstValueFrom)((0, rxjs.combineLatest)([wallets.selectAll$, network.selectAllActiveNetworkIds$]).pipe((0, rxjs.map)(([allWallets, activeNetworkIds]) => resolveBitcoinAccount(allWallets, activeNetworkIds, options?.accountId)), (0, rxjs.filter)((resolved) => resolved.isOk()), (0, rxjs.map)((resolved) => resolved.unwrap().account.accountId), (0, rxjs.take)(1), (0, rxjs.switchMap)((accountId) => require_side_effects.bitcoinAccountWallets$.pipe((0, rxjs.map)((accountWallets) => accountWallets[accountId]))), (0, rxjs.filter)((accountWallet) => !!accountWallet), (0, rxjs.switchMap)((accountWallet) => accountWallet.syncStatus$), (0, rxjs.filter)(({ status }) => status === require_side_effects.SyncStatus.Synced), options?.timeout != null ? (0, rxjs.timeout)({ first: options.timeout }) : passthrough()));
-};
-const passthrough = () => (source$) => source$;
-//#endregion
-//#region src/bitcoin/sign-bitcoin-tx.ts
-const isSignableBitcoinWallet = (wallet) => wallet.type === require_sdk.WalletType.InMemory || wallet.type === require_sdk.WalletType.LazyInMemory;
-/**
-* Signs a Bitcoin transaction with the wallet's keys, through the signer of
-* its wallet kind, with no confirmation prompt of the SDK's own: confirm with
-* the user before calling it. The account is `props.accountId`, or the only
-* signable Bitcoin account on the active network. A `LazyInMemory` account
-* signs through the vault module of `createBitcoinLazyInMemoryVaultModule`.
-*
-* @param wallet - A wallet holding the signing account (see
-*   {@link WalletWithBitcoinSigning}).
-* @param props - The unsigned transaction from `buildBitcoinTx`, and the
-*   password and account when needed.
-* @returns `Ok` with the signed transaction, ready for `submitBitcoinTx`, or
-*   `Err` when no account matches, the password is missing or signing fails.
-*   It never rejects.
-*/
-const signBitcoinTx = async (wallet, props) => {
-	const { serializedTx, password, accountId: requestedAccountId } = props;
-	try {
-		const { stateObservables: obs } = wallet;
-		const allWallets = await (0, rxjs.firstValueFrom)(obs.wallets.selectAll$);
-		const activeNetworkIds = await (0, rxjs.firstValueFrom)(obs.network.selectAllActiveNetworkIds$);
-		const resolved = resolveBitcoinAccount(allWallets.filter(isSignableBitcoinWallet), activeNetworkIds, requestedAccountId);
-		if (resolved.isErr()) return require_asyncoption.Err(resolved.error);
-		const { account, walletEntity } = resolved.value;
-		if (walletEntity.type === require_sdk.WalletType.InMemory && !password) return require_asyncoption.Err(/* @__PURE__ */ new Error("password is required for InMemory wallets: supply props.password or use a LazyInMemory wallet"));
-		const auth = {
-			authenticate: () => (0, rxjs.of)(true),
-			accessAuthSecret: (callback) => password ? callback(require_sdk.AuthSecret(require_bytes_vo.ByteArray(password))) : (0, rxjs.throwError)(() => /* @__PURE__ */ new Error("accessAuthSecret called on a wallet that has no password: this is a LazyInMemory wallet; signer factories must not access the auth secret"))
-		};
-		const signerFactory = new require_composite_signer_factory.CompositeSignerFactory(await wallet._loadModules("addons.loadSignerFactory"));
-		const context = {
-			wallet: walletEntity,
-			accountId: account.accountId,
-			auth
-		};
-		return require_asyncoption.Ok(await (0, rxjs.firstValueFrom)(signerFactory.createTransactionSigner(context).sign({ serializedTx: require_bytes_vo.HexBytes(serializedTx) })));
-	} catch (error) {
-		return require_asyncoption.Err(error instanceof Error ? error : new Error(String(error)));
-	}
-};
-//#endregion
-//#region src/bitcoin/submit-bitcoin-tx.ts
-const SUBMIT_TX_TIMEOUT_MS = 6e4;
-const isBitcoinNetwork = (network) => Object.values(require_types$1.BitcoinNetwork).includes(network);
-const decodeSignedTx = (serializedTx) => {
-	const payload = JSON.parse(require_bytes_vo.HexBytes.toUTF8(require_bytes_vo.HexBytes(serializedTx)));
-	if (typeof payload?.hex !== "string" || !isBitcoinNetwork(payload.network)) throw new Error("Not a signed Bitcoin transaction");
-	return {
-		network: payload.network,
-		hex: payload.hex
-	};
-};
-/**
-* Submits a signed transaction through the account's Bitcoin wallet, which
-* adds it to the account's pending transactions once the provider accepts it,
-* and waits up to 60 seconds for the provider's answer. The account is
-* `props.accountId`, or the only Bitcoin account on the active network. A
-* Bitcoin account must be loaded by at most one wallet per JavaScript realm,
-* since the account's pending transactions are shared across the realm by
-* account id.
-*
-* @param wallet - A wallet with the Bitcoin modules loaded (see
-*   {@link WalletWithBitcoinSubmit}).
-* @param props - The signed transaction, and the account when needed.
-* @returns `Ok` with the transaction ID once the provider accepts it, or
-*   `Err` when no account matches, the account has not started syncing, the
-*   transaction is for another network, the provider refuses it or the wait
-*   times out. It never rejects.
-*/
-const submitBitcoinTx = async (wallet, props) => {
-	const { serializedTx, accountId: requestedAccountId } = props;
-	try {
-		const { network, hex } = decodeSignedTx(serializedTx);
-		const resolved = await resolveBitcoinAccountId(wallet.stateObservables, requestedAccountId);
-		if (resolved.isErr()) return require_asyncoption.Err(resolved.error);
-		const accountId = resolved.value;
-		const foundWallet = findBitcoinAccountWallet(accountId);
-		if (foundWallet.isErr()) return require_asyncoption.Err(foundWallet.error);
-		const accountWallet = foundWallet.value;
-		if (accountWallet.network !== network) return require_asyncoption.Err(/* @__PURE__ */ new Error(`The transaction is for the Bitcoin ${network} network, but account "${accountId}" is on ${accountWallet.network}`));
-		const result = await (0, rxjs.firstValueFrom)(accountWallet.submitTransaction(hex).pipe((0, rxjs.timeout)(SUBMIT_TX_TIMEOUT_MS)));
-		if (result.isErr()) return require_asyncoption.Err(new Error(`Transaction submission failed: ${result.error.reason}`, { cause: result.error }));
-		return require_asyncoption.Ok({ txId: result.value });
-	} catch (error) {
-		return require_asyncoption.Err(error instanceof Error ? error : new Error(String(error)));
-	}
-};
-//#endregion
-Object.defineProperty(exports, "BitcoinTxBuildError", {
-	enumerable: true,
-	get: function() {
-		return BitcoinTxBuildError;
-	}
-});
-Object.defineProperty(exports, "BitcoinTxBuildErrorCode", {
-	enumerable: true,
-	get: function() {
-		return BitcoinTxBuildErrorCode;
-	}
-});
-Object.defineProperty(exports, "buildBitcoinTx", {
-	enumerable: true,
-	get: function() {
-		return buildBitcoinTx;
-	}
-});
-Object.defineProperty(exports, "createBitcoinLazyInMemoryVaultModule", {
-	enumerable: true,
-	get: function() {
-		return createBitcoinLazyInMemoryVaultModule;
-	}
-});
-Object.defineProperty(exports, "modules_exports", {
-	enumerable: true,
-	get: function() {
-		return modules_exports;
-	}
-});
-Object.defineProperty(exports, "sdk_default", {
-	enumerable: true,
-	get: function() {
-		return sdk_default;
-	}
-});
-Object.defineProperty(exports, "sdk_default$1", {
-	enumerable: true,
-	get: function() {
-		return sdk_default$1;
-	}
-});
-Object.defineProperty(exports, "sdk_default$2", {
-	enumerable: true,
-	get: function() {
-		return sdk_default$2;
-	}
-});
-Object.defineProperty(exports, "signBitcoinTx", {
-	enumerable: true,
-	get: function() {
-		return signBitcoinTx;
-	}
-});
-Object.defineProperty(exports, "submitBitcoinTx", {
-	enumerable: true,
-	get: function() {
-		return submitBitcoinTx;
-	}
-});
-Object.defineProperty(exports, "waitForBitcoinAccountSync", {
-	enumerable: true,
-	get: function() {
-		return waitForBitcoinAccountSync;
-	}
-});