@laceio/sdk 0.1.1 → 0.1.2-canary.1

package/dist/submit-bitcoin-tx-D6oYgH5S.js

@@ -0,0 +1,983 @@
+import { a as __toESM, r as __exportAll } from "./rolldown-runtime-OvD0k9op.js";
+import { n as import_buffer, r as init__polyfill_buffer_patch } from "./_polyfill-buffer-patch-yNxN4d5E.js";
+import { a as validateBitcoinAddress, i as isP2trAddress, l as require_src, n as AddressValidationResult, s as BitcoinNetworkId } from "./address-B9ntKL8K.js";
+import { a as getExtendedPubKeys, o as bitcoinFullDerivationPath } from "./keyDerivation-D3k9XyHg.js";
+import { t as require_src$1 } from "./src-BFoefPv_.js";
+import { n as HexBytes, t as ByteArray } from "./bytes.vo-BB7_4JK6.js";
+import { A as ContractName, C as walletRepoStoreContract, S as WalletType, _ as walletActiveStateDependencyContract, b as addressesStoreContract, j as ModuleName, l as signerFactoryAddonContract, n as sdk_default$4, o as inMemoryIntegrationAddonContract, r as sdk_default$3, s as AuthSecret, t as sdk_default$5, v as tokensStoreContract, w as networkStoreContract, x as activitiesStoreContract, y as syncStoreContract } from "./sdk-Cb-gZnS9.js";
+import { n as Ok, t as Err } from "./asyncoption-CruEYOBI.js";
+import { a as inferStoreContext, i as inferModuleContext, n as combineContracts, r as inferContractContext } from "./store-DuBG8qh5.js";
+import { t as ActivityType } from "./activity-type-GsJGWs-3.js";
+import { t as CompositeSignerFactory } from "./composite-signer-factory-CR8YHA1y.js";
+import { t as AuthenticationCancelledError } from "./types-CJT6XF2c.js";
+import { n as addressBookAddressValidatorAddonContract, r as LazyWalletMismatchError, t as tokenIdMapperAddonContract } from "./contract-1R86jhSw.js";
+import { n as BitcoinNetwork } from "./types-B8uiJn-X.js";
+import { n as BITCOIN_MEMPOOL_FEE_MARKET_FEATURE_FLAG, t as BITCOIN_FEATURE_FLAG } from "./const-CUnCl5U0.js";
+import { i as bitcoinContextActions, n as bitcoinAccountWallets$, o as bitcoinContextSelectors, r as SyncStatus } from "./side-effects-BnqYz7Nl.js";
+import { n as encodeUnsignedTxToString, t as signBitcoinTransactionWithSeed } from "./sign-bitcoin-transaction-with-seed-D4z62-jV.js";
+import { Observable, combineLatest, filter, firstValueFrom, forkJoin, map, of, switchMap, take, throwError, timeout } from "rxjs";
+import isEqual from "lodash/isEqual.js";
+//#region ../../packages/contract/bitcoin-context/src/contract.ts
+const bitcoinProviderContract = inferContractContext({
+	name: ContractName("bitcoin-provider"),
+	instance: "exactly-one",
+	contractType: "sideEffectDependency"
+});
+const bitcoinFeeMarketProvider = inferContractContext({
+	name: 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 = inferStoreContext({
+	load: async () => import("./init-DuYENxci.js"),
+	context: {
+		actions: bitcoinContextActions,
+		selectors: 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
+init__polyfill_buffer_patch();
+var import_src$1 = /* @__PURE__ */ __toESM(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 === 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 (validateBitcoinAddress(changeAddress, this.network) !== 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 (validateBitcoinAddress(address, this.network) !== 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 = 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 === 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: import_buffer.Buffer.from(knownAddr.publicKeyHex, "hex"),
+						network: net
+					}).output,
+					value: utxo.satoshis
+				}
+			});
+		}
+		coinselectOutputs.forEach(({ address, value }) => {
+			if (isP2trAddress(address)) {
+				const taprootPubKey = 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: import_buffer.Buffer.from(changeMasterFingerprint, "hex"),
+			pubkey: import_buffer.Buffer.from(changeDerivation.publicKeyHex, "hex"),
+			path: 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
+init__polyfill_buffer_patch();
+const getBitcoinInFlight = (activity) => {
+	if (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 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) => import_buffer.Buffer.from(input.hash).reverse().toString("hex"));
+	const uniqueTxIds = [...new Set(inputTxIds)];
+	if (uniqueTxIds.length === 0) return;
+	const rawTxResults = await firstValueFrom(forkJoin(uniqueTxIds.map((txId) => getRawTransaction(txId))));
+	const rawTxByTxId = /* @__PURE__ */ new Map();
+	uniqueTxIds.forEach((txId, index) => {
+		const rawTx = 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 firstValueFrom(wallet.utxos$);
+	const addresses = await 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: encodeUnsignedTxToString(tx),
+		fee: BigInt(tx.fee)
+	};
+};
+//#endregion
+//#region ../../packages/module/blockchain-bitcoin/src/sdk.ts
+const implementsContracts = combineContracts([
+	inMemoryIntegrationAddonContract,
+	tokensStoreContract,
+	addressesStoreContract,
+	syncStoreContract,
+	addressBookAddressValidatorAddonContract,
+	tokenIdMapperAddonContract,
+	signerFactoryAddonContract
+]);
+const dependsOnContracts = combineContracts([
+	bitcoinProviderContract,
+	bitcoinFeeMarketProvider,
+	networkStoreContract,
+	walletRepoStoreContract,
+	walletActiveStateDependencyContract,
+	activitiesStoreContract,
+	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 = inferModuleContext({
+	moduleName: ModuleName("blockchain-bitcoin"),
+	implements: implementsContracts,
+	dependsOn: dependsOnContracts,
+	feature: {
+		willLoad: (featureFlags) => featureFlags.some((flag) => flag.key === BITCOIN_FEATURE_FLAG),
+		metadata: {
+			name: "Bitcoin",
+			description: "Bitcoin blockchain support"
+		}
+	},
+	store: store_default$2,
+	addons: {
+		loadInMemoryWalletIntegration: async () => import("./in-memory-wallet-integration-TM9bBphA.js"),
+		loadAddressBookAddressValidators: async () => import("./address-book-address-validator-Di_ywo8M.js"),
+		loadTokenIdMapper: async () => import("./token-id-mapper-CnKHQ8DV.js"),
+		loadSignerFactory: async () => import("./signer-factory-BA7WFJVZ.js")
+	}
+});
+//#endregion
+//#region ../../packages/module/bitcoin-mempool-fee-market/src/store/index.ts
+var store_default$1 = inferStoreContext({
+	load: async () => import("./init-DlqJuHhl.js"),
+	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 = inferModuleContext({
+	moduleName: ModuleName("bitcoin-mempool-fee-market"),
+	dependsOn: combineContracts([]),
+	implements: combineContracts([bitcoinFeeMarketProvider]),
+	store: store_default$1,
+	feature: {
+		willLoad: (featureFlags) => featureFlags.some((flag) => flag.key === 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 = inferStoreContext({
+	load: async () => import("./init-C00gw1zi.js"),
+	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 = inferModuleContext({
+	moduleName: ModuleName("bitcoin-provider-maestro"),
+	dependsOn: combineContracts([]),
+	implements: combineContracts([bitcoinProviderContract]),
+	store: store_default,
+	feature: {
+		willLoad: (featureFlags) => featureFlags.some((flag) => flag.key === BITCOIN_FEATURE_FLAG),
+		metadata: {
+			name: "Maestro",
+			description: "Maestro provider for Bitcoin"
+		}
+	},
+	addons: {}
+});
+//#endregion
+//#region src/bitcoin/modules.ts
+var modules_exports = /* @__PURE__ */ __exportAll({
+	bitcoinMempoolFeeMarket: () => sdk_default$1,
+	bitcoinProviderMaestro: () => sdk_default,
+	blockchainBitcoin: () => sdk_default$2,
+	featureDev: () => sdk_default$3,
+	storageInMemory: () => sdk_default$4,
+	storageWebIndexeddb: () => sdk_default$5
+});
+//#endregion
+//#region src/bitcoin/bitcoin-lazy-in-memory-signer-factory.ts
+var import_src = /* @__PURE__ */ __toESM(require_src$1(), 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(switchMap((confirmed) => {
+			if (!confirmed) return throwError(() => new AuthenticationCancelledError());
+			return this.#signWithWords(request, accountProps);
+		}));
+	}
+	#signWithWords(request, accountProps) {
+		return new 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 = getExtendedPubKeys(seed, accountProps.accountIndex);
+					if (!isEqual(accountProps.network === BitcoinNetwork.Mainnet ? derivedKeys.mainnet : derivedKeys.testnet4, accountProps.extendedAccountPublicKeys)) throw new LazyWalletMismatchError();
+					return 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 = 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 = combineContracts([signerFactoryAddonContract]);
+	return inferModuleContext({
+		moduleName: 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 ? Ok(found) : Err(/* @__PURE__ */ new Error(`Bitcoin account "${requestedAccountId}" not found on the active network`));
+	}
+	if (bitcoinAccounts.length === 0) return Err(/* @__PURE__ */ new Error("No Bitcoin accounts found on the active network"));
+	if (bitcoinAccounts.length > 1) return Err(/* @__PURE__ */ new Error(`Multiple Bitcoin accounts found (${bitcoinAccounts.length}): specify accountId to disambiguate`));
+	return 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 firstValueFrom(stateObservables.wallets.selectAll$), await firstValueFrom(stateObservables.network.selectAllActiveNetworkIds$), requestedAccountId);
+	return resolved.isErr() ? Err(resolved.error) : 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 = bitcoinAccountWallets$.value[accountId];
+	return accountWallet ? Ok(accountWallet) : 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 Err(/* @__PURE__ */ new Error("At least one recipient is required"));
+	const invalid = recipients.find(({ amount }) => !isPositiveSatoshiAmount(amount));
+	if (invalid) return 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 ? Err(/* @__PURE__ */ new Error(`Amount ${dust.amount} for ${dust.address} is below the dust limit of 546 satoshis`)) : Ok(void 0);
+};
+const toPaymentFeeRate = (feeRate) => {
+	if (feeRate.feeOption !== "Custom") return Ok(feeRate);
+	const customFeeRate = feeRateFromSatsPerVByte(feeRate.satsPerVByte);
+	return customFeeRate === void 0 ? Err(/* @__PURE__ */ new Error(`Invalid fee rate ${feeRate.satsPerVByte}: custom rates are positive numbers of satoshis per virtual byte, at most 10,000`)) : 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 Err(validRecipients.error);
+		const paymentFeeRate = toPaymentFeeRate(feeRate);
+		if (paymentFeeRate.isErr()) return Err(paymentFeeRate.error);
+		const accountId = await resolveBitcoinAccountId(wallet.stateObservables, requestedAccountId);
+		if (accountId.isErr()) return Err(accountId.error);
+		const accountWallet = findBitcoinAccountWallet(accountId.value);
+		if (accountWallet.isErr()) return Err(accountWallet.error);
+		const pendingActivities = await firstValueFrom(wallet.stateObservables.activities.selectPendingActivitiesByAccount$);
+		const { serializedTx, fee } = await buildBitcoinPayment({
+			wallet: accountWallet.value,
+			pendingActivities: pendingActivities[accountId.value] ?? [],
+			outputs: recipients,
+			feeRate: paymentFeeRate.value,
+			memo
+		});
+		return Ok({
+			serializedTx,
+			fee
+		});
+	} catch (error) {
+		return 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 firstValueFrom(combineLatest([wallets.selectAll$, network.selectAllActiveNetworkIds$]).pipe(map(([allWallets, activeNetworkIds]) => resolveBitcoinAccount(allWallets, activeNetworkIds, options?.accountId)), filter((resolved) => resolved.isOk()), map((resolved) => resolved.unwrap().account.accountId), take(1), switchMap((accountId) => bitcoinAccountWallets$.pipe(map((accountWallets) => accountWallets[accountId]))), filter((accountWallet) => !!accountWallet), switchMap((accountWallet) => accountWallet.syncStatus$), filter(({ status }) => status === SyncStatus.Synced), options?.timeout != null ? timeout({ first: options.timeout }) : passthrough()));
+};
+const passthrough = () => (source$) => source$;
+//#endregion
+//#region src/bitcoin/sign-bitcoin-tx.ts
+const isSignableBitcoinWallet = (wallet) => wallet.type === WalletType.InMemory || wallet.type === 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 firstValueFrom(obs.wallets.selectAll$);
+		const activeNetworkIds = await firstValueFrom(obs.network.selectAllActiveNetworkIds$);
+		const resolved = resolveBitcoinAccount(allWallets.filter(isSignableBitcoinWallet), activeNetworkIds, requestedAccountId);
+		if (resolved.isErr()) return Err(resolved.error);
+		const { account, walletEntity } = resolved.value;
+		if (walletEntity.type === WalletType.InMemory && !password) return Err(/* @__PURE__ */ new Error("password is required for InMemory wallets: supply props.password or use a LazyInMemory wallet"));
+		const auth = {
+			authenticate: () => of(true),
+			accessAuthSecret: (callback) => password ? callback(AuthSecret(ByteArray(password))) : 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 CompositeSignerFactory(await wallet._loadModules("addons.loadSignerFactory"));
+		const context = {
+			wallet: walletEntity,
+			accountId: account.accountId,
+			auth
+		};
+		return Ok(await firstValueFrom(signerFactory.createTransactionSigner(context).sign({ serializedTx: HexBytes(serializedTx) })));
+	} catch (error) {
+		return 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(BitcoinNetwork).includes(network);
+const decodeSignedTx = (serializedTx) => {
+	const payload = JSON.parse(HexBytes.toUTF8(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 Err(resolved.error);
+		const accountId = resolved.value;
+		const foundWallet = findBitcoinAccountWallet(accountId);
+		if (foundWallet.isErr()) return Err(foundWallet.error);
+		const accountWallet = foundWallet.value;
+		if (accountWallet.network !== network) return Err(/* @__PURE__ */ new Error(`The transaction is for the Bitcoin ${network} network, but account "${accountId}" is on ${accountWallet.network}`));
+		const result = await firstValueFrom(accountWallet.submitTransaction(hex).pipe(timeout(SUBMIT_TX_TIMEOUT_MS)));
+		if (result.isErr()) return Err(new Error(`Transaction submission failed: ${result.error.reason}`, { cause: result.error }));
+		return Ok({ txId: result.value });
+	} catch (error) {
+		return Err(error instanceof Error ? error : new Error(String(error)));
+	}
+};
+//#endregion
+export { createBitcoinLazyInMemoryVaultModule as a, sdk_default$1 as c, BitcoinTxBuildErrorCode as d, waitForBitcoinAccountSync as i, sdk_default$2 as l, signBitcoinTx as n, modules_exports as o, buildBitcoinTx as r, sdk_default as s, submitBitcoinTx as t, BitcoinTxBuildError as u };