@laceio/sdk 0.1.0 → 0.1.1-canary.0

package/dist/side-effects-DG0R-KFc.cjs

@@ -0,0 +1,804 @@
+const require_chunk = require("./chunk-9hOWP6kD.cjs");
+const require__polyfill_buffer_patch = require("./_polyfill-buffer-patch-BycQkEkK.cjs");
+const require_address = require("./address-lECYBd9-.cjs");
+const require_time_vo = require("./time.vo-TmYE-_Y2.cjs");
+const require_bignum_vo = require("./bignum.vo-Du-bpvar.cjs");
+const require_asyncoption = require("./asyncoption-CYcZNBRM.cjs");
+const require_slice = require("./slice-B9QKuhi0.cjs");
+const require_activity_type = require("./activity-type-BPXxdHBP.cjs");
+const require_while_active = require("./while-active-I2TlHtm7.cjs");
+const require_types = require("./types-Dls6Z5gV.cjs");
+const require_const = require("./const-CSWmOyzn.cjs");
+const require_keyDerivation = require("./keyDerivation-DcKRUCVh.cjs");
+const require_bitcoin_data_provider = require("./bitcoin-data-provider-D0OT_Uiu.cjs");
+let rxjs = require("rxjs");
+let _reduxjs_toolkit = require("@reduxjs/toolkit");
+let lodash_isEqual = require("lodash/isEqual.js");
+lodash_isEqual = require_chunk.__toESM(lodash_isEqual);
+let rxjs_operators = require("rxjs/operators");
+//#region ../../packages/module/blockchain-bitcoin/src/store/slice.ts
+const slice = (0, _reduxjs_toolkit.createSlice)({
+	name: "bitcoinContext",
+	initialState: { historyFetchErrors: [] },
+	reducers: {
+		getAddressTransactionHistoryFailed: (state, action) => {
+			state.historyFetchErrors.push(action.payload);
+		},
+		setTip: (state, { payload }) => {
+			state.tip = payload;
+		}
+	},
+	selectors: {
+		selectTip: ({ tip }) => tip,
+		bitcoinContext: (sliceState) => sliceState
+	}
+});
+const selectBlockchainNetworkId = (0, _reduxjs_toolkit.createSelector)(require_slice.networkSelectors.network.selectNetworkType, require_slice.networkSelectors.network.selectBlockchainNetworks, (networkType, blockchainNetworks) => blockchainNetworks.Bitcoin?.[networkType]);
+const selectNetwork = (0, _reduxjs_toolkit.createSelector)(selectBlockchainNetworkId, (networkId) => networkId ? networkId.includes("mainnet") ? require_types.BitcoinNetwork.Mainnet : require_types.BitcoinNetwork.Testnet : void 0);
+const bitcoinContextReducers = { [slice.name]: slice.reducer };
+/** Direct import of this is an anti-pattern. OK for tests. */
+const bitcoinContextActions = { bitcoinContext: {
+	...slice.actions,
+	getTipFailed: (0, _reduxjs_toolkit.createAction)("bitcoinContext/getTipFailed"),
+	requestResync: (0, _reduxjs_toolkit.createAction)("bitcoin/requestResync")
+} };
+/** Direct import of this is an anti-pattern. OK for tests. */
+const bitcoinContextSelectors = { bitcoinContext: {
+	...slice.selectors,
+	selectBlockchainNetworkId,
+	selectNetwork
+} };
+const BITCOIN_TOKEN_METADATA = {
+	name: "Bitcoin",
+	ticker: "BTC",
+	decimals: 8,
+	displayDecimalPlaces: 8,
+	image: "data:image/png;base64,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",
+	blockchainSpecific: {}
+};
+//#endregion
+//#region ../../packages/module/blockchain-bitcoin/src/tx-builder/utils.ts
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+var import_src = /* @__PURE__ */ require_chunk.__toESM(require_address.require_src());
+/**
+* Converts a raw transaction hex into a BitcoinTransactionHistoryEntry using an InputResolver to fetch additional input details.
+*
+* This function deserializes a raw Bitcoin transaction hex and transforms it into a transaction history entry.
+* It uses an InputResolver to asynchronously fetch and include details about each input, such as the associated address
+* and the amount of satoshis, which are not directly available from the transaction input script.
+*
+* @param raw - The raw hexadecimal string of the Bitcoin transaction.
+* @param network - The Bitcoin network (Mainnet or Testnet) that the transaction pertains to.
+* @param inputResolver - An instance of InputResolver to fetch additional input details.
+* @returns A promise that resolves to a detailed transaction history entry.
+*/
+const historyEntryFromRawTx = async (raw, network, inputResolver) => {
+	const tx = import_src.Transaction.fromHex(raw);
+	const bitcoinNetwork = network === require_types.BitcoinNetwork.Mainnet ? import_src.networks.bitcoin : import_src.networks.testnet;
+	return {
+		inputs: await Promise.all(tx.ins.map(async (input) => {
+			const txId = require__polyfill_buffer_patch.import_buffer.Buffer.from(input.hash).reverse().toString("hex");
+			const index = input.index;
+			try {
+				return {
+					...await inputResolver.resolve(txId, index),
+					isCoinbase: false
+				};
+			} catch {
+				return {
+					txId,
+					index,
+					address: "",
+					satoshis: 0,
+					isCoinbase: false
+				};
+			}
+		})),
+		outputs: tx.outs.map((o) => {
+			const chunks = import_src.script.decompile(o.script);
+			if (chunks && chunks[0] === import_src.opcodes.OP_RETURN) {
+				const payloadChunks = chunks.slice(1).filter((c) => require__polyfill_buffer_patch.import_buffer.Buffer.isBuffer(c));
+				const opReturnData = require__polyfill_buffer_patch.import_buffer.Buffer.concat(payloadChunks).toString("utf8");
+				return {
+					address: "",
+					satoshis: o.value,
+					opReturnData
+				};
+			}
+			return {
+				address: import_src.address.fromOutputScript(o.script, bitcoinNetwork),
+				satoshis: o.value
+			};
+		}),
+		transactionHash: tx.getId(),
+		confirmations: 0,
+		status: require_bitcoin_data_provider.BitcoinTransactionStatus.Pending,
+		blockHeight: 0,
+		timestamp: 0
+	};
+};
+//#endregion
+//#region ../../packages/module/blockchain-bitcoin/src/providers/BlockchainInputResolver.ts
+/**
+* Represents an implementation of the `InputResolver` interface that fetches detailed information
+* about a transaction input from the blockchain data provider.
+*/
+var BlockchainInputResolver = class {
+	/**
+	* Creates an instance of `BlockchainInputResolver`.
+	*
+	* @param dataProvider - The provider used to fetch transaction data from the blockchain.
+	* @param network - The Bitcoin network the inputs belong to.
+	*/
+	constructor(dataProvider, network) {
+		this.dataProvider = dataProvider;
+		this.network = network;
+	}
+	/**
+	* Resolves the transaction input to a `UTxO` object providing detailed information
+	* about the input, including the owning address and the amount.
+	*
+	* @param txId - The hexadecimal string representing the transaction ID of the input to resolve.
+	* @param index - The zero-based index of the input within the transaction's list of outputs.
+	*
+	* @returns A promise that resolves to a `BitcoinUTxO` object containing the resolved input details.
+	* If the input cannot be resolved, the promise should reject with an error explaining the failure.
+	*/
+	async resolve(txId, index) {
+		const transaction = (await (0, rxjs.firstValueFrom)(this.dataProvider.getTransaction({ network: this.network }, txId))).unwrapOr(null);
+		if (!transaction || index >= transaction.outputs.length) throw new Error("Transaction or output index not found");
+		const output = transaction.outputs[index];
+		return {
+			txId,
+			index,
+			address: output.address,
+			satoshis: output.satoshis,
+			script: "",
+			confirmations: transaction.confirmations,
+			height: transaction.blockHeight,
+			runes: [],
+			inscriptions: []
+		};
+	}
+};
+//#endregion
+//#region ../../packages/module/blockchain-bitcoin/src/wallet/BitcoinWallet.ts
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+var import_dist = /* @__PURE__ */ require_chunk.__toESM(require_address.require_dist());
+import_src.initEccLib(import_dist);
+/** Where an account wallet is in syncing its state with the provider. */
+let SyncStatus = /* @__PURE__ */ function(SyncStatus) {
+	SyncStatus["Pending"] = "pending";
+	SyncStatus["Syncing"] = "syncing";
+	SyncStatus["Synced"] = "synced";
+	SyncStatus["Error"] = "error";
+	return SyncStatus;
+}({});
+var BitcoinWallet = class {
+	syncStatus$ = new rxjs.BehaviorSubject({
+		status: SyncStatus.Syncing,
+		lastUpdate: Date.now()
+	});
+	transactionHistory$ = new rxjs.BehaviorSubject(new Array());
+	pendingTransactions$ = new rxjs.BehaviorSubject(new Array());
+	utxos$ = new rxjs.BehaviorSubject(new Array());
+	balance$ = new rxjs.BehaviorSubject(0);
+	addresses$ = new rxjs.BehaviorSubject(new Array());
+	isLoadingHistory$ = new rxjs.BehaviorSubject(false);
+	network;
+	address;
+	masterFingerprint;
+	nextCursor$ = new rxjs.BehaviorSubject(void 0);
+	pollSubscription = null;
+	lastKnownBlock = null;
+	historyDepth;
+	provider;
+	info;
+	pollController$;
+	requestResync$;
+	logger;
+	inputResolver;
+	feeMarketProvider;
+	constructor(provider, feeMarketProvider, historyDepth = 20, info, pollController$, requestResync$, logger) {
+		const bitcoinNetwork = info.network === require_types.BitcoinNetwork.Mainnet ? import_src.networks.bitcoin : import_src.networks.testnet;
+		this.pollController$ = pollController$;
+		this.requestResync$ = requestResync$;
+		this.logger = logger;
+		this.network = info.network;
+		this.historyDepth = historyDepth;
+		this.provider = provider;
+		this.info = info;
+		this.masterFingerprint = info.masterFingerprint;
+		this.inputResolver = new BlockchainInputResolver(provider, this.network);
+		this.feeMarketProvider = feeMarketProvider;
+		const extendedAccountPubKey = info.extendedAccountPublicKeys.nativeSegWit;
+		const pubKey = require_keyDerivation.deriveChildPublicKey(extendedAccountPubKey, require_keyDerivation.ChainType.External, 0);
+		this.address = {
+			address: require_address.deriveAddressByType(pubKey, require_address.AddressType.NativeSegWit, bitcoinNetwork),
+			addressType: require_address.AddressType.NativeSegWit,
+			network: info.network,
+			account: this.info.accountIndex,
+			chain: require_keyDerivation.ChainType.External,
+			index: 0,
+			publicKeyHex: require__polyfill_buffer_patch.import_buffer.Buffer.from(pubKey).toString("hex")
+		};
+		this.addresses$.next([this.address]);
+		this.startPolling();
+		this.utxos$.pipe((0, rxjs_operators.map)((utxos) => utxos.reduce((total, utxo) => total + utxo.satoshis, 0))).subscribe((balance) => {
+			this.balance$.next(balance);
+		});
+	}
+	getInfo() {
+		return (0, rxjs.of)(require_asyncoption.Ok(this.info));
+	}
+	getNetwork() {
+		return (0, rxjs.of)(require_asyncoption.Ok(this.network));
+	}
+	getAddress() {
+		return (0, rxjs.of)(require_asyncoption.Ok(this.address));
+	}
+	/**
+	* Fetches the raw serialized transaction (hex) for a given transaction id.
+	*
+	* @param txId - 32-byte transaction ID in hexadecimal form.
+	*/
+	getRawTransaction(txId) {
+		return this.provider.getRawTransaction({ network: this.network }, txId);
+	}
+	/**
+	* Fetches the current fee market for estimating transaction fees.
+	*/
+	getCurrentFeeMarket() {
+		return this.feeMarketProvider.getFeeMarket({ network: this.network });
+	}
+	/**
+	* Fetches transaction history pages recursively until the total number of
+	* transactions reaches the `desiredAmount` or the end of history is found.
+	*
+	* @param desiredAmount - The target number of transactions to have loaded.
+	* @returns An observable that emits an `Ok<boolean>` on success or an `Err<ProviderError>` on failure.
+	* The boolean is `true` if the end of history was reached.
+	*/
+	fetchTxHistoryUpTo(desiredAmount) {
+		if (this.isLoadingHistory$.value) {
+			this.logger.debug("History loading already in progress. Skipping request.");
+			return (0, rxjs.of)(require_asyncoption.Ok(false));
+		}
+		this.isLoadingHistory$.next(true);
+		return (0, rxjs.of)(this.nextCursor$.value).pipe((0, rxjs.expand)((cursor) => {
+			if (this.transactionHistory$.value.length >= desiredAmount || cursor === null) return rxjs.EMPTY;
+			return this.provider.getTransactions({ network: this.network }, this.address.address, {
+				cursor,
+				limit: this.historyDepth,
+				order: "desc"
+			}).pipe((0, rxjs_operators.map)((result) => {
+				if (result.isErr()) {
+					this.logger.error("Failed to get older transactions:", result.error);
+					throw result.error;
+				}
+				const { items: olderHistory, cursor: nextCursor } = result.value;
+				const uniqueHistory = Array.from(new Map([...this.transactionHistory$.value, ...olderHistory].map((tx) => [tx.transactionHash, tx])).values());
+				this.transactionHistory$.next(uniqueHistory);
+				this.nextCursor$.next(nextCursor || null);
+				return nextCursor || null;
+			}));
+		}), (0, rxjs.defaultIfEmpty)(this.nextCursor$.value), (0, rxjs.last)(), (0, rxjs_operators.map)((lastCursor) => lastCursor === null), (0, rxjs_operators.map)((hasReachedEnd) => require_asyncoption.Ok(hasReachedEnd)), (0, rxjs_operators.catchError)((error) => {
+			this.logger.error("A critical error occurred during history fetch:", error);
+			return (0, rxjs.of)(require_asyncoption.Err(error));
+		}), (0, rxjs.finalize)(() => {
+			this.isLoadingHistory$.next(false);
+		}));
+	}
+	/**
+	* Submits a raw transaction to the blockchain for inclusion in a block.
+	*
+	* On success the transaction is eagerly appended to pendingTransactions$.
+	* A failure to derive that pending entry (e.g. an output with no address
+	* form) is logged but never fails the submission: the transaction is
+	* already on the network, so the txId must still be returned.
+	*
+	* @param rawTransaction - The raw transaction data to be broadcast to the network.
+	*/
+	submitTransaction(rawTransaction) {
+		return this.provider.submitTransaction({ network: this.network }, rawTransaction).pipe((0, rxjs.mergeMap)((submitResult) => {
+			if (submitResult.isErr()) return (0, rxjs.of)(submitResult);
+			const transactionId = submitResult.value;
+			return (0, rxjs.from)(historyEntryFromRawTx(rawTransaction, this.network, this.inputResolver)).pipe((0, rxjs.tap)((entry) => {
+				entry.transactionHash = transactionId;
+				if (!this.pendingTransactions$.value.some((tx) => tx.transactionHash === entry.transactionHash)) this.pendingTransactions$.next([...this.pendingTransactions$.value, entry]);
+			}), (0, rxjs_operators.map)(() => submitResult), (0, rxjs_operators.catchError)((error) => {
+				this.logger.error("Failed to derive pending entry for submitted transaction:", error);
+				return (0, rxjs.of)(submitResult);
+			}));
+		}), (0, rxjs_operators.catchError)((error) => {
+			this.logger.error("Failed to submit transaction:", error);
+			return (0, rxjs.of)(require_asyncoption.Err(error));
+		}));
+	}
+	/**
+	* Stop polling by unsubscribing from the subscription
+	*/
+	shutdown() {
+		if (this.pollSubscription) {
+			this.pollSubscription.unsubscribe();
+			this.pollSubscription = null;
+		}
+	}
+	/**
+	* Starts reacting to tip changes and updating wallet state.
+	* The polling controller is responsible for *when* we trigger,
+	* this method just reacts to those triggers.
+	*/
+	startPolling() {
+		this.pollSubscription = (0, rxjs.merge)(this.pollController$.pipe((0, rxjs_operators.map)((tip) => ({
+			type: "tip",
+			tip
+		}))), this.requestResync$.pipe((0, rxjs.withLatestFrom)(this.pollController$), (0, rxjs_operators.map)(([, tip]) => ({
+			type: "manual",
+			tip
+		})))).pipe((0, rxjs.tap)((event) => {
+			this.updateSyncStatus(SyncStatus.Pending);
+			this.logger.debug(event.type === "tip" ? `Poll triggered by tip ${event.tip.hash} at height ${event.tip.height}` : `Manual resync triggered at tip ${event.tip.hash} (height ${event.tip.height})`);
+		}), (0, rxjs_operators.switchMap)((event) => {
+			const latestBlockInfo = event.tip;
+			let task$;
+			if (event.type === "tip") task$ = !this.lastKnownBlock || this.lastKnownBlock.hash !== latestBlockInfo.hash ? this.updateState(latestBlockInfo) : this.updatePendingTransactions();
+			else task$ = this.updateState(latestBlockInfo);
+			this.updateSyncStatus(SyncStatus.Syncing);
+			return task$.pipe((0, rxjs.tap)(() => {
+				this.updateSyncStatus(SyncStatus.Synced);
+			}), (0, rxjs_operators.catchError)((error) => {
+				this.logger.error("Failed to update wallet state:", error);
+				this.updateSyncStatus(SyncStatus.Error, error);
+				return rxjs.EMPTY;
+			}));
+		})).subscribe();
+	}
+	/**
+	* Fetches the latest transactions and updates the transactionHistory$ subject if they have changed.
+	*/
+	updateTransactions() {
+		return this.provider.getTransactions({ network: this.network }, this.address.address, {
+			limit: this.historyDepth,
+			order: "desc"
+		}).pipe((0, rxjs_operators.map)((result) => {
+			if (result.isErr()) {
+				this.logger.error("Failed to get transactions:", result.error);
+				throw result.error;
+			}
+			const { items: newHistory, cursor: nextCursor } = result.value;
+			const currentHistory = this.transactionHistory$.value;
+			const combinedHistory = [...currentHistory, ...newHistory];
+			const uniqueHistory = Array.from(new Map(combinedHistory.map((tx) => [tx.transactionHash, tx])).values());
+			uniqueHistory.sort((a, b) => b.timestamp - a.timestamp);
+			const hasSetChanged = !(0, lodash_isEqual.default)(uniqueHistory, currentHistory);
+			if (hasSetChanged) this.transactionHistory$.next(uniqueHistory);
+			if (this.nextCursor$.value === void 0) this.nextCursor$.next(nextCursor || null);
+			return hasSetChanged;
+		}));
+	}
+	/**
+	* Updates the local list of pending transactions by synchronizing with the remote mempool.
+	*
+	* Transactions in the Bitcoin network can be replaced in the mempool by another transaction
+	* with the same inputs but possibly with a higher fee (Replace-By-Fee, RBF).
+	*
+	* The method performs the following operations:
+	*
+	* 1. **Fetch Remote Pending Transactions**: Retrieves the list of pending transactions from the mempool
+	*    for the wallet's address. This includes transactions that are waiting to be confirmed.
+	*
+	* 2. **Synchronize Local and Remote Transactions**:
+	*    - For each remote pending transaction:
+	*      - If it matches a transaction in the local list (by transaction hash), it updates the local transaction
+	*        with the remote version, since it contains more metadata (I.E resolved inputs).
+	*
+	* 3. **Purge Invalid Local Transactions**:
+	*    - Iterates over the local list of pending transactions to check each transaction's inputs against:
+	*      a. Inputs of **confirmed** transactions in the history (`confirmations > 0`) to detect inputs settled in a
+	*         block. Unconfirmed history entries are ignored — a transaction stays pending until it is mined.
+	*      b. Inputs of other remote pending transactions to handle RBF scenarios where a transaction might be replaced
+	*         by another with the same inputs but not the same hash.
+	*    - Removes any local transactions whose inputs are found in the confirmed transactions or in another competing pending transaction.
+	*/
+	updatePendingTransactions() {
+		return this.provider.getTransactionsInMempool({ network: this.network }, this.address.address, { order: "desc" }).pipe((0, rxjs.withLatestFrom)(this.pendingTransactions$), (0, rxjs.tap)(([mempoolResult, localPendingTxs]) => {
+			if (mempoolResult.isErr()) {
+				this.logger.error("Failed to get mempool transactions:", mempoolResult.error);
+				throw mempoolResult.error;
+			}
+			const { items: remotePendingTxs } = mempoolResult.value;
+			const confirmedHistory = this.transactionHistory$.value.filter((tx) => tx.confirmations > 0);
+			const validLocalTxs = localPendingTxs.filter((localTx) => {
+				return !localTx.inputs.some((input) => this.isInputSpent(input, confirmedHistory) || this.isInputSpent(input, remotePendingTxs.filter((remoteTx) => remoteTx.transactionHash !== localTx.transactionHash)));
+			});
+			const finalTxsMap = new Map(validLocalTxs.map((tx) => [tx.transactionHash, tx]));
+			remotePendingTxs.forEach((remoteTx) => {
+				finalTxsMap.set(remoteTx.transactionHash, remoteTx);
+			});
+			let newPendingTxs = Array.from(finalTxsMap.values());
+			const confirmedHashes = new Set(confirmedHistory.map((tx) => tx.transactionHash));
+			newPendingTxs = newPendingTxs.filter((tx) => !confirmedHashes.has(tx.transactionHash));
+			if (!(0, lodash_isEqual.default)(newPendingTxs, this.pendingTransactions$.value)) this.pendingTransactions$.next(newPendingTxs);
+		}), (0, rxjs_operators.map)(() => void 0));
+	}
+	/**
+	* Helper method to check if a specific transaction input has been used
+	* in a given list of transactions.
+	*/
+	isInputSpent(inputToFind, transactionList) {
+		return transactionList.some((tx) => tx.inputs.some((input) => input.txId === inputToFind.txId && input.index === inputToFind.index));
+	}
+	/**
+	* Fetches the latest UTxOs and updates the utxos$ subject if they have changed.
+	* Returns a cold observable that completes when the operation is done.
+	*/
+	updateUtxos() {
+		return this.provider.getUTxOs({ network: this.network }, this.address.address, {}).pipe((0, rxjs.withLatestFrom)(this.utxos$), (0, rxjs.tap)(([utxoResult, currentUtxos]) => {
+			if (utxoResult.isErr()) {
+				this.logger.error("Failed to get UTxOs:", utxoResult.error);
+				throw utxoResult.error;
+			}
+			const { items } = utxoResult.value;
+			if (!(0, lodash_isEqual.default)(items, currentUtxos)) this.utxos$.next(items);
+		}), (0, rxjs_operators.map)(() => void 0));
+	}
+	/**
+	* Updates the entire wallet state.
+	* It chains the various update operations in the correct order.
+	*/
+	updateState(latestBlockInfo) {
+		return this.updateTransactions().pipe((0, rxjs.mergeMap)((hasTxSetChanged) => {
+			const tasksToRun = [this.updatePendingTransactions()];
+			if (hasTxSetChanged) tasksToRun.push(this.updateUtxos());
+			return (0, rxjs.forkJoin)(tasksToRun);
+		}), (0, rxjs.tap)(() => {
+			this.lastKnownBlock = latestBlockInfo;
+		}), (0, rxjs_operators.map)(() => void 0));
+	}
+	updateSyncStatus(status, lastError) {
+		this.syncStatus$.next({
+			status,
+			lastUpdate: Date.now(),
+			lastError
+		});
+	}
+};
+//#endregion
+//#region ../../packages/module/blockchain-bitcoin/src/wallet/account-wallets.ts
+/**
+* A BehaviorSubject that holds a record of Bitcoin wallets associated with account IDs.
+* The keys are AccountId strings, and the values are BitcoinWallet instances.
+* It is a single module-level subject, so every wallet loaded in the same
+* JavaScript realm registers its accounts here.
+*/
+const bitcoinAccountWallets$ = new rxjs.BehaviorSubject({});
+//#endregion
+//#region ../../packages/module/blockchain-bitcoin/src/store/helpers/compute-token-balances.ts
+const outpointKey = (ref) => `${ref.txId}#${ref.index}`;
+/**
+* Derives the confirmed (`available`) and unconfirmed (`pending`) BTC balances
+* for an account from its confirmed UTxO set and the transactions currently in
+* the mempool.
+*
+* - `available`: confirmed UTxOs **minus** any consumed by an unconfirmed
+*   transaction. Those are in-flight spent and no longer spendable, even though
+*   the provider still reports them as confirmed UTxOs until the next block.
+* - `pending`: value of unconfirmed outputs paying our own addresses — an
+*   incoming receive, or our own change from an outgoing send. These are
+*   recognised by the wallet but not yet finalised by the network.
+*
+* Deriving both from the same pending set avoids double-counting: on an
+* outgoing send the spent UTxO leaves `available` while its change appears in
+* `pending`, so `available + pending` reflects the true post-send balance.
+*
+* Outputs that are themselves spent by another mempool transaction (chained
+* mempool spends) are excluded from `pending` so they are not counted twice.
+*/
+const computeBitcoinTokenBalances = ({ confirmedUtxos, pendingTransactions, ownAddresses }) => {
+	const spentOutpoints = /* @__PURE__ */ new Set();
+	for (const tx of pendingTransactions) for (const input of tx.inputs) spentOutpoints.add(outpointKey(input));
+	let available = 0n;
+	for (const utxo of confirmedUtxos) if (!spentOutpoints.has(outpointKey(utxo))) available += BigInt(utxo.satoshis);
+	let pending = 0n;
+	for (const tx of pendingTransactions) for (const [index, output] of tx.outputs.entries()) {
+		const isOwn = ownAddresses.has(output.address);
+		const isSpentByAnotherPendingTx = spentOutpoints.has(outpointKey({
+			txId: tx.transactionHash,
+			index
+		}));
+		if (isOwn && !isSpentByAnotherPendingTx) pending += BigInt(output.satoshis);
+	}
+	return {
+		available,
+		pending
+	};
+};
+//#endregion
+//#region ../../packages/module/blockchain-bitcoin/src/store/side-effects.ts
+const mapNetworkTypeToBitcoinNetwork = (networkType) => {
+	switch (networkType) {
+		case "mainnet": return require_types.BitcoinNetwork.Mainnet;
+		case "testnet": return require_types.BitcoinNetwork.Testnet;
+		default: {
+			const _exhaustive = networkType;
+			throw new Error(`Unhandled network type: ${String(_exhaustive)}`);
+		}
+	}
+};
+const deriveBitcoinTestnetOptions = (config) => {
+	const maestroConfig = config.bitcoinProvider.maestroConfig;
+	if (!Object.keys(maestroConfig ?? {}).includes(require_types.BitcoinNetwork.Testnet)) return [];
+	return [{
+		id: require_address.BitcoinNetworkId("testnet4"),
+		label: "bitcoin.network-config.network-option.testnet4"
+	}];
+};
+const registerBitcoinTestnetOptions = (testnetOptions) => (_, { network: { selectTestnetOptions$ } }, { actions }) => selectTestnetOptions$.pipe((0, rxjs.filter)((options) => !options?.Bitcoin), (0, rxjs.map)(() => actions.network.setTestnetOptions({
+	blockchainName: "Bitcoin",
+	options: testnetOptions
+})));
+const registerBitcoinBlockchainNetworks = (_, { network: { selectBlockchainNetworks$ } }, { actions }) => selectBlockchainNetworks$.pipe((0, rxjs.filter)((blockchainNetworks) => !blockchainNetworks?.Bitcoin), (0, rxjs.map)(() => actions.network.setBlockchainNetworks({
+	blockchain: "Bitcoin",
+	mainnet: require_address.BitcoinNetworkId("mainnet"),
+	testnet: require_address.BitcoinNetworkId("testnet4")
+})));
+const mapBitcoinTxToActivity = (rawTx, userAddresses, accountId) => {
+	let totalInputFromUser = 0;
+	let totalOutputToUser = 0;
+	let hasForeignOutput = false;
+	let hasOwnInputs = false;
+	for (const input of rawTx.inputs) if (userAddresses.has(input.address)) {
+		totalInputFromUser += input.satoshis;
+		hasOwnInputs = true;
+	}
+	for (const output of rawTx.outputs) if (userAddresses.has(output.address)) totalOutputToUser += output.satoshis;
+	else hasForeignOutput = true;
+	const netAmount = BigInt(totalOutputToUser - totalInputFromUser);
+	let activityType;
+	if (hasOwnInputs && !hasForeignOutput) activityType = require_activity_type.ActivityType.Self;
+	else if (netAmount > 0n) activityType = require_activity_type.ActivityType.Receive;
+	else activityType = require_activity_type.ActivityType.Send;
+	if (rawTx.confirmations <= 0) activityType = require_activity_type.ActivityType.Pending;
+	return {
+		accountId,
+		activityId: rawTx.transactionHash,
+		type: activityType,
+		tokenBalanceChanges: [{
+			tokenId: require_const.BITCOIN_TOKEN_ID,
+			amount: require_bignum_vo.BigNumber(netAmount)
+		}],
+		timestamp: require_time_vo.Timestamp(rawTx.timestamp > 0 ? rawTx.timestamp * 1e3 : Date.now()),
+		...activityType === require_activity_type.ActivityType.Pending ? { blockchainSpecific: { Bitcoin: {
+			consumedInputs: rawTx.inputs.map((input) => ({
+				txId: input.txId,
+				index: input.index
+			})),
+			producedOutputs: []
+		} } } : {}
+	};
+};
+const trackTip = (tipPollFrequency) => (_, { bitcoinContext: { selectNetwork$ }, wallets: { selectActiveNetworkAccounts$ } }, { actions, bitcoinProvider: { getLastKnownBlock }, isWalletActive$ }) => (0, rxjs.combineLatest)([selectNetwork$.pipe((0, rxjs.distinctUntilChanged)()), selectActiveNetworkAccounts$.pipe((0, rxjs.map)((accounts) => accounts.some((account) => account.blockchainName === "Bitcoin")), (0, rxjs.distinctUntilChanged)())]).pipe((0, rxjs.switchMap)(([network, hasBitcoinAccounts]) => {
+	if (!network) return (0, rxjs.of)(actions.bitcoinContext.setTip(void 0));
+	if (!hasBitcoinAccounts) return rxjs.EMPTY;
+	return (0, rxjs.merge)((0, rxjs.of)(void 0), (0, rxjs.interval)(tipPollFrequency)).pipe((0, rxjs.exhaustMap)(() => getLastKnownBlock({ network })), (0, rxjs.mergeMap)((result) => {
+		if (result.isErr()) return (0, rxjs.of)(actions.bitcoinContext.getTipFailed({
+			failure: result.error.reason,
+			network
+		}));
+		return (0, rxjs.of)(actions.bitcoinContext.setTip(result.value));
+	}));
+}), require_while_active.whileActive(isWalletActive$));
+/**
+* Factory function to create and configure a new BitcoinWallet instance.
+*
+* @param historyDepth - The depth of transaction history to maintain.
+* @param requestResync$ - Observable that triggers wallet resynchronization.
+* @param selectNetwork$ - Observable providing the current Bitcoin network (undefined when not yet registered).
+* @param selectTip$ - Observable providing the current blockchain tip.
+* @param bitcoinAccountWallets$ - Observable holding the mapping of account IDs to BitcoinWallet instances.
+* @param provider - The Bitcoin data provider.
+* @param feeMarketProvider - The provider for fee market estimations.
+* @param account - The in-memory wallet account data.
+* @param logger - The logger for wallet errors.
+* @returns An object containing observables for the wallet's tokens and addresses.
+*/
+const createBitcoinWallet = ({ historyDepth, requestResync$, selectNetwork$, selectTip$, bitcoinAccountWallets$, provider, feeMarketProvider, account, logger }) => {
+	const walletInfo = {
+		accountIndex: account.blockchainSpecific.accountIndex,
+		extendedAccountPublicKeys: account.blockchainSpecific.extendedAccountPublicKeys,
+		masterFingerprint: account.blockchainSpecific.masterFingerprint,
+		network: mapNetworkTypeToBitcoinNetwork(account.networkType),
+		walletId: account.walletId
+	};
+	const resyncController$ = requestResync$.pipe((0, rxjs.filter)(({ payload: { accountId } }) => accountId === account.accountId));
+	const wallet = new BitcoinWallet(provider, feeMarketProvider, historyDepth, walletInfo, (0, rxjs.combineLatest)([selectTip$, selectNetwork$]).pipe((0, rxjs.filter)(([tip, currentNetwork]) => !!tip && currentNetwork === walletInfo.network), (0, rxjs.map)(([tip]) => tip)), resyncController$, logger);
+	const currentWallets = bitcoinAccountWallets$.value;
+	bitcoinAccountWallets$.next({
+		...currentWallets,
+		[account.accountId]: wallet
+	});
+	return {
+		addresses$: wallet.addresses$.pipe((0, rxjs.map)((derivedAddresses) => derivedAddresses.map((derivedAddr) => ({
+			address: derivedAddr.address,
+			accountId: account.accountId,
+			data: {
+				network: derivedAddr.network,
+				addressType: derivedAddr.addressType,
+				account: derivedAddr.account,
+				chain: derivedAddr.chain,
+				index: derivedAddr.index,
+				publicKeyHex: derivedAddr.publicKeyHex
+			}
+		})))),
+		tokens$: (0, rxjs.combineLatest)([
+			wallet.addresses$,
+			wallet.utxos$,
+			wallet.pendingTransactions$
+		]).pipe((0, rxjs.map)(([addresses, utxos, pendingTransactions]) => {
+			const primaryAddress = addresses[0]?.address || "";
+			const { available, pending } = computeBitcoinTokenBalances({
+				confirmedUtxos: utxos,
+				pendingTransactions,
+				ownAddresses: new Set(addresses.map((a) => a.address))
+			});
+			const btcToken = {
+				metadata: BITCOIN_TOKEN_METADATA,
+				accountId: account.accountId,
+				address: require_types.BitcoinAddress(primaryAddress),
+				tokenId: require_const.BITCOIN_TOKEN_ID,
+				available: require_bignum_vo.BigNumber(available),
+				pending: require_bignum_vo.BigNumber(pending),
+				decimals: 8,
+				displayDecimalPlaces: 8,
+				displayLongName: "Bitcoin",
+				displayShortName: "BTC",
+				blockchainName: "Bitcoin"
+			};
+			return {
+				address: require_types.BitcoinAddress(primaryAddress),
+				tokens: [btcToken]
+			};
+		})),
+		syncStatus$: wallet.syncStatus$,
+		activities$: (0, rxjs.combineLatest)([
+			wallet.transactionHistory$,
+			wallet.pendingTransactions$,
+			wallet.addresses$
+		]).pipe((0, rxjs.map)(([rawTxs, pendingTxs, derivedAddresses]) => {
+			const userAddresses = new Set(derivedAddresses.map((a) => a.address));
+			return [...pendingTxs, ...rawTxs].map((rawTx) => mapBitcoinTxToActivity(rawTx, userAddresses, account.accountId));
+		})),
+		fetchTxHistoryUpTo: (desiredCount) => {
+			return wallet.fetchTxHistoryUpTo(desiredCount);
+		}
+	};
+};
+const startBitcoinWallet = (historyDepth) => ({ bitcoinContext: { requestResync$, getTipFailed$ } }, { bitcoinContext: { selectTip$, selectNetwork$ }, wallets: { selectActiveNetworkAccounts$ }, activities: { selectDesiredLoadedActivitiesCountPerAccount$, selectAllMap$ } }, { bitcoinProvider, bitcoinAccountWallets$, bitcoinFeeMarketProvider, actions, logger }) => selectActiveNetworkAccounts$.pipe((0, rxjs.map)((accounts) => accounts.filter((account) => account.blockchainName === "Bitcoin")), (0, rxjs.mergeAll)(), (0, rxjs.mergeMap)((bitcoinAccount) => {
+	const bitcoinWallet = createBitcoinWallet({
+		historyDepth,
+		requestResync$,
+		selectNetwork$,
+		selectTip$,
+		bitcoinAccountWallets$,
+		provider: bitcoinProvider,
+		feeMarketProvider: bitcoinFeeMarketProvider,
+		account: bitcoinAccount,
+		logger
+	});
+	return (0, rxjs.merge)(selectActiveNetworkAccounts$.pipe((0, rxjs.take)(1), (0, rxjs.map)(() => actions.tokens.upsertTokensMetadata({ metadatas: [{
+		...BITCOIN_TOKEN_METADATA,
+		tokenId: require_const.BITCOIN_TOKEN_ID
+	}] }))), bitcoinWallet.addresses$.pipe((0, rxjs.map)((addresses) => {
+		return actions.addresses.upsertAddresses({
+			accountId: bitcoinAccount.accountId,
+			addresses,
+			blockchainName: "Bitcoin"
+		});
+	})), bitcoinWallet.syncStatus$.pipe((0, rxjs.map)((update) => {
+		const operationId = `${bitcoinAccount.accountId}-bitcoin-sync`;
+		switch (update.status) {
+			case SyncStatus.Pending: return actions.sync.addSyncOperation({
+				accountId: bitcoinAccount.accountId,
+				operation: {
+					operationId,
+					status: "Pending",
+					description: "sync.operation.bitcoin-wallet-sync",
+					startedAt: require_time_vo.Timestamp(update.lastUpdate)
+				}
+			});
+			case SyncStatus.Syncing: return actions.sync.addSyncOperation({
+				accountId: bitcoinAccount.accountId,
+				operation: {
+					operationId,
+					status: "InProgress",
+					type: "Indeterminate",
+					description: "sync.operation.bitcoin-wallet-sync",
+					startedAt: require_time_vo.Timestamp(update.lastUpdate)
+				}
+			});
+			case SyncStatus.Synced: return actions.sync.completeSyncOperation({
+				accountId: bitcoinAccount.accountId,
+				operationId
+			});
+			case SyncStatus.Error: return actions.sync.failSyncOperation({
+				accountId: bitcoinAccount.accountId,
+				operationId,
+				error: "sync.error.bitcoin-sync-failed"
+			});
+		}
+	})), getTipFailed$.pipe((0, rxjs.withLatestFrom)(selectNetwork$), (0, rxjs.filter)(([{ payload }, currentNetwork]) => payload.network === currentNetwork), (0, rxjs.withLatestFrom)(bitcoinWallet.syncStatus$), (0, rxjs.filter)(([, walletStatus]) => walletStatus.status === SyncStatus.Syncing), (0, rxjs.map)(() => actions.sync.failSyncOperation({
+		accountId: bitcoinAccount.accountId,
+		operationId: `${bitcoinAccount.accountId}-bitcoin-sync`,
+		error: "sync.error.bitcoin-sync-failed"
+	}))), bitcoinWallet.tokens$.pipe((0, rxjs.skip)(1), (0, rxjs.map)(({ address, tokens }) => {
+		return actions.tokens.setAddressTokens({
+			accountId: bitcoinAccount.accountId,
+			address: require_types.BitcoinAddress(address),
+			tokens,
+			blockchainName: "Bitcoin"
+		});
+	})), bitcoinWallet.activities$.pipe((0, rxjs.map)((activities) => {
+		return actions.activities.upsertActivities({
+			accountId: bitcoinAccount.accountId,
+			activities
+		});
+	})), selectDesiredLoadedActivitiesCountPerAccount$.pipe((0, rxjs.mergeMap)((desiredCountMap) => (0, rxjs.from)(Object.entries(desiredCountMap))), (0, rxjs.filter)(([accountId]) => accountId === bitcoinAccount.accountId), (0, rxjs.withLatestFrom)(selectAllMap$), (0, rxjs.filter)(([[, desiredCount], loadedActivities]) => {
+		return (loadedActivities[bitcoinAccount.accountId]?.length ?? 0) < desiredCount;
+	}), (0, rxjs.switchMap)(([[, desiredAmount]]) => bitcoinWallet.fetchTxHistoryUpTo(desiredAmount)), (0, rxjs.mergeMap)((result) => {
+		if (result.isErr()) return (0, rxjs.of)(actions.bitcoinContext.getAddressTransactionHistoryFailed({
+			accountId: bitcoinAccount.accountId,
+			failure: result.error.reason
+		}));
+		if (result.value) return (0, rxjs.of)(actions.activities.setHasLoadedOldestEntry({
+			accountId: bitcoinAccount.accountId,
+			hasLoadedOldestEntry: true
+		}));
+		return rxjs.EMPTY;
+	})));
+}));
+const createBitcoinProviderSideEffects = (config) => {
+	return [
+		registerBitcoinBlockchainNetworks,
+		registerBitcoinTestnetOptions(deriveBitcoinTestnetOptions(config)),
+		startBitcoinWallet(config.bitcoinProvider.historyDepth),
+		trackTip(config.bitcoinProvider.tipPollFrequency)
+	];
+};
+//#endregion
+Object.defineProperty(exports, "SyncStatus", {
+	enumerable: true,
+	get: function() {
+		return SyncStatus;
+	}
+});
+Object.defineProperty(exports, "bitcoinAccountWallets$", {
+	enumerable: true,
+	get: function() {
+		return bitcoinAccountWallets$;
+	}
+});
+Object.defineProperty(exports, "bitcoinContextActions", {
+	enumerable: true,
+	get: function() {
+		return bitcoinContextActions;
+	}
+});
+Object.defineProperty(exports, "bitcoinContextReducers", {
+	enumerable: true,
+	get: function() {
+		return bitcoinContextReducers;
+	}
+});
+Object.defineProperty(exports, "bitcoinContextSelectors", {
+	enumerable: true,
+	get: function() {
+		return bitcoinContextSelectors;
+	}
+});
+Object.defineProperty(exports, "createBitcoinProviderSideEffects", {
+	enumerable: true,
+	get: function() {
+		return createBitcoinProviderSideEffects;
+	}
+});