@laceio/sdk 0.1.1 → 0.1.2-canary.0

package/dist/init-DuYENxci.js

@@ -0,0 +1,17 @@
+import "./_web-crypto-random-bytes-Bo-GTcRS.js";
+import "./_polyfill-buffer-patch-yNxN4d5E.js";
+import "./codecs-Dc1Krpbt.js";
+import "./address-B9ntKL8K.js";
+import "./safe-buffer-B_vMqJWU.js";
+import "./browser-B1eMbDwh.js";
+import "./asyncoption-CruEYOBI.js";
+import { a as bitcoinContextReducers, n as bitcoinAccountWallets$, o as bitcoinContextSelectors, t as createBitcoinProviderSideEffects } from "./side-effects-BnqYz7Nl.js";
+//#region ../../packages/module/blockchain-bitcoin/src/store/init.ts
+const store = (props) => ({
+	sideEffects: createBitcoinProviderSideEffects(props.runtime.config),
+	reducers: bitcoinContextReducers,
+	selectors: bitcoinContextSelectors,
+	sideEffectDependencies: { bitcoinAccountWallets$ }
+});
+//#endregion
+export { store as default };

package/dist/{init-D6DBUsD3.cjs → init-Dv3zKj0r.cjs}

@@ -1,8 +1,8 @@
 require("./rolldown-runtime-Br2OG8yv.cjs");
-const require_retry_config = require("./retry-config-DC5IMaH7.cjs");
-const require_while_active = require("./while-active-Dhc2LwOm.cjs");
-const require_utils = require("./utils-5JvjbqH3.cjs");
-const require_slice = require("./slice-D11m2EKl.cjs");
+const require_retry_config = require("./retry-config-BaCfVC1H.cjs");
+const require_while_active = require("./while-active-Dsowp0Fi.cjs");
+const require_utils = require("./utils-DsElZgCI.cjs");
+const require_slice = require("./slice-DayJvMRD.cjs");
 let rxjs = require("rxjs");
 let redux_persist = require("redux-persist");
 //#region ../../packages/lib/util-store/src/by-blockchain-name.ts

package/dist/{init-BtzMZ7Pk.cjs → init-Dy-05ktr.cjs}

@@ -1,5 +1,5 @@
 require("./rolldown-runtime-Br2OG8yv.cjs");
-const require_slice = require("./slice-DZmQJNV8.cjs");
+const require_slice = require("./slice-B4CdYoPu.cjs");
 let rxjs = require("rxjs");
 //#region ../../packages/contract/failures/src/utils/parse-failure-id.ts
 const KNOWN_BLOCKCHAINS = new Set([

package/dist/{init-BsCBAGWf.cjs → init-EP0CUWNK.cjs}

@@ -1,6 +1,6 @@
 const require_rolldown_runtime = require("./rolldown-runtime-Br2OG8yv.cjs");
-const require_util = require("./util-CmdAhheh.cjs");
-const require_slice = require("./slice-D11FHQuQ.cjs");
+const require_util = require("./util-CzeB3hfa.cjs");
+const require_slice = require("./slice-BiRsDKOK.cjs");
 let _laceio_cardano_util = require("@laceio/cardano/util");
 let rxjs = require("rxjs");
 let lodash_isEqual = require("lodash/isEqual.js");

package/dist/{init-BJVU54pI.cjs → init-EhzD7a8i.cjs}

@@ -1,5 +1,5 @@
 require("./rolldown-runtime-Br2OG8yv.cjs");
-const require_slice = require("./slice-CGVHXHDt.cjs");
+const require_slice = require("./slice-DnBWfA-k.cjs");
 let rxjs = require("rxjs");
 let redux_persist = require("redux-persist");
 //#region ../../packages/contract/views/src/store/side-effects.ts

package/dist/{init-w9GEs73W.js → init-Fw89ZmrR.js}

@@ -1,5 +1,5 @@
-import { r as networkReducers, t as initialState } from "./slice-CB4SnzMm.js";
-import { t as FEATURE_FLAG_NETWORK_TYPE } from "./const-DXk2tFyv.js";
+import { r as networkReducers, t as initialState } from "./slice-GwiiJRoq.js";
+import { t as FEATURE_FLAG_NETWORK_TYPE } from "./const-CjmfjBP3.js";
 import { deepEquals, isNotNil } from "@laceio/cardano/util";
 import { distinctUntilChanged, filter, map, merge } from "rxjs";
 import { createMigrate } from "redux-persist";

package/dist/init-GsT2AEa4.cjs

@@ -0,0 +1,424 @@
+const require_rolldown_runtime = require("./rolldown-runtime-Br2OG8yv.cjs");
+const require_asyncoption = require("./asyncoption-i0VbqVTq.cjs");
+const require_retry_config = require("./retry-config-BaCfVC1H.cjs");
+const require_error = require("./error-Cb3EnD0u.cjs");
+const require_http_client = require("./http-client-B3N-TMxu.cjs");
+const require_lib$1 = require("./lib-Yk6Upl5D.cjs");
+const require_bitcoin_data_provider = require("./bitcoin-data-provider-w1oEDSU3.cjs");
+let _laceio_cardano_core = require("@laceio/cardano/core");
+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);
+let rxjs_operators = require("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 = (0, _laceio_cardano_util.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 (require_error.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 (require_error.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 (require_error.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 _laceio_cardano_core.ProviderError(_laceio_cardano_core.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 (require_error.isNotFoundError(error)) return require_bitcoin_data_provider.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 _laceio_cardano_core.ProviderError(_laceio_cardano_core.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 ? require_bitcoin_data_provider.BitcoinTransactionStatus.Confirmed : require_bitcoin_data_provider.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: require_bitcoin_data_provider.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 require_error.toProviderError(error);
+		}
+	}
+};
+//#endregion
+//#region ../../packages/lib/bitcoin-provider-core/src/maestro-config.ts
+var import_lib = /* @__PURE__ */ require_rolldown_runtime.__toESM(require_lib$1.require_lib());
+const computeMaestroConfigIdentifier = ({ clientConfig: { baseUrl, projectId } }) => `${baseUrl}-${projectId}`;
+const getMaestroClient = (0, lodash_memoize.default)(({ clientConfig, rateLimiterConfig }) => {
+	const rateLimiter = new import_lib.default({
+		reservoir: rateLimiterConfig.size,
+		reservoirIncreaseAmount: rateLimiterConfig.increaseAmount,
+		reservoirIncreaseInterval: rateLimiterConfig.increaseInterval,
+		reservoirIncreaseMaximum: rateLimiterConfig.size
+	});
+	return new require_http_client.HttpClient({
+		baseUrl: require_http_client.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
+var import_dist = require_retry_config.require_dist();
+const getMaestroApiProvider = (0, lodash_memoize.default)((config, logger) => {
+	return new MaestroBitcoinProvider(getMaestroClient(config), logger);
+}, computeMaestroConfigIdentifier);
+const getMaestroConfig = (context, configs) => configs[context.network];
+const unprovisionedNetworkError = (network) => new _laceio_cardano_core.ProviderError(_laceio_cardano_core.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 (0, rxjs.of)(require_asyncoption.Err(unprovisionedNetworkError(context.network)));
+		return (0, rxjs.from)(getMaestroApiProvider(config, logger).getLastKnownBlock().then(require_asyncoption.Ok).catch(require_asyncoption.Err));
+	},
+	getTransaction: (context, txHash) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return (0, rxjs.of)(require_asyncoption.Err(unprovisionedNetworkError(context.network)));
+		return (0, rxjs.from)(getMaestroApiProvider(config, logger).getTransaction(txHash).then(require_asyncoption.Ok).catch(require_asyncoption.Err));
+	},
+	getRawTransaction: (context, txHash) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return (0, rxjs.of)(require_asyncoption.Err(unprovisionedNetworkError(context.network)));
+		const provider = getMaestroApiProvider(config, logger);
+		return (0, rxjs.defer)(async () => provider.getRawTransaction(txHash)).pipe((0, import_dist.retryBackoff)(require_retry_config.PROVIDER_REQUEST_RETRY_CONFIG), (0, rxjs_operators.map)(require_asyncoption.Ok), (0, rxjs_operators.catchError)((error) => (0, rxjs.of)(require_asyncoption.Err(error))));
+	},
+	getTransactions: (context, address, { afterBlockHeight, limit, order, cursor }) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return (0, rxjs.of)(require_asyncoption.Err(unprovisionedNetworkError(context.network)));
+		return (0, rxjs.from)(getMaestroApiProvider(config, logger).getTransactions(address, {
+			count: limit,
+			order,
+			cursor,
+			from: afterBlockHeight
+		}).then((result) => require_asyncoption.Ok(result)).catch(require_asyncoption.Err));
+	},
+	getTransactionsInMempool: (context, address, { afterBlockHeight, limit, order, cursor }) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return (0, rxjs.of)(require_asyncoption.Err(unprovisionedNetworkError(context.network)));
+		return (0, rxjs.from)(getMaestroApiProvider(config, logger).getTransactionsInMempool(address, {
+			count: limit,
+			order,
+			cursor,
+			from: afterBlockHeight
+		}).then((result) => require_asyncoption.Ok(result)).catch(require_asyncoption.Err));
+	},
+	getUTxOs: (context, address, { afterBlockHeight, limit, order, cursor }) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return (0, rxjs.of)(require_asyncoption.Err(unprovisionedNetworkError(context.network)));
+		return (0, rxjs.from)(getMaestroApiProvider(config, logger).getUTxOs(address, {
+			count: limit,
+			order,
+			cursor,
+			from: afterBlockHeight
+		}).then((result) => require_asyncoption.Ok(result)).catch(require_asyncoption.Err));
+	},
+	submitTransaction: (context, rawTransaction) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return (0, rxjs.of)(require_asyncoption.Err(unprovisionedNetworkError(context.network)));
+		return (0, rxjs.from)(getMaestroApiProvider(config, logger).submitTransaction(rawTransaction).then(require_asyncoption.Ok).catch(require_asyncoption.Err));
+	},
+	getTransactionStatus: (context, txHash) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return (0, rxjs.of)(require_asyncoption.Err(unprovisionedNetworkError(context.network)));
+		return (0, rxjs.from)(getMaestroApiProvider(config, logger).getTransactionStatus(txHash).then(require_asyncoption.Ok).catch(require_asyncoption.Err));
+	},
+	estimateFee: (context, blocks, mode) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return (0, rxjs.of)(require_asyncoption.Err(unprovisionedNetworkError(context.network)));
+		return (0, rxjs.from)(getMaestroApiProvider(config, logger).estimateFee(blocks, mode).then(require_asyncoption.Ok).catch(require_asyncoption.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
+exports.default = redux;

package/dist/{init-Rxohwpmu.js → init-NCjgwCZy.js}

@@ -1,5 +1,5 @@
-import { n as featureFlagSetEquals, r as featureFlagsToFeatures, t as createFeatureFlagStorage } from "./util-DxzlYNS5.js";
-import { i as initialState, n as featuresReducers } from "./slice-Be7hj4Iy.js";
+import { n as featureFlagSetEquals, r as featureFlagsToFeatures, t as createFeatureFlagStorage } from "./util-C8a4fA9p.js";
+import { i as initialState, n as featuresReducers } from "./slice-Bk0Sv05J.js";
 import { deepEquals } from "@laceio/cardano/util";
 import { distinctUntilChanged, filter, map, switchMap } from "rxjs";
 import isEqual from "lodash/isEqual.js";

package/dist/{init-DxUHsN53.cjs → init-NdhG_VrF.cjs}

@@ -1,8 +1,8 @@
 require("./rolldown-runtime-Br2OG8yv.cjs");
-const require_is_redux_persist_state = require("./is-redux-persist-state-CTn3WZVh.cjs");
-const require_account_id_vo = require("./account-id.vo-LvCBVn5r.cjs");
-const require_activity_type_stable = require("./activity-type.stable-BJEfeLxL.cjs");
-const require_slice = require("./slice-HeHCv3bl.cjs");
+const require_is_redux_persist_state = require("./is-redux-persist-state-BCFnSm36.cjs");
+const require_account_id_vo = require("./account-id.vo-DwqFjK5u.cjs");
+const require_activity_type = require("./activity-type-Ch6ljxBy.cjs");
+const require_slice = require("./slice-C34iOOUH.cjs");
 let redux_persist = require("redux-persist");
 //#region ../../packages/contract/activities/src/store/migrations/reset-reward-activity-dates.ts
 /**
@@ -27,7 +27,7 @@ const resetRewardActivities = (state) => {
 		const list = activitiesMap[key];
 		if (!Array.isArray(list)) continue;
 		desiredLoadedActivitiesCountPerAccount[accountId] = list.length;
-		activitiesMap[key] = list.filter((activity) => activity.type !== require_activity_type_stable.ActivityType.Rewards);
+		activitiesMap[key] = list.filter((activity) => activity.type !== require_activity_type.ActivityType.Rewards);
 	}
 	return {
 		...typedState,
@@ -47,7 +47,7 @@ const rewardEpochDisplay = (state) => {
 	const activitiesMap = typedState.activities ?? {};
 	for (const list of Object.values(activitiesMap)) {
 		if (!Array.isArray(list)) continue;
-		for (const activity of list) if (activity.type === require_activity_type_stable.ActivityType.Rewards && activity.blockchainSpecific && typeof activity.blockchainSpecific.epoch === "number") {
+		for (const activity of list) if (activity.type === require_activity_type.ActivityType.Rewards && activity.blockchainSpecific && typeof activity.blockchainSpecific.epoch === "number") {
 			const meta = activity.blockchainSpecific;
 			meta.epoch = meta.epoch + REWARD_EPOCH_DISPLAY_OFFSET;
 		}

package/dist/{init-DDdhguVC.js → init-SZ01tARX2.js}

@@ -1,5 +1,5 @@
-import { n as CollectionStore, r as DocumentStore, t as KeyValueStore } from "./key-value-store-8cMzeNyG.js";
-import { t as Serializable } from "./serializable-B8GahgE1.js";
+import { n as CollectionStore, r as DocumentStore, t as KeyValueStore } from "./key-value-store--W3SrMaw.js";
+import { t as Serializable } from "./serializable-BHdKIgk3.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-BAJJzBza.js → init-Y3mkB4XS.js}

@@ -1,5 +1,5 @@
-import { t as BlockchainNetworkId } from "./blockchain-network-id.vo-DNRkuT5B.js";
-import { n as addressBookReducers } from "./slice-B87b52iM.js";
+import { t as BlockchainNetworkId } from "./blockchain-network-id.vo-CiVykuqG.js";
+import { n as addressBookReducers } from "./slice-obCSLm1x.js";
 import { createMigrate } from "redux-persist";
 //#region ../../packages/contract/address-book/src/store/init.ts
 const store = () => ({

package/dist/init-c4l6r-o-.js

@@ -0,0 +1,5 @@
+import { n as passportReducers } from "./slice-t8Q1cHm-.js";
+//#region ../../packages/contract/passport/src/store/init.ts
+const store = () => ({ reducers: passportReducers });
+//#endregion
+export { store as default };

package/dist/{init-Dku4b2lG.js → init-kEfUTuG2.js}

@@ -1,4 +1,4 @@
-import { n as viewsReducers } from "./slice-DhvF7L6X.js";
+import { n as viewsReducers } from "./slice-BPNuHKfw.js";
 import { map } from "rxjs";
 import { createMigrate } from "redux-persist";
 //#region ../../packages/contract/views/src/store/side-effects.ts