@laceio/sdk 0.1.0 → 0.1.1-canary.0

package/dist/init-BUpFzYsD.cjs

@@ -0,0 +1,143 @@
+require("./chunk-9hOWP6kD.cjs");
+const require_blockchain_network_id_vo = require("./blockchain-network-id.vo-DEQ14dYj.cjs");
+const require_repo_slice = require("./repo-slice-BB_W-6OL.cjs");
+const require_account_id_vo = require("./account-id.vo-DYZBZQsz.cjs");
+let redux_persist = require("redux-persist");
+//#region ../../packages/lib/util-hw/src/device-identity.ts
+const LEDGER_USB_VENDOR_ID = 11415;
+/**
+* Stable USB product identity. Ledger encodes the model in the high byte and
+* app/firmware-dependent interface flags in the low byte, so the same device
+* can report different productIds across firmware updates or open apps.
+* Masks the flag bits for Ledger (mirrors `@ledgerhq/devices`, which resolves
+* models via `productId >> 8`); other vendors keep the full productId.
+*/
+const canonicalUsbProductId = (vendorId, productId) => vendorId === LEDGER_USB_VENDOR_ID ? productId & 65280 : productId;
+//#endregion
+//#region ../../packages/contract/wallet-repo/src/value-objects/hardware-wallet-id.vo.ts
+const USB_HW_PATTERN = /^usb-hw-(\d+)-(\d+)-(.+)$/;
+const BLE_HW_PATTERN = /^ble-(ledger|trezor)-(.+)$/;
+const USB_NO_SERIAL_SENTINEL = "no-serial";
+/**
+* The wallet ID of the hardware device a descriptor describes.
+* `HardwareWalletId.parse` reads the descriptor back from a wallet ID, or
+* returns `null` for an ID of another form.
+*/
+const HardwareWalletId = (descriptor) => {
+	switch (descriptor.kind) {
+		case "usb": return `usb-hw-${descriptor.vendorId}-${canonicalUsbProductId(descriptor.vendorId, descriptor.productId)}-${descriptor.serialNumber ?? USB_NO_SERIAL_SENTINEL}`;
+		case "ble": return `ble-${descriptor.vendorName}-${descriptor.id}`;
+	}
+};
+HardwareWalletId.parse = (walletId) => {
+	const usbMatch = USB_HW_PATTERN.exec(walletId);
+	if (usbMatch) {
+		const serialSegment = usbMatch[3];
+		return {
+			kind: "usb",
+			vendorId: Number(usbMatch[1]),
+			productId: Number(usbMatch[2]),
+			serialNumber: serialSegment === USB_NO_SERIAL_SENTINEL ? null : serialSegment
+		};
+	}
+	const bleMatch = BLE_HW_PATTERN.exec(walletId);
+	if (bleMatch) return {
+		kind: "ble",
+		vendorName: bleMatch[1],
+		id: bleMatch[2],
+		name: null
+	};
+	return null;
+};
+//#endregion
+//#region ../../packages/contract/wallet-repo/src/migrations/3-set-blockchain-network-id.ts
+const migrateBlockchainNetworkId = (blockchainName) => {
+	switch (blockchainName) {
+		case "Cardano": return require_blockchain_network_id_vo.BlockchainNetworkId("cardano-1");
+		case "Midnight": return require_blockchain_network_id_vo.BlockchainNetworkId("midnight-preview");
+		case "Bitcoin": return require_blockchain_network_id_vo.BlockchainNetworkId("bitcoin-testnet4");
+	}
+};
+const setBlockchainNetworkId = (state) => {
+	const typedState = state;
+	if (!typedState.entities) return typedState;
+	for (const wallet of Object.values(typedState.entities)) for (const account of wallet.accounts) account.blockchainNetworkId = migrateBlockchainNetworkId(account.blockchainName);
+	return typedState;
+};
+//#endregion
+//#region ../../packages/contract/wallet-repo/src/migrations/4-update-midnight-account-ids.ts
+const updateMidnightAccountIds = (state) => {
+	const typedState = state;
+	if (!typedState.entities) return typedState;
+	for (const wallet of Object.values(typedState.entities)) for (const account of wallet.accounts) if (account.blockchainName === "Midnight") {
+		const networkId = account.blockchainSpecific.networkId;
+		account.accountId = require_account_id_vo.AccountId(`${wallet.walletId}-mn-0-${networkId}`);
+	}
+	if (typedState.activeAccountContext?.accountId.endsWith("-mn")) typedState.activeAccountContext = null;
+	return typedState;
+};
+//#endregion
+//#region ../../packages/contract/wallet-repo/src/migrations/5-normalize-hardware-wallet-ids.ts
+/**
+* Rewrites hardware wallet ids to the canonical descriptor encoding (Ledger
+* USB productIds carry app/firmware-dependent interface bits that are now
+* masked at id construction) and merges wallet entities that collapse into
+* the same id, so devices that were duplicated by a productId drift become a
+* single wallet again. Account ids embed the wallet id as their prefix, so
+* they are rewritten along with the walletId fields.
+*/
+const normalizeHardwareWalletIds = (state) => {
+	const typedState = state;
+	if (!typedState.entities) return typedState;
+	const renames = /* @__PURE__ */ new Map();
+	for (const oldId of Object.keys(typedState.entities)) {
+		const descriptor = HardwareWalletId.parse(oldId);
+		if (!descriptor) continue;
+		const newId = HardwareWalletId(descriptor);
+		if (newId === oldId) continue;
+		renames.set(oldId, newId);
+		const wallet = typedState.entities[oldId];
+		for (const account of wallet.accounts) {
+			account.walletId = newId;
+			account.accountId = require_account_id_vo.AccountId(account.accountId.replace(oldId, newId));
+		}
+		const target = typedState.entities[newId];
+		typedState.entities[newId] = target ? {
+			...target,
+			accounts: [...target.accounts, ...wallet.accounts.filter((account) => target.accounts.every((existing) => existing.accountId !== account.accountId))]
+		} : {
+			...wallet,
+			walletId: newId
+		};
+		delete typedState.entities[oldId];
+		if (typedState.activeAccountContext?.walletId === oldId) typedState.activeAccountContext = {
+			walletId: newId,
+			accountId: require_account_id_vo.AccountId(typedState.activeAccountContext.accountId.replace(oldId, newId))
+		};
+	}
+	if (renames.size > 0) typedState.ids = [...new Set(typedState.ids.map((id) => renames.get(id) ?? id))];
+	return typedState;
+};
+//#endregion
+//#region ../../packages/contract/wallet-repo/src/store/persisted-migrations.ts
+/** The migrations of the persisted `wallets` state, by the version they reach. */
+const walletsMigrations = {
+	3: setBlockchainNetworkId,
+	4: updateMidnightAccountIds,
+	5: normalizeHardwareWalletIds
+};
+//#endregion
+//#region ../../packages/contract/wallet-repo/src/store/init.ts
+const walletsReducers = { wallets: require_repo_slice.repositorySlice.reducer };
+const storeExports = async () => {
+	return {
+		reducers: walletsReducers,
+		persistConfig: { wallets: {
+			version: 5,
+			migrate: (0, redux_persist.createMigrate)(walletsMigrations)
+		} }
+	};
+};
+//#endregion
+exports.default = storeExports;
+exports.walletsReducers = walletsReducers;

package/dist/{init-BvpYHyLH.cjs → init-BZ-WyAIL.cjs}

@@ -1,8 +1,8 @@
 require("./chunk-9hOWP6kD.cjs");
 const require_equals = require("./equals-3gajbRxE.cjs");
-const require_isNotNil = require("./isNotNil-C_SO1tcC.cjs");
-const require_slice = require("./slice-CtIMw2YT.cjs");
-const require_const = require("./const-BErUlcZw.cjs");
+const require_isNotNil = require("./isNotNil-CrYIUFry.cjs");
+const require_slice = require("./slice-B9QKuhi0.cjs");
+const require_const = require("./const-BWBAzOmN.cjs");
 let rxjs = require("rxjs");
 let redux_persist = require("redux-persist");
 //#region ../../packages/contract/network/src/store/migrations/2-reset-testnets.ts

package/dist/init-BZdfdLX7.js

@@ -0,0 +1,422 @@
+import { a as __toESM } from "./chunk-D6g4UhsZ.js";
+import { n as ProviderError, r as ProviderFailure } from "./errors-CAOTqN4_.js";
+import { t as contextLogger } from "./logging-BAMMfn5j.js";
+import { n as Ok, t as Err } from "./asyncoption-DZQGfznq.js";
+import { n as retryBackoff, t as PROVIDER_REQUEST_RETRY_CONFIG } from "./retry-config-Bu5Yn5ua.js";
+import { i as toProviderError, r as isNotFoundError } from "./error-CvEYL98P.js";
+import { n as buildUrl, t as HttpClient } from "./http-client-B7_kBTYn.js";
+import { t as require_lib } from "./lib-JYqcAX0c.js";
+import { t as BitcoinTransactionStatus } from "./bitcoin-data-provider-LN_8oamW.js";
+import { defer, from, of } from "rxjs";
+import memoize from "lodash/memoize.js";
+import { catchError as catchError$1, map as map$1 } from "rxjs/operators";
+//#region ../../packages/lib/bitcoin-provider-core/src/maestro/util.ts
+const SATS_IN_BTC = 1e8;
+/**
+* Converts a Bitcoin amount expressed as a decimal string (I.E `"0.00012345"`)
+* into its integer value in satoshis.
+*
+* @param btcString - Bitcoin amount as a string (e.g. `"2"`, `"0.5"`, `"0.00000001"`).
+* @returns Amount in satoshis as a number.
+*/
+const btcStringToSatoshis = (btcString) => {
+	const [integerPart, fractionPart = ""] = btcString.split(".");
+	const paddedFraction = fractionPart.padEnd(8, "0").slice(0, 8);
+	return Number(integerPart) * SATS_IN_BTC + Number(paddedFraction);
+};
+/**
+* Return the OP_RETURN payload (as hex) if the output is nulldata,
+* otherwise undefined.
+*/
+const getOpReturnData = (output) => {
+	const asm = output.scriptPubKey?.asm;
+	if (!asm) return void 0;
+	if (!(output.scriptPubKey?.type === "nulldata" || asm.startsWith("OP_RETURN"))) return void 0;
+	const [, hexPayload] = asm.split(/\s+/);
+	return hexPayload ?? void 0;
+};
+//#endregion
+//#region ../../packages/lib/bitcoin-provider-core/src/maestro/maestro-provider.ts
+/**
+* High-level REST wrapper around Maestro's Bitcoin API.
+*/
+var MaestroBitcoinProvider = class {
+	logger;
+	#client;
+	#txCache = /* @__PURE__ */ new Map();
+	#rawTxCache = /* @__PURE__ */ new Map();
+	/**
+	* Creates a new instance of the Maestro Bitcoin provider.
+	*
+	* @param client - Pre-configured HTTP client.
+	* @param logger - Any ts-log compatible logger implementation.
+	*/
+	constructor(client, logger) {
+		this.#client = client;
+		this.logger = contextLogger(logger, this.constructor.name);
+	}
+	/**
+	* Fetches the current block height and hash.
+	*
+	* @returns A promise that resolves with the current blockchain information.
+	*/
+	async getLastKnownBlock() {
+		const { data: { last_updated: { block_height, block_hash } } } = await this.request("/rpc/general/info");
+		return {
+			height: Number(block_height),
+			hash: block_hash
+		};
+	}
+	/**
+	* Retrieves detailed information about a specific blockchain transaction by its hash.
+	*
+	* @param txHash - The hash of the transaction to retrieve. This is typically a unique identifier
+	* in hexadecimal format.
+	* @returns A promise that resolves to a `TransactionHistoryEntry`.
+	*
+	* @throws `Error` Throws an error if the transaction cannot be retrieved, which might occur due to network issues,
+	* incorrect transaction hash, or the transaction not existing in the blockchain.
+	*/
+	async getTransaction(txHash) {
+		if (this.#txCache.has(txHash)) return this.#txCache.get(txHash);
+		const { data: { data } } = await this.request(`/rpc/transaction/${txHash}`, { params: { verbose: true } });
+		const entry = this.mapTxEntry(txHash, data);
+		if (entry.confirmations > 0) this.#txCache.set(txHash, entry);
+		return entry;
+	}
+	/**
+	* Fetches the raw serialized transaction (hex) for a given transaction hash.
+	*
+	* Raw bytes of confirmed transactions are immutable, so they are cached
+	* indefinitely; unconfirmed transactions are re-fetched on every call.
+	*
+	* @param txHash - The hash of the transaction to retrieve, in hexadecimal format.
+	* @returns A promise that resolves to the raw transaction hex.
+	*
+	* @throws `Error` Throws an error if the transaction cannot be retrieved, which might occur due to network issues,
+	* incorrect transaction hash, or the transaction not existing in the blockchain.
+	*/
+	async getRawTransaction(txHash) {
+		if (this.#rawTxCache.has(txHash)) return this.#rawTxCache.get(txHash);
+		const { data: { data } } = await this.request(`/rpc/transaction/${txHash}`, { params: { verbose: true } });
+		if (data.confirmations > 0) this.#rawTxCache.set(txHash, data.hex);
+		return data.hex;
+	}
+	/**
+	* Retrieve a **paginated**, (reverse-chronological by default) history of transactions
+	* that involve a given address.
+	*
+	* @param address - The Bitcoin address or script pubkey to query for transactions.
+	* @param parameters - Optional parameters to filter and paginate the transaction history.
+	*
+	* @returns `BitcoinPaginatedResponse` -
+	*          `{ items: TransactionHistoryEntry[]; cursor: string }`.
+	*/
+	async getTransactions(address, parameters) {
+		try {
+			const { data: { data: edges = [], next_cursor } } = await this.request(`/addresses/${address}/txs`, { params: {
+				order: "desc",
+				count: 50,
+				...parameters
+			} });
+			const transactions = [];
+			for (const { tx_hash } of edges) transactions.push(await this.getTransaction(tx_hash));
+			return {
+				items: transactions,
+				cursor: next_cursor ?? ""
+			};
+		} catch (error) {
+			if (isNotFoundError(error)) return {
+				items: [],
+				cursor: ""
+			};
+			throw error;
+		}
+	}
+	/**
+	* Retrieves unconfirmed transactions (as transaction history entries) from the mempool for a given Bitcoin address.
+	*
+	* This function queries pending transactions associated with the specified Bitcoin address.
+	* It returns an array of transaction history entries representing UTXOs that are currently unconfirmed.
+	* Optionally, you can filter transactions to only include those observed after a specified block height.
+	*
+	* @param address - The Bitcoin address or script pubkey to query for pending transactions.
+	* @param parameters - Optional parameters to filter and paginate the transaction history.
+	* @returns `BitcoinPaginatedResponse` -
+	*          `{ items: TransactionHistoryEntry[]; cursor: string }`.
+	*/
+	async getTransactionsInMempool(address, parameters) {
+		try {
+			const { data: { data: utxos = [], next_cursor } } = await this.request(`/mempool/addresses/${address}/utxos`, { params: {
+				order: "desc",
+				...parameters
+			} });
+			if (utxos.length === 0) return {
+				items: [],
+				cursor: ""
+			};
+			const seen = /* @__PURE__ */ new Set();
+			const pendingPromises = [];
+			for (const { txid, mempool: isInMempool } of utxos) {
+				if (seen.has(txid) || !isInMempool) continue;
+				seen.add(txid);
+				pendingPromises.push(this.mapTxToPendingEntry(txid));
+			}
+			return {
+				items: await Promise.all(pendingPromises),
+				cursor: next_cursor ?? ""
+			};
+		} catch (error) {
+			if (isNotFoundError(error)) return {
+				items: [],
+				cursor: ""
+			};
+			throw error;
+		}
+	}
+	/**
+	* Fetches the unspent transaction outputs (UTxOs) associated with a specified address.
+	*
+	* @returns A promise that resolves with a list of UTxOs for the address.
+	*/
+	async getUTxOs(address, parameters) {
+		try {
+			const { data: { data: utxos = [], next_cursor } } = await this.request(`/addresses/${address}/utxos`, { params: { ...parameters } });
+			return {
+				items: utxos.map((out) => ({
+					txId: out.txid,
+					index: out.vout,
+					satoshis: Number.parseInt(out.satoshis, 10),
+					address: out.address,
+					script: out.script_pubkey,
+					height: out.height,
+					confirmations: out.confirmations,
+					inscriptions: out.inscriptions.map((inscription) => ({
+						offset: inscription.offset,
+						inscriptionId: inscription.inscription_id
+					})),
+					runes: out.runes.map((rune) => ({
+						runeId: rune.rune_id,
+						amount: rune.amount
+					}))
+				})),
+				cursor: next_cursor ?? ""
+			};
+		} catch (error) {
+			if (isNotFoundError(error)) return {
+				items: [],
+				cursor: ""
+			};
+			throw error;
+		}
+	}
+	/**
+	* Submits a raw transaction to the blockchain for inclusion in a block.
+	*
+	* @returns A promise that resolves with the transaction hash of the submitted transaction.
+	*/
+	async submitTransaction(rawTransaction) {
+		const { data, status } = await this.request("/rpc/transaction/submit", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(rawTransaction)
+		});
+		if (status !== 201) throw new ProviderError(ProviderFailure.InvalidResponse, `Unexpected response status: ${status} - ${JSON.stringify(data)}`);
+		return data;
+	}
+	/**
+	* Fetches the status of a specified transaction by its hash.
+	*
+	* @returns A promise that resolves with the current status of the transaction.
+	*/
+	async getTransactionStatus(txHash) {
+		try {
+			const { status } = await this.getTransaction(txHash);
+			return status;
+		} catch (error) {
+			if (isNotFoundError(error)) return BitcoinTransactionStatus.Dropped;
+			throw error;
+		}
+	}
+	/**
+	* Estimates the transaction fee in BTC per kilobyte based on the desired confirmation time and fee estimation mode.
+	*
+	* This method queries a blockchain fee estimation service to determine the appropriate fee
+	* rate required for a transaction to be confirmed within the specified number of blocks.
+	*
+	* @param blocks - The target number of blocks within which the transaction should be confirmed.
+	*                          A smaller number indicates a higher priority and typically results in a higher fee.
+	*                          For example, `blocks = 1` requests a fee estimation for the next block confirmation.
+	* @param mode - The fee estimation mode, which determines the trade-off between
+	*                                   reliability and cost:
+	*                                 - `FeeEstimationMode.Conservative`: Prioritizes confirmation reliability.
+	*                                 - `FeeEstimationMode.Economical`: Aims to minimize fees, with potentially slower confirmations.
+	* @returns A promise that resolves to the estimated fee in satoshis per byte.
+	*                            This value can be used to calculate the total transaction fee
+	*                            based on the size of the transaction in bytes.
+	*/
+	async estimateFee(blocks, mode) {
+		const { data: { data }, status } = await this.request(`/rpc/transaction/estimatefee/${blocks}`, { params: { mode } });
+		if (status !== 200) throw new ProviderError(ProviderFailure.InvalidResponse, "Invalid response from fee estimation API.");
+		return {
+			feeRate: data.feerate,
+			targetConfirmationTime: data.blocks
+		};
+	}
+	/**
+	* Transform a Maestro transaction record into the wallet's
+	* `TransactionHistoryEntry` format.
+	*
+	* @param txHash - The transaction hash.
+	* @param data - The data payload returned by `/rpc/transaction/{hash}`.
+	* @param overrides - Partial entry whose properties overwrite the derived base
+	*                   values (e.g. `{ status: Pending, confirmations: -1 }`).
+	*
+	* @returns A fully populated `TransactionHistoryEntry`.
+	*/
+	mapTxEntry(txHash, data, overrides = {}) {
+		return {
+			inputs: data.vin.map((vin) => ({
+				txId: vin.txid ?? "",
+				index: vin.vout ?? 0,
+				address: vin.address ?? "",
+				satoshis: btcStringToSatoshis(vin.value.toString()),
+				isCoinbase: !!vin.coinbase,
+				coinbaseScript: vin.coinbase ?? ""
+			})),
+			outputs: data.vout.map((vout) => ({
+				address: vout.address,
+				satoshis: btcStringToSatoshis(vout.value.toString()),
+				opReturnData: getOpReturnData(vout)
+			})),
+			transactionHash: txHash,
+			confirmations: data.confirmations,
+			status: data.confirmations > 0 ? BitcoinTransactionStatus.Confirmed : BitcoinTransactionStatus.Pending,
+			blockHeight: data.blockheight,
+			timestamp: data.blocktime,
+			...overrides
+		};
+	}
+	/**
+	* Maps a transaction hash to a pending transaction entry.
+	*
+	* @param txHash - The transaction hash to map.
+	*/
+	async mapTxToPendingEntry(txHash) {
+		const { data } = await this.request(`/rpc/transaction/${txHash}`, { params: { verbose: true } });
+		return this.mapTxEntry(txHash, data.data, {
+			confirmations: -1,
+			status: BitcoinTransactionStatus.Pending,
+			blockHeight: 0,
+			timestamp: Math.floor(Date.now() / 1e3)
+		});
+	}
+	/**
+	* Performs a generic HTTP request to the Maestro API.
+	*/
+	async request(endpoint, options) {
+		try {
+			this.logger.debug("request", endpoint);
+			const response = await this.#client.request(endpoint, options);
+			this.logger.debug("response", JSON.stringify(response));
+			return response;
+		} catch (error) {
+			this.logger.debug("error", error);
+			throw toProviderError(error);
+		}
+	}
+};
+//#endregion
+//#region ../../packages/lib/bitcoin-provider-core/src/maestro-config.ts
+var import_lib = /* @__PURE__ */ __toESM(require_lib());
+const computeMaestroConfigIdentifier = ({ clientConfig: { baseUrl, projectId } }) => `${baseUrl}-${projectId}`;
+const getMaestroClient = memoize(({ clientConfig, rateLimiterConfig }) => {
+	const rateLimiter = new import_lib.default({
+		reservoir: rateLimiterConfig.size,
+		reservoirIncreaseAmount: rateLimiterConfig.increaseAmount,
+		reservoirIncreaseInterval: rateLimiterConfig.increaseInterval,
+		reservoirIncreaseMaximum: rateLimiterConfig.size
+	});
+	return new HttpClient({
+		baseUrl: buildUrl([clientConfig.apiVersion], clientConfig.baseUrl),
+		requestInit: { headers: { "api-key": clientConfig.projectId ?? "" } }
+	}, { rateLimiter });
+}, computeMaestroConfigIdentifier);
+//#endregion
+//#region ../../packages/lib/bitcoin-provider-core/src/create-maestro-bitcoin-provider.ts
+const getMaestroApiProvider = memoize((config, logger) => {
+	return new MaestroBitcoinProvider(getMaestroClient(config), logger);
+}, computeMaestroConfigIdentifier);
+const getMaestroConfig = (context, configs) => configs[context.network];
+const unprovisionedNetworkError = (network) => new ProviderError(ProviderFailure.NotImplemented, void 0, `maestro is unprovisioned for network ${network}: no config entry in this build`);
+const createMaestroBitcoinProvider = (maestroConfig, logger) => ({
+	getLastKnownBlock: (context) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return of(Err(unprovisionedNetworkError(context.network)));
+		return from(getMaestroApiProvider(config, logger).getLastKnownBlock().then(Ok).catch(Err));
+	},
+	getTransaction: (context, txHash) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return of(Err(unprovisionedNetworkError(context.network)));
+		return from(getMaestroApiProvider(config, logger).getTransaction(txHash).then(Ok).catch(Err));
+	},
+	getRawTransaction: (context, txHash) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return of(Err(unprovisionedNetworkError(context.network)));
+		const provider = getMaestroApiProvider(config, logger);
+		return defer(async () => provider.getRawTransaction(txHash)).pipe(retryBackoff(PROVIDER_REQUEST_RETRY_CONFIG), map$1(Ok), catchError$1((error) => of(Err(error))));
+	},
+	getTransactions: (context, address, { afterBlockHeight, limit, order, cursor }) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return of(Err(unprovisionedNetworkError(context.network)));
+		return from(getMaestroApiProvider(config, logger).getTransactions(address, {
+			count: limit,
+			order,
+			cursor,
+			from: afterBlockHeight
+		}).then((result) => Ok(result)).catch(Err));
+	},
+	getTransactionsInMempool: (context, address, { afterBlockHeight, limit, order, cursor }) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return of(Err(unprovisionedNetworkError(context.network)));
+		return from(getMaestroApiProvider(config, logger).getTransactionsInMempool(address, {
+			count: limit,
+			order,
+			cursor,
+			from: afterBlockHeight
+		}).then((result) => Ok(result)).catch(Err));
+	},
+	getUTxOs: (context, address, { afterBlockHeight, limit, order, cursor }) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return of(Err(unprovisionedNetworkError(context.network)));
+		return from(getMaestroApiProvider(config, logger).getUTxOs(address, {
+			count: limit,
+			order,
+			cursor,
+			from: afterBlockHeight
+		}).then((result) => Ok(result)).catch(Err));
+	},
+	submitTransaction: (context, rawTransaction) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return of(Err(unprovisionedNetworkError(context.network)));
+		return from(getMaestroApiProvider(config, logger).submitTransaction(rawTransaction).then(Ok).catch(Err));
+	},
+	getTransactionStatus: (context, txHash) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return of(Err(unprovisionedNetworkError(context.network)));
+		return from(getMaestroApiProvider(config, logger).getTransactionStatus(txHash).then(Ok).catch(Err));
+	},
+	estimateFee: (context, blocks, mode) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return of(Err(unprovisionedNetworkError(context.network)));
+		return from(getMaestroApiProvider(config, logger).estimateFee(blocks, mode).then(Ok).catch(Err));
+	}
+});
+//#endregion
+//#region ../../packages/module/bitcoin-provider-maestro/src/store/dependencies.ts
+const initializeDependencies = async ({ runtime: { config: { bitcoinProvider: { maestroConfig } } } }, { logger }) => ({ bitcoinProvider: createMaestroBitcoinProvider(maestroConfig, logger) });
+//#endregion
+//#region ../../packages/module/bitcoin-provider-maestro/src/store/init.ts
+const redux = async (props, dependencies) => ({ sideEffectDependencies: await initializeDependencies(props, dependencies) });
+//#endregion
+export { redux as default };

package/dist/{init-CJeOys1w.cjs → init-B_HWNXMD.cjs}

@@ -1,6 +1,6 @@
 require("./chunk-9hOWP6kD.cjs");
-const require_is_redux_persist_state = require("./is-redux-persist-state-DxJSsvxB.cjs");
-const require_slice = require("./slice-BLSxLmie.cjs");
+const require_is_redux_persist_state = require("./is-redux-persist-state-C5luvPEH.cjs");
+const require_slice = require("./slice-Dongunf7.cjs");
 //#region ../../packages/contract/sync/src/store/init.ts
 /**
 * Transform that excludes pendingSync from being persisted.

package/dist/init-BbIMt6xU.cjs

@@ -0,0 +1,6 @@
+require("./chunk-9hOWP6kD.cjs");
+const require_slice = require("./slice-B4QOYaOG.cjs");
+//#region ../../packages/contract/passport/src/store/init.ts
+const store = () => ({ reducers: require_slice.passportReducers });
+//#endregion
+exports.default = store;

package/dist/{init-BYdN1aqE.cjs → init-BewG6swt.cjs}

@@ -1,6 +1,6 @@
 require("./chunk-9hOWP6kD.cjs");
-const require_blockchain_network_id_vo = require("./blockchain-network-id.vo-5iC6Kffo.cjs");
-const require_slice = require("./slice-BEFoeqgr.cjs");
+const require_blockchain_network_id_vo = require("./blockchain-network-id.vo-DEQ14dYj.cjs");
+const require_slice = require("./slice-BzJgg9FS.cjs");
 let redux_persist = require("redux-persist");
 //#region ../../packages/contract/address-book/src/store/init.ts
 const store = () => ({

package/dist/{init-BX0AZAVH2.js → init-Bilqsbng.js}

@@ -1,6 +1,6 @@
 import "./_polyfill-buffer-patch-JcrfT1gU.js";
-import { t as Serializable } from "./serializable-BxFUShKY.js";
-import { n as CollectionStore, r as DocumentStore, t as KeyValueStore } from "./key-value-store-DTX1quRS.js";
+import { t as Serializable } from "./serializable-F7OtYl8d.js";
+import { n as CollectionStore, r as DocumentStore, t as KeyValueStore } from "./key-value-store-DZcNDB3n.js";
 //#region ../../packages/module/storage-web-indexeddb/src/storage-api-adapter.ts
 const DB_NAME = "lace-storage";
 const OBJECT_STORE_NAME = "key-value";

package/dist/{init-Tpn9VkFu.cjs → init-BpwlQ6wF.cjs}

@@ -1,5 +1,5 @@
 require("./chunk-9hOWP6kD.cjs");
-const require_slice = require("./slice-jnpOgiSZ.cjs");
+const require_slice = require("./slice-CaMfviYu.cjs");
 //#region ../../packages/contract/addresses/src/store/init.ts
 const addressesStoreInit = () => ({
 	reducers: require_slice.addressesReducers,

package/dist/{init-D5-P0HXK.js → init-BtQOzUjX.js}

@@ -1,4 +1,4 @@
-import { n as addressesReducers } from "./slice-ws8PccRX.js";
+import { n as addressesReducers } from "./slice-Dn0WojD7.js";
 //#region ../../packages/contract/addresses/src/store/init.ts
 const addressesStoreInit = () => ({
 	reducers: addressesReducers,

package/dist/{init-BvGz3qUd2.js → init-CCTscPaY2.js}

@@ -1,5 +1,5 @@
-import { t as toEmpty } from "./toEmpty-DzLd-ZCi.js";
-import { t as setFeatureFlags } from "./actions-BWTyAr7B.js";
+import { t as toEmpty } from "./toEmpty-Djj-QbpI.js";
+import { t as setFeatureFlags } from "./actions-Cwj0ApZf.js";
 import { BehaviorSubject, filter, tap } from "rxjs";
 import { isAnyOf } from "@reduxjs/toolkit";
 //#region ../../packages/module/feature-dev/src/store/dependencies.ts

package/dist/{init-D4hPipCD.cjs → init-CH0yyBof.cjs}

@@ -1,5 +1,5 @@
 require("./chunk-9hOWP6kD.cjs");
-const require_esm_browser = require("./esm-browser-DnXNvpcn.cjs");
+const require_esm_browser = require("./esm-browser-CZbMeVod.cjs");
 let rxjs = require("rxjs");
 //#region ../../packages/contract/app/src/store/side-effects.ts
 require_esm_browser.init_esm_browser();