@laceio/sdk 0.1.1 → 0.1.2-canary.0

package/dist/init-D9g1HXYf.cjs

@@ -0,0 +1,40 @@
+require("./rolldown-runtime-Br2OG8yv.cjs");
+const require_util = require("./util-Bu4W5lF4.cjs");
+const require_bignum_vo = require("./bignum.vo-hx2kuqlA.cjs");
+const require_account = require("./account-BUOj4pYJ.cjs");
+const require_account_tokens = require("./account-tokens-nwcvwLu4.cjs");
+let _laceio_cardano_core = require("@laceio/cardano/core");
+let rxjs = require("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 }) => (0, rxjs.combineLatest)([selectCardanoCustodyAccountState$.pipe((0, rxjs.map)((selectAccountState) => selectAccountState(account.accountId))), selectRewardAccountDetailsWithInFlight$.pipe((0, rxjs.map)((details) => details[account.accountId]?.rewardAccountInfo.withdrawableAmount))]).pipe((0, rxjs.distinctUntilChanged)(([previousState, previousRewards], [state, rewards]) => previousState === state && previousRewards === rewards), (0, rxjs.map)(([accountState, inFlightRewards]) => actions.tokens.setAccountTokens({
+	blockchainName: "Cardano",
+	accountId: account.accountId,
+	byAddress: accountState?.status === "live" ? [{
+		address: require_util.CardanoPaymentAddress(account.blockchainSpecific.address),
+		tokens: require_account_tokens.toAccountTokens((0, _laceio_cardano_core.coalesceValueQuantities)([...accountState.funds.filter(([, txOut]) => txOut.scriptReference === void 0), ...accountState.reserves.own].map(([, txOut]) => txOut.value)), inFlightRewards === void 0 ? accountState.withdrawableRewards : require_bignum_vo.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((0, rxjs.mergeAll)(), (0, rxjs.distinct)((account) => account.accountId), (0, rxjs.mergeMap)((account) => require_account.isCardanoCustodyAccount(account) ? computeCustodyAccountTokens(account)(actionObservables, stateObservables, dependencies) : []));
+//#endregion
+//#region ../../packages/contract/cardano-context/src/custody/store/init.ts
+const init = () => ({ sideEffects: [trackCustodyAccountTokens] });
+//#endregion
+exports.default = init;

package/dist/{init-CNLGJJRx.js → init-DA7zmptx.js}

@@ -1,4 +1,4 @@
-import { n as failuresReducers } from "./slice-CobanYgn.js";
+import { n as failuresReducers } from "./slice-CwyYrh1H.js";
 import { distinctUntilChanged, map } from "rxjs";
 //#region ../../packages/contract/failures/src/utils/parse-failure-id.ts
 const KNOWN_BLOCKCHAINS = new Set([

package/dist/{init-DkIc5nqF.cjs → init-DFMiP2ZH.cjs}

@@ -1,5 +1,5 @@
 require("./rolldown-runtime-Br2OG8yv.cjs");
-const require_composite_signer_factory = require("./composite-signer-factory-BpF1mIYA.cjs");
+const require_composite_signer_factory = require("./composite-signer-factory-m5cVs9h_.cjs");
 //#region ../../packages/contract/signer/src/store/dependencies.ts
 const initializeSignerSideEffectDependencies = async ({ loadModules }) => {
 	return { signerFactory: new require_composite_signer_factory.CompositeSignerFactory(await loadModules("addons.loadSignerFactory")) };

package/dist/{init-zSzCjoor.js → init-DFjT8YvT.js}

@@ -1,7 +1,7 @@
-import { n as retryBackoff, t as PROVIDER_REQUEST_RETRY_CONFIG } from "./retry-config-BcUmMS--.js";
-import { t as whileActive } from "./while-active-BpppWuCs.js";
-import { c as POLLING_INTERVAL_MS, i as shouldFetchPriceHistory, l as SUPPORTED_CURRENCIES_FEATURE_FLAG, o as DEFAULT_CURRENCY_PREFERENCE, r as shouldFetchPrice, u as TOKEN_PRICING_NETWORK_TYPE } from "./utils-o8aMjfln.js";
-import { r as tokenPricingReducers } from "./slice-zJ9XVYjZ.js";
+import { n as retryBackoff, t as PROVIDER_REQUEST_RETRY_CONFIG } from "./retry-config-Dmgt28wM.js";
+import { t as whileActive } from "./while-active-B0lWy_6l.js";
+import { d as TOKEN_PRICING_NETWORK_TYPE, i as shouldFetchPriceHistory, l as POLLING_INTERVAL_MS, r as shouldFetchPrice, s as DEFAULT_CURRENCY_PREFERENCE, u as SUPPORTED_CURRENCIES_FEATURE_FLAG } from "./utils-BfBEUvWA.js";
+import { r as tokenPricingReducers } from "./slice-Da426sf9.js";
 import { EMPTY, catchError, concat, distinctUntilChanged, exhaustMap, filter, interval, map, merge, of, startWith, switchMap, withLatestFrom } from "rxjs";
 import { createMigrate } from "redux-persist";
 //#region ../../packages/lib/util-store/src/by-blockchain-name.ts

package/dist/init-DGjXwWs2.cjs

@@ -0,0 +1,143 @@
+require("./rolldown-runtime-Br2OG8yv.cjs");
+const require_blockchain_network_id_vo = require("./blockchain-network-id.vo-BAKEwGjG.cjs");
+const require_repo_slice = require("./repo-slice-7X4AYYVm.cjs");
+const require_account_id_vo = require("./account-id.vo-DwqFjK5u.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-DHrCbpkW.cjs

@@ -0,0 +1,121 @@
+const require_rolldown_runtime = require("./rolldown-runtime-Br2OG8yv.cjs");
+const require_asyncoption = require("./asyncoption-i0VbqVTq.cjs");
+const require_error = require("./error-Cb3EnD0u.cjs");
+const require_http_client = require("./http-client-B3N-TMxu.cjs");
+const require_types = require("./types-CLRUYpfe.cjs");
+let _laceio_cardano_util = require("@laceio/cardano/util");
+let rxjs = require("rxjs");
+let lodash_memoize = require("lodash/memoize.js");
+lodash_memoize = require_rolldown_runtime.__toESM(lodash_memoize);
+//#region ../../packages/module/bitcoin-mempool-fee-market/src/mempool/mempool-fee-market-provider.ts
+const MIN_FEE_RATE = 11e-6;
+const DEFAULT_MARKETS = {
+	fast: {
+		feeRate: 25e-6,
+		targetConfirmationTime: 1
+	},
+	standard: {
+		feeRate: 15e-6,
+		targetConfirmationTime: 3
+	},
+	slow: {
+		feeRate: 11e-6,
+		targetConfirmationTime: 6
+	}
+};
+/**
+* Converts a fee rate in satoshis per vbyte to BTC per kilobyte.
+* @param satsPerVByte - The fee rate in satoshis per vbyte.
+*/
+const satsPerVByteToBtcPerKB = (satsPerVByte) => satsPerVByte * 1e3 / 1e8;
+/**
+* High-level REST wrapper around Mempool.space's Bitcoin feemarket API API.
+*/
+var MempoolFeeMarketProvider = class {
+	logger;
+	#client;
+	/**
+	* Creates a new instance of the Mempool FeeMarket provider.
+	*
+	* @param client - Pre-configured HTTP client.
+	* @param logger - Any ts-log compatible logger implementation.
+	*/
+	constructor(client, logger) {
+		this.#client = client;
+		this.logger = (0, _laceio_cardano_util.contextLogger)(logger, this.constructor.name);
+	}
+	/**
+	* 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.
+	*
+	* @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 getFeeMarket(network) {
+		try {
+			if (network === require_types.BitcoinNetwork.Testnet) return DEFAULT_MARKETS;
+			const feeData = await this.request("/api/v1/fees/recommended");
+			const fastEstimate = feeData.fastestFee;
+			const standardEstimate = feeData.halfHourFee;
+			const slowEstimate = feeData.hourFee;
+			return {
+				fast: {
+					feeRate: Math.max(satsPerVByteToBtcPerKB(fastEstimate), MIN_FEE_RATE),
+					targetConfirmationTime: 600
+				},
+				standard: {
+					feeRate: Math.max(satsPerVByteToBtcPerKB(standardEstimate), MIN_FEE_RATE),
+					targetConfirmationTime: 1800
+				},
+				slow: {
+					feeRate: Math.max(satsPerVByteToBtcPerKB(slowEstimate), MIN_FEE_RATE),
+					targetConfirmationTime: 3600
+				}
+			};
+		} catch (error) {
+			this.logger.error("Failed to fetch fee market:", error);
+		}
+		return DEFAULT_MARKETS;
+	}
+	/**
+	* Performs a generic HTTP request to the Mempool.space 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.data;
+		} catch (error) {
+			this.logger.debug("error", error);
+			throw require_error.toProviderError(error);
+		}
+	}
+};
+//#endregion
+//#region ../../packages/module/bitcoin-mempool-fee-market/src/store/dependencies.ts
+const computeMaestroConfigIdentifier = ({ url }) => `${url}`;
+const getMempoolSpaceClient = (0, lodash_memoize.default)(({ url }) => {
+	return new require_http_client.HttpClient({ baseUrl: url });
+}, computeMaestroConfigIdentifier);
+const getMempoolSpaceApiProvider = (0, lodash_memoize.default)((config, logger) => {
+	return new MempoolFeeMarketProvider(getMempoolSpaceClient(config), logger);
+}, computeMaestroConfigIdentifier);
+const getMempoolSpaceConfig = (context, configs) => {
+	const config = configs[context.network];
+	if (!config) throw new Error(`Assertion failed: no blockfrost config found (${context.network}`);
+	return config;
+};
+const initializeDependencies = async ({ runtime: { config: { bitcoinFeeMarketProvider: { mempoolSpaceConfig } } } }, { logger }) => {
+	return { bitcoinFeeMarketProvider: { getFeeMarket: (context) => {
+		return (0, rxjs.from)(getMempoolSpaceApiProvider(getMempoolSpaceConfig(context, mempoolSpaceConfig), logger).getFeeMarket(context.network).then(require_asyncoption.Ok).catch(require_asyncoption.Err));
+	} } };
+};
+//#endregion
+//#region ../../packages/module/bitcoin-mempool-fee-market/src/store/init.ts
+const redux = async (props, dependencies) => ({ sideEffectDependencies: await initializeDependencies(props, dependencies) });
+//#endregion
+exports.default = redux;

package/dist/{init-B64zCLxG.cjs → init-DUF4ar8P.cjs}

@@ -1,8 +1,8 @@
 require("./rolldown-runtime-Br2OG8yv.cjs");
-const require_esm_browser = require("./esm-browser-DTc9IK3D.cjs");
-const require_slice = require("./slice-oqm_r1cS.cjs");
-const require_blockingWithLatestFrom = require("./blockingWithLatestFrom-DY8OPg0w.cjs");
-const require_toEmpty = require("./toEmpty-DAMmNB5r.cjs");
+const require_esm_browser = require("./esm-browser-bweqfBlL.cjs");
+const require_slice = require("./slice-DnG-yvpI.cjs");
+const require_blockingWithLatestFrom = require("./blockingWithLatestFrom-D8kBPBMX.cjs");
+const require_toEmpty = require("./toEmpty-CYAbupM4.cjs");
 let _laceio_cardano_util = require("@laceio/cardano/util");
 let rxjs = require("rxjs");
 //#region ../../packages/contract/analytics/src/store/side-effects.ts

package/dist/init-DlqJuHhl.js

@@ -0,0 +1,119 @@
+import { n as Ok, t as Err } from "./asyncoption-CruEYOBI.js";
+import { o as toProviderError } from "./error-DIZOY2Lw.js";
+import { t as HttpClient } from "./http-client-TRlhDZGh.js";
+import { n as BitcoinNetwork } from "./types-B8uiJn-X.js";
+import { contextLogger } from "@laceio/cardano/util";
+import { from } from "rxjs";
+import memoize from "lodash/memoize.js";
+//#region ../../packages/module/bitcoin-mempool-fee-market/src/mempool/mempool-fee-market-provider.ts
+const MIN_FEE_RATE = 11e-6;
+const DEFAULT_MARKETS = {
+	fast: {
+		feeRate: 25e-6,
+		targetConfirmationTime: 1
+	},
+	standard: {
+		feeRate: 15e-6,
+		targetConfirmationTime: 3
+	},
+	slow: {
+		feeRate: 11e-6,
+		targetConfirmationTime: 6
+	}
+};
+/**
+* Converts a fee rate in satoshis per vbyte to BTC per kilobyte.
+* @param satsPerVByte - The fee rate in satoshis per vbyte.
+*/
+const satsPerVByteToBtcPerKB = (satsPerVByte) => satsPerVByte * 1e3 / 1e8;
+/**
+* High-level REST wrapper around Mempool.space's Bitcoin feemarket API API.
+*/
+var MempoolFeeMarketProvider = class {
+	logger;
+	#client;
+	/**
+	* Creates a new instance of the Mempool FeeMarket 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);
+	}
+	/**
+	* 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.
+	*
+	* @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 getFeeMarket(network) {
+		try {
+			if (network === BitcoinNetwork.Testnet) return DEFAULT_MARKETS;
+			const feeData = await this.request("/api/v1/fees/recommended");
+			const fastEstimate = feeData.fastestFee;
+			const standardEstimate = feeData.halfHourFee;
+			const slowEstimate = feeData.hourFee;
+			return {
+				fast: {
+					feeRate: Math.max(satsPerVByteToBtcPerKB(fastEstimate), MIN_FEE_RATE),
+					targetConfirmationTime: 600
+				},
+				standard: {
+					feeRate: Math.max(satsPerVByteToBtcPerKB(standardEstimate), MIN_FEE_RATE),
+					targetConfirmationTime: 1800
+				},
+				slow: {
+					feeRate: Math.max(satsPerVByteToBtcPerKB(slowEstimate), MIN_FEE_RATE),
+					targetConfirmationTime: 3600
+				}
+			};
+		} catch (error) {
+			this.logger.error("Failed to fetch fee market:", error);
+		}
+		return DEFAULT_MARKETS;
+	}
+	/**
+	* Performs a generic HTTP request to the Mempool.space 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.data;
+		} catch (error) {
+			this.logger.debug("error", error);
+			throw toProviderError(error);
+		}
+	}
+};
+//#endregion
+//#region ../../packages/module/bitcoin-mempool-fee-market/src/store/dependencies.ts
+const computeMaestroConfigIdentifier = ({ url }) => `${url}`;
+const getMempoolSpaceClient = memoize(({ url }) => {
+	return new HttpClient({ baseUrl: url });
+}, computeMaestroConfigIdentifier);
+const getMempoolSpaceApiProvider = memoize((config, logger) => {
+	return new MempoolFeeMarketProvider(getMempoolSpaceClient(config), logger);
+}, computeMaestroConfigIdentifier);
+const getMempoolSpaceConfig = (context, configs) => {
+	const config = configs[context.network];
+	if (!config) throw new Error(`Assertion failed: no blockfrost config found (${context.network}`);
+	return config;
+};
+const initializeDependencies = async ({ runtime: { config: { bitcoinFeeMarketProvider: { mempoolSpaceConfig } } } }, { logger }) => {
+	return { bitcoinFeeMarketProvider: { getFeeMarket: (context) => {
+		return from(getMempoolSpaceApiProvider(getMempoolSpaceConfig(context, mempoolSpaceConfig), logger).getFeeMarket(context.network).then(Ok).catch(Err));
+	} } };
+};
+//#endregion
+//#region ../../packages/module/bitcoin-mempool-fee-market/src/store/init.ts
+const redux = async (props, dependencies) => ({ sideEffectDependencies: await initializeDependencies(props, dependencies) });
+//#endregion
+export { redux as default };

package/dist/{init-y2Ra0vZP.js → init-Dnsv155v.js}

@@ -1,6 +1,6 @@
-import { n as v4, t as init_esm_browser } from "./esm-browser-C93Q-EOI.js";
-import { a as FolderId, t as reducers } from "./slice-maaskdUn.js";
-import { t as firstStateOfStatus } from "./first-state-of-status-DQnMT3ya.js";
+import { n as v4, t as init_esm_browser } from "./esm-browser-MG97cre9.js";
+import { a as FolderId, t as reducers } from "./slice-DBpJ2QGf.js";
+import { t as firstStateOfStatus } from "./first-state-of-status-unPynOuM.js";
 import { switchMap, withLatestFrom } from "rxjs";
 import { createMigrate } from "redux-persist";
 //#region ../../packages/contract/tokens/src/store/side-effects.ts