@laceio/sdk 0.1.1 → 0.1.2-canary.1

package/dist/{init-C-jErzp5.cjs → init-BopV9ed4.cjs}

@@ -1,6 +1,6 @@
 require("./rolldown-runtime-Br2OG8yv.cjs");
-const require_toEmpty = require("./toEmpty-DAMmNB5r.cjs");
-const require_actions = require("./actions-DdGbj7c7.cjs");
+const require_toEmpty = require("./toEmpty-CYAbupM4.cjs");
+const require_actions = require("./actions-B2BJ4RTy.cjs");
 let rxjs = require("rxjs");
 let _reduxjs_toolkit = require("@reduxjs/toolkit");
 //#region ../../packages/module/feature-dev/src/store/dependencies.ts

package/dist/init-BpHTq2R5.js

@@ -0,0 +1,105 @@
+import { v as TEMENOS_PROOF_SERVER_MODES } from "./const-D0CbQlo4.js";
+import { r as midnightContextReducers, t as initialState } from "./slice-oWnc7YVD.js";
+import { createMigrate } from "redux-persist";
+//#region ../../packages/contract/midnight-context/src/store/side-effects.ts
+const initializeSideEffects = () => [];
+//#endregion
+//#region ../../packages/contract/midnight-context/src/store/init.ts
+const store = async (props) => ({
+	sideEffects: initializeSideEffects(),
+	reducers: midnightContextReducers,
+	preloadedState: { midnightContext: {
+		...initialState,
+		supportsWasmProver: props.runtime.app === "lace-extension",
+		defaultTestNetNetworkId: props.runtime.config.defaultMidnightTestnetNetworkId
+	} },
+	persistConfig: { midnightContext: {
+		version: 14,
+		whitelist: [
+			"userNetworksConfigOverrides",
+			"proofServerDisclosureAcknowledgements",
+			"isActivityPageHeaderBannerDismissed",
+			"isPortfolioBannerDismissed",
+			"dustBalanceByAccount",
+			"dustGenerationDetailsByAccount"
+		],
+		migrate: createMigrate({
+			3: (state) => {
+				const typedState = state;
+				delete typedState.networkId;
+				return typedState;
+			},
+			4: (state) => {
+				return state;
+			},
+			5: (state) => {
+				const typedState = state;
+				delete typedState.dustParameters;
+				return typedState;
+			},
+			6: (state) => {
+				return state;
+			},
+			7: (state) => {
+				const typedState = state;
+				delete typedState.dustBalance;
+				delete typedState.dustGenerationDetails;
+				typedState.dustBalanceByAccount = {};
+				typedState.dustGenerationDetailsByAccount = {};
+				return typedState;
+			},
+			8: (state) => {
+				const typedState = state;
+				delete typedState.featureFlagsNetworksConfigOverrides;
+				return typedState;
+			},
+			9: (state) => {
+				const typedState = state;
+				typedState.publicKeysByAccount = {};
+				return typedState;
+			},
+			10: (state) => {
+				const typedState = state;
+				const overrides = typedState.userNetworksConfigOverrides;
+				for (const networkId in overrides) {
+					const networkOverrides = overrides[networkId];
+					if (!networkOverrides) continue;
+					delete networkOverrides.nodeAddress;
+					delete networkOverrides.indexerAddress;
+				}
+				return typedState;
+			},
+			11: (state) => {
+				const typedState = state;
+				delete typedState.shouldAcknowledgeMidnightDisclaimer;
+				return typedState;
+			},
+			12: (state) => {
+				const typedState = state;
+				const userOverrides = typedState.userNetworksConfigOverrides;
+				if (userOverrides) for (const networkId in userOverrides) {
+					const override = userOverrides[networkId];
+					if (override) delete override.proofServerAddress;
+				}
+				return typedState;
+			},
+			13: (state) => {
+				const typedState = state;
+				for (const override of Object.values(typedState.userNetworksConfigOverrides ?? {})) if (override) delete override.proofServerAddress;
+				return typedState;
+			},
+			14: (state) => {
+				const typedState = state;
+				for (const networkId of ["mainnet", "preview"]) {
+					const override = typedState.userNetworksConfigOverrides?.[networkId];
+					const previousMode = override?.proofServer;
+					const mode = TEMENOS_PROOF_SERVER_MODES[networkId];
+					if (override && mode && previousMode?.kind === "tee-delegated" && previousMode.url === "https://api.proofserver.wastedp.io") override.proofServer = { ...mode };
+				}
+				return typedState;
+			}
+		})
+	} }
+});
+//#endregion
+export { store as default };

package/dist/init-BpSITBfF.js

@@ -0,0 +1,39 @@
+import { g as CardanoPaymentAddress } from "./util-Cp5cZkfK.js";
+import { t as BigNumber } from "./bignum.vo-CEXOIew0.js";
+import { t as isCardanoCustodyAccount } from "./account-BOQruszJ.js";
+import { t as toAccountTokens } from "./account-tokens-DvkOFVON.js";
+import { coalesceValueQuantities } from "@laceio/cardano/core";
+import { combineLatest, distinct, distinctUntilChanged, map, mergeAll, mergeMap } from "rxjs";
+//#region ../../packages/contract/cardano-context/src/custody/store/track-custody-account-tokens.ts
+/**
+* A custody account holds what its owner can spend through Lace while it is
+* live: plain funds without a reference script, own reserves and withdrawable
+* rewards. No Lace builder spends a plain fund carrying a reference script or
+* a foreign reserve, the control UTxO's lovelace is the state's minimum and
+* the owner's fee reserve, grant UTxOs hold lovelace only a sweep frees,
+* stranded deposits cannot be spent, and account tokens are no holding, so
+* none of them reaches the tokens store.
+*
+* The rewards come from the balance view of the reward details: a pending
+* withdrawal's rewards already sit in its outputs, which the classification
+* reads in flight, so they must not count a second time. The classified
+* state itself keeps the raw amount the chain reports.
+*/
+const computeCustodyAccountTokens = (account) => (_, { cardanoCustody: { selectCardanoCustodyAccountState$ }, cardanoContext: { selectRewardAccountDetailsWithInFlight$ } }, { actions }) => combineLatest([selectCardanoCustodyAccountState$.pipe(map((selectAccountState) => selectAccountState(account.accountId))), selectRewardAccountDetailsWithInFlight$.pipe(map((details) => details[account.accountId]?.rewardAccountInfo.withdrawableAmount))]).pipe(distinctUntilChanged(([previousState, previousRewards], [state, rewards]) => previousState === state && previousRewards === rewards), map(([accountState, inFlightRewards]) => actions.tokens.setAccountTokens({
+	blockchainName: "Cardano",
+	accountId: account.accountId,
+	byAddress: accountState?.status === "live" ? [{
+		address: CardanoPaymentAddress(account.blockchainSpecific.address),
+		tokens: toAccountTokens(coalesceValueQuantities([...accountState.funds.filter(([, txOut]) => txOut.scriptReference === void 0), ...accountState.reserves.own].map(([, txOut]) => txOut.value)), inFlightRewards === void 0 ? accountState.withdrawableRewards : BigNumber.valueOf(inFlightRewards))
+	}] : []
+})));
+/**
+* Tracks the tokens of every active custody account, which the Cardano
+* context's own token tracking leaves to this store.
+*/
+const trackCustodyAccountTokens = (actionObservables, stateObservables, dependencies) => stateObservables.cardanoContext.selectActiveCardanoAccounts$.pipe(mergeAll(), distinct((account) => account.accountId), mergeMap((account) => isCardanoCustodyAccount(account) ? computeCustodyAccountTokens(account)(actionObservables, stateObservables, dependencies) : []));
+//#endregion
+//#region ../../packages/contract/cardano-context/src/custody/store/init.ts
+const init = () => ({ sideEffects: [trackCustodyAccountTokens] });
+//#endregion
+export { init as default };

package/dist/{init-DX4WyB0R.cjs → init-BrdVzxei.cjs}

@@ -1,7 +1,7 @@
 require("./rolldown-runtime-Br2OG8yv.cjs");
-const require_esm_browser = require("./esm-browser-DTc9IK3D.cjs");
-const require_slice = require("./slice-Do2R2CYW.cjs");
-const require_first_state_of_status = require("./first-state-of-status-OROkXcRv.cjs");
+const require_esm_browser = require("./esm-browser-bweqfBlL.cjs");
+const require_slice = require("./slice-C9TT5KhY.cjs");
+const require_first_state_of_status = require("./first-state-of-status-CbT7hPa4.cjs");
 let rxjs = require("rxjs");
 let redux_persist = require("redux-persist");
 //#region ../../packages/contract/tokens/src/store/side-effects.ts

package/dist/{init-LfyMo-sS.cjs → init-BwkU0ruo.cjs}

@@ -1,6 +1,6 @@
 require("./rolldown-runtime-Br2OG8yv.cjs");
-const require_key_value_store = require("./key-value-store-DUAepXQf.cjs");
-const require_serializable = require("./serializable-CRdnFaLZ.cjs");
+const require_key_value_store = require("./key-value-store-C2Xt5Emp.cjs");
+const require_serializable = require("./serializable-BxHkoPdk.cjs");
 //#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-CB__aLD7.cjs → init-C-G32J12.cjs}

@@ -1,6 +1,6 @@
 require("./rolldown-runtime-Br2OG8yv.cjs");
-const require_slice = require("./slice-DtaO72qY.cjs");
-const require_const = require("./const-BY8B3_0_.cjs");
+const require_slice = require("./slice-Bs2aMERu.cjs");
+const require_const = require("./const-iwzZEE_w.cjs");
 let _laceio_cardano_util = require("@laceio/cardano/util");
 let rxjs = require("rxjs");
 let redux_persist = require("redux-persist");

package/dist/init-C00gw1zi.js

@@ -0,0 +1,422 @@
+import { a as __toESM } from "./rolldown-runtime-OvD0k9op.js";
+import { n as Ok, t as Err } from "./asyncoption-CruEYOBI.js";
+import { n as retryBackoff, t as PROVIDER_REQUEST_RETRY_CONFIG } from "./retry-config-Dmgt28wM.js";
+import { a as isNotFoundError, o as toProviderError } from "./error-DIZOY2Lw.js";
+import { n as buildUrl, t as HttpClient } from "./http-client-TRlhDZGh.js";
+import { t as require_lib } from "./lib--iqvW4O_.js";
+import { t as BitcoinTransactionStatus } from "./bitcoin-data-provider-BYPSmuZS.js";
+import { ProviderError, ProviderFailure } from "@laceio/cardano/core";
+import { contextLogger } from "@laceio/cardano/util";
+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-TkPq_Ny_.js → init-C2RgrfZe.js}

@@ -1,4 +1,4 @@
-import { n as v4, t as init_esm_browser } from "./esm-browser-C93Q-EOI.js";
+import { n as v4, t as init_esm_browser } from "./esm-browser-MG97cre9.js";
 import { EMPTY, catchError, debounceTime, exhaustMap, filter, ignoreElements, map, merge, of, switchMap, take } from "rxjs";
 //#region ../../packages/contract/app/src/store/side-effects.ts
 init_esm_browser();