@laceio/sdk 0.1.1 → 0.1.2-canary.1

package/dist/init-D8OeObDF.cjs

@@ -0,0 +1,1141 @@
+const require_rolldown_runtime = require("./rolldown-runtime-Br2OG8yv.cjs");
+require("./_polyfill-buffer-patch-CM8X7JiY.cjs");
+const require_util = require("./util-Bu4W5lF4.cjs");
+const require_time_vo = require("./time.vo-D3wWRw9L.cjs");
+const require_bignum_vo = require("./bignum.vo-hx2kuqlA.cjs");
+const require_asyncoption = require("./asyncoption-i0VbqVTq.cjs");
+const require_token_id_vo = require("./token-id.vo-DXv5uS9n.cjs");
+const require_const = require("./const-D-eZIS4n.cjs");
+const require_cardano_network_id_to_network_type = require("./cardano-network-id-to-network-type-C0ufJOyE.cjs");
+const require_error = require("./error-Cb3EnD0u.cjs");
+const require_http_client = require("./http-client-B3N-TMxu.cjs");
+const require_blockfrost_tx_submit_provider = require("./blockfrost-tx-submit-provider-CLNQ5ycR.cjs");
+const require_lib$1 = require("./lib-Yk6Upl5D.cjs");
+let _laceio_cardano_key_management = require("@laceio/cardano/key-management");
+let _laceio_cardano_crypto = require("@laceio/cardano/crypto");
+let _laceio_cardano_core = require("@laceio/cardano/core");
+let _laceio_cardano_util = require("@laceio/cardano/util");
+let rxjs = require("rxjs");
+let lodash_omit_js = require("lodash/omit.js");
+lodash_omit_js = require_rolldown_runtime.__toESM(lodash_omit_js);
+let lodash_memoize = require("lodash/memoize.js");
+lodash_memoize = require_rolldown_runtime.__toESM(lodash_memoize);
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-asset-provider.ts
+var BlockfrostAssetProvider = class extends require_blockfrost_tx_submit_provider.BlockfrostProvider {
+	constructor(client, logger) {
+		super(client, logger);
+	}
+	async getAsset({ assetId, extraData }) {
+		try {
+			const response = await this.request(`assets/${assetId.toString()}`);
+			const name = _laceio_cardano_core.Cardano.AssetId.getAssetName(assetId);
+			const policyId = _laceio_cardano_core.Cardano.PolicyId(response.policy_id);
+			const quantity = BigInt(response.quantity);
+			return {
+				assetId,
+				fingerprint: _laceio_cardano_core.Cardano.AssetFingerprint(response.fingerprint),
+				name,
+				nftMetadata: extraData?.nftMetadata ? this.mapNftMetadata(response) : null,
+				policyId,
+				quantity,
+				supply: quantity,
+				tokenMetadata: extraData?.tokenMetadata ? this.mapTokenMetadata(assetId, response) : null
+			};
+		} catch (error) {
+			this.logger.error("getAsset failed", assetId, extraData);
+			throw require_error.toProviderError(error);
+		}
+	}
+	mapNftMetadata(asset) {
+		const image = this.metadatumToString(asset.onchain_metadata?.image || asset.metadata?.logo);
+		const name = asset.onchain_metadata?.name || asset.metadata?.name;
+		if (!image || !name) return null;
+		try {
+			return {
+				description: this.metadatumToString(asset.onchain_metadata?.description || asset.metadata?.description),
+				files: Array.isArray(asset.onchain_metadata?.files) ? asset.onchain_metadata.files.map((file) => {
+					const mediaType = file.mediaType;
+					const fileName = file.name;
+					const source = this.metadatumToString(file.src);
+					if (!source || !mediaType) return null;
+					try {
+						return {
+							mediaType: _laceio_cardano_core.Asset.MediaType(mediaType),
+							name: fileName,
+							otherProperties: this.mapFileMetadataOtherProperties(file),
+							src: _laceio_cardano_core.Asset.Uri(source)
+						};
+					} catch (error) {
+						this.logger.warn("Failed to parse onchain_metadata file", file, error);
+						return null;
+					}
+				}).filter(_laceio_cardano_util.isNotNil) : void 0,
+				image: _laceio_cardano_core.Asset.Uri(image),
+				mediaType: asset.onchain_metadata?.mediaType ? _laceio_cardano_core.Asset.ImageMediaType(asset.onchain_metadata.mediaType) : void 0,
+				name,
+				otherProperties: this.mapNftMetadataOtherProperties(asset.onchain_metadata),
+				version: this.mapNftMetadataVersion(asset.onchain_metadata)
+			};
+		} catch (error) {
+			this.logger.warn("Failed to parse nft metadata", asset, error);
+			return null;
+		}
+	}
+	asString = (metadatum) => typeof metadatum === "string" ? metadatum : void 0;
+	metadatumToString(metadatum) {
+		let stringMetadatum;
+		if (Array.isArray(metadatum)) stringMetadatum = metadatum.map((metadata) => this.asString(metadata)).filter(_laceio_cardano_util.isNotNil).join("");
+		else stringMetadatum = this.asString(metadatum);
+		return stringMetadatum;
+	}
+	objToMetadatum(object) {
+		if (typeof object === "string") return object;
+		if (typeof object === "number") return BigInt(object);
+		if (typeof object === "object") {
+			if (object === null) return "";
+			if (Array.isArray(object)) return object.map((item) => this.objToMetadatum(item));
+			return new Map(Object.entries(object).map(([key, value]) => [key, this.objToMetadatum(value)]));
+		}
+		return "";
+	}
+	mapNftMetadataVersion(metadata) {
+		return typeof metadata?.version === "string" ? metadata.version : "1.0";
+	}
+	mapFileMetadataOtherProperties(metadata) {
+		return this.mapOtherProperties(metadata, [
+			"name",
+			"mediaType",
+			"src"
+		]);
+	}
+	mapNftMetadataOtherProperties(metadata) {
+		return this.mapOtherProperties(metadata, [
+			"name",
+			"image",
+			"description",
+			"mediaType",
+			"files",
+			"version"
+		]);
+	}
+	mapOtherProperties(metadata, mainProperties) {
+		if (!metadata) return;
+		const otherProperties = Object.entries((0, lodash_omit_js.default)(metadata, mainProperties));
+		if (otherProperties.length === 0) return;
+		return new Map(otherProperties.map(([key, value]) => [key, this.objToMetadatum(value)]));
+	}
+	mapTokenMetadata(assetId, asset) {
+		return {
+			assetId,
+			decimals: asset.metadata?.decimals || void 0,
+			desc: this.metadatumToString(asset.metadata?.description || asset.onchain_metadata?.description),
+			icon: this.metadatumToString(asset.metadata?.logo || asset.onchain_metadata?.image),
+			name: asset.metadata?.name || asset.onchain_metadata?.name,
+			ticker: asset.metadata?.ticker || void 0,
+			url: asset.metadata?.url || void 0,
+			version: "1.0"
+		};
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-address-discovery.ts
+/**
+* How far we search for stake keys before concluding there are no more stake credentials.
+*/
+const STAKE_KEY_GAP = 5;
+/**
+* How far we search for payment addresses under a single stake key
+* before concluding that no more addresses exist (or that they are “franken”).
+*/
+const PAYMENT_CREDENTIAL_GAP = 100;
+/**
+* Safety cap for thorough discovery. The thorough predicate continues past
+* the gap when the Blockfrost-returned address set still has unmatched
+* entries; this bound ensures the loop cannot run forever when an unmatched
+* entry is structurally undiscoverable (true "franken" cases).
+*/
+const HARD_UPPER_BOUND = 1e4;
+/**
+* Fetch size for Blockfrost addresses per page.
+*/
+const BLOCKFROST_PAGE_SIZE = 100;
+/**
+* Derive the reward account (stake address) at a given stakeIndex.
+*/
+const deriveRewardAccount = async (account, stakeIndex) => {
+	return require_util.CardanoRewardAccount((await account.deriveAddress({
+		type: _laceio_cardano_key_management.AddressType.External,
+		index: 0
+	}, stakeIndex)).rewardAccount);
+};
+/**
+* Derive a payment address at a given (payment) index + address type (internal/external).
+*/
+const derivePaymentAddress = async (account, paymentIndex, stakeIndex, isInternal) => {
+	const type = isInternal ? _laceio_cardano_key_management.AddressType.Internal : _laceio_cardano_key_management.AddressType.External;
+	return account.deriveAddress({
+		type,
+		index: paymentIndex
+	}, stakeIndex);
+};
+const compareAddresses = (a, b) => {
+	const indexDiff = a.index - b.index;
+	if (indexDiff !== 0) return indexDiff;
+	if (a.stakeKeyDerivationPath && b.stakeKeyDerivationPath) return a.stakeKeyDerivationPath.index - b.stakeKeyDerivationPath.index;
+	return 0;
+};
+/**
+* Example BlockfrostAddressDiscovery class that:
+*   - Paginates all addresses from each reward account
+*   - Derives addresses sequentially and checks if they match
+*   - Uses a gap-based approach for both stake keys AND payment addresses
+*   - Logs leftover addresses as unknown
+*/
+var BlockfrostAddressDiscovery = class extends require_blockfrost_tx_submit_provider.BlockfrostProvider {
+	constructor(client, logger) {
+		super(client, logger);
+	}
+	/**
+	* @returns Observable that emits all discovered addresses one by one. Completes on first error.
+	*/
+	discover(manager, options = {}) {
+		const isThorough = options.thorough ?? false;
+		this.logger.debug(`Discovering addresses using Blockfrost (thorough=${isThorough})...`);
+		return (0, rxjs.forkJoin)({
+			firstAddress: (0, rxjs.from)(manager.deriveAddress({
+				index: 0,
+				type: _laceio_cardano_key_management.AddressType.External
+			}, 0)),
+			discovered: this.#discoverAddresses(manager, isThorough).pipe((0, rxjs.toArray)())
+		}).pipe((0, rxjs.mergeMap)(({ firstAddress, discovered }) => (0, rxjs.from)([firstAddress, ...discovered])), (0, rxjs.distinct)(({ address }) => address), (0, rxjs.map)(require_asyncoption.Ok), (0, rxjs.catchError)((error) => (0, rxjs.of)(require_asyncoption.Err(error instanceof _laceio_cardano_core.ProviderError ? error : new _laceio_cardano_core.ProviderError(_laceio_cardano_core.ProviderFailure.Unknown, error)))));
+	}
+	/**
+	* Main discovery logic:
+	*   1. Stake key gap: we keep deriving stake keys until we have
+	*      STAKE_KEY_GAP consecutive stake keys that yield zero discovered addresses.
+	*   2. Payment credential gap: for each stake key, we stop deriving
+	*      payment addresses once we have PAYMENT_CREDENTIAL_GAP consecutive misses.
+	*      In thorough mode, termination additionally requires the Blockfrost
+	*      address set to be drained (bounded by HARD_UPPER_BOUND).
+	*/
+	#discoverAddresses(account, thorough) {
+		return new rxjs.Observable((subscriber) => {
+			let isUnsubscribed = false;
+			(async () => {
+				let stakeIndex = 0;
+				let stakeGapCount = 0;
+				try {
+					while (stakeGapCount < STAKE_KEY_GAP) {
+						if (isUnsubscribed) break;
+						this.logger.debug(`Deriving reward account for stake index ${stakeIndex}...`);
+						const rewardAccount = await deriveRewardAccount(account, stakeIndex);
+						this.logger.debug(`Fetching addresses for stake credential ${rewardAccount}...`);
+						const allAddressesForStake = await this.#fetchAllAddressesForAccount(rewardAccount);
+						if (allAddressesForStake.length === 0) {
+							stakeGapCount++;
+							stakeIndex++;
+							continue;
+						}
+						stakeGapCount = 0;
+						const { discovered, unknown } = await this.#discoverAddressesForStakeKey(account, stakeIndex, allAddressesForStake, thorough);
+						for (const address of discovered.sort(compareAddresses)) subscriber.next(address);
+						if (unknown.length > 0) this.logger.warn(`The following addresses under stakeIndex ${stakeIndex} were not matched:`, unknown);
+						++stakeIndex;
+					}
+					subscriber.complete();
+				} catch (error) {
+					subscriber.error(error);
+				}
+			})();
+			return () => {
+				isUnsubscribed = true;
+			};
+		});
+	}
+	/**
+	* Discover addresses under a single stake key.
+	*
+	* Standard mode (thorough=false): stop once we hit PAYMENT_CREDENTIAL_GAP
+	* consecutive misses. Matches the BIP-44 gap-limit convention.
+	*
+	* Thorough mode (thorough=true): also require the Blockfrost address set to
+	* be drained before stopping, so high-index entries past the gap can still
+	* be discovered. Bounded by HARD_UPPER_BOUND to guarantee termination when
+	* an entry is structurally undiscoverable.
+	*
+	* @returns Array of discovered (matched) addresses + leftover “unknown/franken” addresses
+	*/
+	async #discoverAddressesForStakeKey(account, stakeIndex, allAddressesForStake, thorough) {
+		const discovered = [];
+		const uniqueAddressesForStake = new Set(allAddressesForStake);
+		let gapCount = 0;
+		let paymentIndex = 0;
+		while (true) {
+			const hasHitGap = gapCount >= PAYMENT_CREDENTIAL_GAP;
+			if (thorough ? hasHitGap && uniqueAddressesForStake.size === 0 || paymentIndex >= HARD_UPPER_BOUND : hasHitGap) {
+				this.logger.debug(`Stopping payment discovery for stakeIndex ${stakeIndex} at paymentIndex ${paymentIndex} (gap=${gapCount}, remaining=${uniqueAddressesForStake.size}, thorough=${thorough}).`);
+				break;
+			}
+			const externalAddr = await derivePaymentAddress(account, paymentIndex, stakeIndex, false);
+			const hasExternalInSet = uniqueAddressesForStake.has(externalAddr.address);
+			const internalAddr = await derivePaymentAddress(account, paymentIndex, stakeIndex, true);
+			const hasInternalInSet = uniqueAddressesForStake.has(internalAddr.address);
+			if (hasExternalInSet) {
+				discovered.push({
+					...externalAddr,
+					stakeKeyDerivationPath: {
+						index: stakeIndex,
+						role: _laceio_cardano_key_management.KeyRole.Stake
+					}
+				});
+				uniqueAddressesForStake.delete(externalAddr.address);
+			}
+			if (hasInternalInSet) {
+				discovered.push({
+					...internalAddr,
+					stakeKeyDerivationPath: {
+						index: stakeIndex,
+						role: _laceio_cardano_key_management.KeyRole.Stake
+					}
+				});
+				uniqueAddressesForStake.delete(internalAddr.address);
+			}
+			if (!hasExternalInSet && !hasInternalInSet) gapCount++;
+			else gapCount = 0;
+			++paymentIndex;
+		}
+		return {
+			discovered,
+			unknown: [...uniqueAddressesForStake]
+		};
+	}
+	/**
+	* Fetch all addresses associated with a reward account from Blockfrost,
+	* handling pagination until the response has fewer than BLOCKFROST_PAGE_SIZE items.
+	*/
+	async #fetchAllAddressesForAccount(rewardAccount) {
+		const allAddresses = [];
+		let page = 1;
+		this.logger.debug(`Fetching addresses for stake ${rewardAccount} (paginated)...`);
+		while (true) try {
+			const response = await this.request(`accounts/${rewardAccount}/addresses?count=${BLOCKFROST_PAGE_SIZE}&page=${page}`);
+			if (!response || response.length === 0) break;
+			for (const entry of response) allAddresses.push(entry.address);
+			if (response.length < BLOCKFROST_PAGE_SIZE) break;
+			++page;
+		} catch (error) {
+			if (require_error.isNotFoundError(error)) {
+				this.logger.debug(`No addresses found for stake ${rewardAccount}. 404 from Blockfrost.`);
+				break;
+			}
+			this.logger.error(`Error fetching addresses for stake ${rewardAccount}:`, error);
+			throw error;
+		}
+		this.logger.debug(`Fetched ${allAddresses.length} addresses for stake ${rewardAccount}`);
+		return allAddresses;
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-tokens-provider.ts
+const amountToRawToken = (amount) => ({
+	available: require_bignum_vo.BigNumber(BigInt(amount.quantity)),
+	pending: require_bignum_vo.BigNumber(0n),
+	tokenId: require_token_id_vo.TokenId(amount.unit)
+});
+var BlockfrostTokensProvider = class extends require_blockfrost_tx_submit_provider.BlockfrostProvider {
+	getTokens(props) {
+		return (0, rxjs.from)(this.request(`addresses/${props.address}`).then(({ amount }) => require_asyncoption.Ok(amount.map(amountToRawToken))).catch((error) => {
+			if (require_error.isNotFoundError(error)) return require_asyncoption.Ok([]);
+			return require_asyncoption.Err(error);
+		}));
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-activity-provider.ts
+/**
+* Provider responsible for fetching transaction history and details.
+*/
+var BlockfrostActivityProvider = class extends require_blockfrost_tx_submit_provider.BlockfrostProvider {
+	#txProvider;
+	constructor(client, logger, txProvider = new require_blockfrost_tx_submit_provider.BlockfrostTxProvider(client, logger)) {
+		super(client, logger);
+		this.#txProvider = txProvider;
+	}
+	/**
+	* Fetches the transaction history for a Cardano address.
+	*
+	* @param address - Cardano payment address to fetch transaction history for
+	* @param numberOfItems - How many history items should be fetched (order: newer → older)
+	* @param startAtBlock - At which block (inclusive) should it start
+	* @param startAtIndex - At which index (inclusive) should it start
+	* @returns Observable with Result containing the history items or an error
+	*/
+	getAddressTransactionHistory({ address, numberOfItems, startAtBlock, startAtIndex, endAtBlock, endAtIndex, order = "desc" }) {
+		const fromIndexParameter = startAtIndex !== void 0 ? `:${startAtIndex}` : "";
+		const toIndexParameter = endAtIndex !== void 0 ? `:${endAtIndex}` : "";
+		const optionalFromParameter = startAtBlock !== void 0 ? `&to=${startAtBlock}${fromIndexParameter}` : "";
+		const optionalToParameter = endAtBlock !== void 0 ? `&from=${endAtBlock}${toIndexParameter}` : "";
+		return (0, rxjs.from)(this.request(`addresses/${address}/transactions?count=${numberOfItems}&order=${order}${optionalFromParameter}${optionalToParameter}`)).pipe((0, rxjs.map)((addressTxHistory) => require_asyncoption.Ok(addressTxHistory.map((item) => ({
+			txId: _laceio_cardano_core.Cardano.TransactionId(item.tx_hash),
+			txIndex: _laceio_cardano_core.Cardano.TxIndex(item.tx_index),
+			blockNumber: _laceio_cardano_core.Cardano.BlockNo(item.block_height),
+			blockTime: require_time_vo.Timestamp(item.block_time * 1e3)
+		})))), (0, rxjs.catchError)((error) => {
+			if (require_error.isNotFoundError(error)) return (0, rxjs.of)(require_asyncoption.Ok([]));
+			return (0, rxjs.of)(require_asyncoption.Err(error));
+		}));
+	}
+	/**
+	* Fetches transaction details, cbor and utxos to build a Cardano.HydratedTx
+	* which is returned inside a tuple together with the tx details which holds
+	* additional info not stored in the HydratedTx.
+	*
+	* @param txId - Cardano.TransactionId
+	*/
+	getTransactionDetails(txId) {
+		return (0, rxjs.forkJoin)([
+			(0, rxjs.from)(this.#txProvider.getTransaction(txId)),
+			this.#fetchTxFromCbor(txId),
+			this.#fetchUtxos(txId)
+		]).pipe((0, rxjs.map)(([txDetails, blockfrostTxCBOR, blockFrostUtxos]) => {
+			const { inputs, outputs, collaterals } = require_blockfrost_tx_submit_provider.BlockfrostToCardanoSDK.transactionUtxos(blockFrostUtxos, blockfrostTxCBOR);
+			const inputSource = txDetails.valid_contract ? _laceio_cardano_core.Cardano.InputSource.inputs : _laceio_cardano_core.Cardano.InputSource.collaterals;
+			const body = {
+				...inputSource === _laceio_cardano_core.Cardano.InputSource.collaterals ? {
+					collateralReturn: outputs.length > 0 ? outputs[0] : void 0,
+					collaterals: inputs,
+					fee: BigInt(0),
+					inputs: [],
+					outputs: [],
+					totalCollateral: blockfrostTxCBOR.body.fee
+				} : {
+					collateralReturn: blockfrostTxCBOR.body.collateralReturn ?? void 0,
+					collaterals,
+					fee: blockfrostTxCBOR.body.fee,
+					inputs,
+					outputs
+				},
+				certificates: blockfrostTxCBOR.body.certificates ?? [],
+				donation: blockfrostTxCBOR.body.donation,
+				mint: blockfrostTxCBOR.body.mint ? new Map([...blockfrostTxCBOR.body.mint].sort()) : void 0,
+				proposalProcedures: blockfrostTxCBOR.body.proposalProcedures,
+				validityInterval: blockfrostTxCBOR.body.validityInterval ? blockfrostTxCBOR.body.validityInterval : {
+					invalidBefore: void 0,
+					invalidHereafter: void 0
+				},
+				votingProcedures: blockfrostTxCBOR.body.votingProcedures,
+				withdrawals: blockfrostTxCBOR.body.withdrawals
+			};
+			return require_asyncoption.Ok({
+				auxiliaryData: blockfrostTxCBOR.auxiliaryData,
+				blockHeader: {
+					blockNo: _laceio_cardano_core.Cardano.BlockNo(txDetails.block_height),
+					hash: _laceio_cardano_core.Cardano.BlockId(txDetails.block),
+					slot: _laceio_cardano_core.Cardano.Slot(txDetails.slot)
+				},
+				body,
+				id: txId,
+				index: txDetails.index,
+				inputSource,
+				txSize: 0,
+				witness: blockfrostTxCBOR.witness,
+				blockTime: txDetails.block_time
+			});
+		}), (0, rxjs.catchError)((error) => (0, rxjs.of)(require_asyncoption.Err(error))));
+	}
+	#fetchTxFromCbor(txId) {
+		return (0, rxjs.from)(this.request(`txs/${txId}/cbor`)).pipe((0, rxjs.map)(({ cbor }) => _laceio_cardano_core.Serialization.Transaction.fromCbor(_laceio_cardano_core.Serialization.TxCBOR(cbor)).toCore()));
+	}
+	#fetchUtxos(txId) {
+		return (0, rxjs.from)(this.request(`txs/${txId}/utxos`));
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-input-resolver-provider.ts
+/**
+* A resolver class to fetch and resolve transaction inputs using Blockfrost API.
+*/
+var BlockfrostInputResolverProvider = class extends require_blockfrost_tx_submit_provider.BlockfrostProvider {
+	/**
+	* Constructs a new BlockfrostInputResolverProvider.
+	*
+	* @param client - The Blockfrost client instance to interact with the Blockfrost API.
+	* @param logger - The logger instance to log messages to.
+	*/
+	constructor(client, logger) {
+		super(client, logger);
+	}
+	/**
+	* Resolves a transaction input (`Cardano.TxIn`) to its corresponding output (`Cardano.TxOut`).
+	*
+	* @param input - The transaction input to resolve, including its transaction ID and index.
+	* @returns A promise that resolves to the corresponding `Cardano.TxOut` if found, or `null` if not.
+	*/
+	async resolveInput(input) {
+		this.logger.debug(`Resolving input ${input.txId}#${input.index}`);
+		const out = await this.fetchTxOut(input);
+		if (!out) return null;
+		return out;
+	}
+	/**
+	* Fetches and caches the transaction output (`Cardano.TxOut`) for a given transaction input (`Cardano.TxIn`).
+	*
+	* @param txIn - The transaction input to fetch and cache the output for.
+	* @returns A promise that resolves to the corresponding `Cardano.TxOut` if found, or `null` if not.
+	*/
+	async fetchTxOut(txIn) {
+		let response;
+		try {
+			response = await this.request(`txs/${txIn.txId}/utxos`);
+		} catch (error) {
+			this.logger.error(`Failed to fetch transaction ${txIn.txId}`, error);
+			if (require_error.isNotFoundError(error)) return null;
+			throw error;
+		}
+		for (const blockfrostUTxO of response.outputs) {
+			if (blockfrostUTxO.output_index !== txIn.index) continue;
+			const coreTxOut = require_blockfrost_tx_submit_provider.BlockfrostToCardanoSDK.txOut(blockfrostUTxO);
+			this.logger.debug(`Resolved input ${txIn.txId}#${txIn.index} from Blockfrost`);
+			return coreTxOut;
+		}
+		this.logger.error(`Failed to resolve input ${txIn.txId}#${txIn.index}`);
+		return null;
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-stake-pool-provider.ts
+var BlockfrostStakePoolProvider = class extends require_blockfrost_tx_submit_provider.BlockfrostProvider {
+	constructor(client, logger) {
+		super(client, logger);
+	}
+	async getMetadata(poolId) {
+		try {
+			const metadata = await this.request(`pools/${poolId}/metadata`);
+			return Object.keys(metadata).length ? metadata : null;
+		} catch (error) {
+			if (error instanceof _laceio_cardano_core.ProviderError) {
+				if (error.reason === _laceio_cardano_core.ProviderFailure.NotFound) return null;
+				throw error;
+			}
+			throw require_error.toProviderError(error);
+		}
+	}
+	async getNetworkData() {
+		try {
+			const [genesis, params, network, retiring] = await Promise.all([
+				this.request("genesis"),
+				this.request("epochs/latest/parameters"),
+				this.request("network"),
+				this.paginatedRequests({
+					endpoint: "pools/retiring",
+					pageSize: 100
+				})
+			]);
+			return {
+				activeSlotsCoefficient: genesis.active_slots_coefficient,
+				desiredNumberOfPools: params.n_opt,
+				epochLength: genesis.epoch_length,
+				liveStake: Number(network.stake.live),
+				maxLovelaceSupply: Number(network.supply.max),
+				monetaryExpansion: params.rho,
+				poolInfluence: params.a0,
+				reserves: Number(network.supply.reserves),
+				retiringPools: retiring.map((pool) => pool.pool_id),
+				slotLength: genesis.slot_length,
+				timestamp: 0,
+				treasuryCut: params.tau
+			};
+		} catch (error) {
+			throw require_error.toProviderError(error);
+		}
+	}
+	async getStakePool(poolId) {
+		try {
+			return await this.request(`pools/${poolId}`);
+		} catch (error) {
+			if (error instanceof _laceio_cardano_core.ProviderError) {
+				if (error.reason === _laceio_cardano_core.ProviderFailure.NotFound) return null;
+				throw error;
+			}
+			throw require_error.toProviderError(error);
+		}
+	}
+	async getStakePools() {
+		try {
+			return await this.paginatedRequests({
+				endpoint: "pools/extended",
+				pageSize: 100
+			});
+		} catch (error) {
+			throw require_error.toProviderError(error);
+		}
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-rewards-provider.ts
+/**
+* Blockfrost returns 404 from the `accounts/*` endpoints for a stake address
+* that has never appeared on-chain. That is a normal state for a fresh
+* account, not an error: it means "never registered, nothing staked, no
+* rewards".
+*/
+const NEVER_ACTIVE_REWARD_ACCOUNT_INFO = {
+	isActive: false,
+	isRegistered: false,
+	rewardsSum: require_bignum_vo.BigNumber(0n),
+	withdrawableAmount: require_bignum_vo.BigNumber(0n),
+	controlledAmount: require_bignum_vo.BigNumber(0n)
+};
+var BlockfrostRewardsProvider = class extends require_blockfrost_tx_submit_provider.BlockfrostProvider {
+	constructor(client, logger) {
+		super(client, logger);
+	}
+	/**
+	* Fetches the total rewards balance for a given reward account.
+	*
+	* @param rewardAccount - CardanoRewardAccount to fetch the balance for
+	* @param epochs - Optional range of epochs to filter the rewards
+	* @returns Observable with Result containing the rewards or an error
+	*/
+	getAccountRewards({ rewardAccount }) {
+		return (0, rxjs.defer)(async () => this.paginatedRequests({
+			endpoint: `accounts/${rewardAccount}/rewards?order=desc`,
+			pageSize: 100
+		})).pipe((0, rxjs.map)((rewards) => require_asyncoption.Ok(rewards.map((reward) => ({
+			epoch: _laceio_cardano_core.Cardano.EpochNo(reward.epoch),
+			rewards: require_bignum_vo.BigNumber(BigInt(reward.amount)),
+			poolId: _laceio_cardano_core.Cardano.PoolId(reward.pool_id)
+		})))), (0, rxjs.catchError)((error) => {
+			if (require_error.isNotFoundError(error)) return (0, rxjs.of)(require_asyncoption.Ok([]));
+			return (0, rxjs.of)(require_asyncoption.Err(error));
+		}));
+	}
+	/**
+	* Fetches stake account information for a given reward account.
+	*
+	* @param rewardAccount - CardanoRewardAccount to fetch info for
+	* @returns Observable with Result containing RewardAccountInfo or an error
+	*/
+	getRewardAccountInfo({ rewardAccount }) {
+		return (0, rxjs.from)(this.request(`accounts/${rewardAccount}`).then((account) => require_asyncoption.Ok({
+			isActive: account.active,
+			isRegistered: account.registered ?? account.active,
+			...account.pool_id && { poolId: _laceio_cardano_core.Cardano.PoolId(account.pool_id) },
+			...account.drep_id && { drepId: account.drep_id },
+			rewardsSum: require_bignum_vo.BigNumber(BigInt(account.rewards_sum)),
+			withdrawableAmount: require_bignum_vo.BigNumber(BigInt(account.withdrawable_amount)),
+			controlledAmount: require_bignum_vo.BigNumber(BigInt(account.controlled_amount))
+		})).catch((error) => {
+			if (require_error.isNotFoundError(error)) return require_asyncoption.Ok(NEVER_ACTIVE_REWARD_ACCOUNT_INFO);
+			return require_asyncoption.Err(error);
+		}));
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-delegations-provider.ts
+var BlockfrostDelegationsProvider = class extends require_blockfrost_tx_submit_provider.BlockfrostProvider {
+	constructor(client, logger) {
+		super(client, logger);
+	}
+	/**
+	* Fetches all delegation history for a given reward account.
+	*
+	* @param rewardAccount - CardanoRewardAccount to fetch the delegations for
+	* @returns Observable with Result containing all delegations or an error
+	*/
+	getAccountDelegations({ rewardAccount }) {
+		return (0, rxjs.from)(this.paginatedRequests({
+			endpoint: `accounts/${rewardAccount}/delegations?order=desc`,
+			pageSize: 100
+		})).pipe((0, rxjs.map)((delegations) => require_asyncoption.Ok(delegations.map((delegation) => ({
+			activeEpoch: _laceio_cardano_core.Cardano.EpochNo(delegation.active_epoch),
+			txHash: _laceio_cardano_core.Cardano.TransactionId(delegation.tx_hash),
+			amount: require_bignum_vo.BigNumber(BigInt(delegation.amount)),
+			poolId: _laceio_cardano_core.Cardano.PoolId(delegation.pool_id)
+		})))), (0, rxjs.catchError)((error) => (0, rxjs.of)(require_asyncoption.Err(error))));
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-governance-provider.ts
+const PAGE_SIZE = 100;
+const jsonLdString = (value) => {
+	if (typeof value === "string") return value;
+	if (typeof value === "object" && value !== null && "@value" in value) {
+		const inner = value["@value"];
+		return typeof inner === "string" ? inner : void 0;
+	}
+};
+const getMetadataBody = (jsonMetadata) => {
+	if (typeof jsonMetadata !== "object" || jsonMetadata === null) return void 0;
+	const body = jsonMetadata.body;
+	if (typeof body !== "object" || body === null) return void 0;
+	return body;
+};
+const extractReferences = (references) => {
+	if (!Array.isArray(references)) return void 0;
+	const parsed = references.flatMap((reference) => {
+		if (typeof reference !== "object" || reference === null) return [];
+		const { uri, label } = reference;
+		const uriValue = jsonLdString(uri);
+		if (uriValue === void 0) return [];
+		const labelValue = jsonLdString(label);
+		return [{
+			uri: uriValue,
+			...labelValue !== void 0 && { label: labelValue }
+		}];
+	});
+	return parsed.length > 0 ? parsed : void 0;
+};
+const extractMetadata = (envelope, body) => {
+	const metadata = {};
+	if (typeof envelope?.url === "string") metadata.metadataUrl = envelope.url;
+	if (typeof envelope?.hash === "string") metadata.metadataHash = envelope.hash;
+	const assign = (key, value) => {
+		const parsed = jsonLdString(value);
+		if (parsed !== void 0) metadata[key] = parsed;
+	};
+	if (body) {
+		assign("imageUrl", (typeof body.image === "object" && body.image !== null ? body.image : void 0)?.contentUrl);
+		assign("bio", body.bio);
+		assign("email", body.email);
+		assign("objectives", body.objectives);
+		assign("motivations", body.motivations);
+		assign("qualifications", body.qualifications);
+		assign("paymentAddress", body.paymentAddress);
+		const references = extractReferences(body.references);
+		if (references) metadata.references = references;
+	}
+	return Object.keys(metadata).length > 0 ? metadata : void 0;
+};
+const toDRepSummary = (item) => {
+	const credential = {
+		hash: (0, _laceio_cardano_crypto.Hash28ByteBase16)(item.hex.length === 58 ? item.hex.slice(2) : item.hex),
+		type: item.has_script ? _laceio_cardano_core.Cardano.CredentialType.ScriptHash : _laceio_cardano_core.Cardano.CredentialType.KeyHash
+	};
+	const body = getMetadataBody(item.metadata?.json_metadata);
+	return {
+		drepId: _laceio_cardano_core.Cardano.DRepID(item.drep_id),
+		cip105DrepId: _laceio_cardano_core.Cardano.DRepID.cip105FromCredential(credential),
+		hex: item.hex,
+		isActive: !item.retired && !item.expired,
+		retired: item.retired,
+		expired: item.expired,
+		amount: item.amount,
+		hasScript: item.has_script,
+		name: jsonLdString(body?.givenName),
+		metadata: extractMetadata(item.metadata, body)
+	};
+};
+var BlockfrostGovernanceProvider = class extends require_blockfrost_tx_submit_provider.BlockfrostProvider {
+	constructor(client, logger) {
+		super(client, logger);
+	}
+	getDReps() {
+		const fetchPage = (page) => (0, rxjs.from)(this.request(`governance/dreps?page=${page}&count=${PAGE_SIZE}`));
+		return fetchPage(1).pipe((0, rxjs.expand)((items, index) => items.length === PAGE_SIZE ? fetchPage(index + 2) : rxjs.EMPTY), (0, rxjs.reduce)((accumulated, items) => [...accumulated, ...items], []), (0, rxjs.map)((all) => require_asyncoption.Ok(all.filter((d) => d.drep_id.startsWith("drep1")).map((item) => toDRepSummary(item)))), (0, rxjs.catchError)((error) => (0, rxjs.of)(require_asyncoption.Err(error))));
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-registrations-provider.ts
+var BlockfrostRegistrationsProvider = class extends require_blockfrost_tx_submit_provider.BlockfrostProvider {
+	constructor(client, logger) {
+		super(client, logger);
+	}
+	/**
+	* Fetches all registration history for a given reward account.
+	*
+	* @param rewardAccount - CardanoRewardAccount to fetch the registrations for
+	* @returns Observable with Result containing all registrations or an error
+	*/
+	getAccountRegistrations({ rewardAccount }) {
+		return (0, rxjs.from)(this.paginatedRequests({
+			endpoint: `accounts/${rewardAccount}/registrations?order=desc`,
+			pageSize: 100
+		})).pipe((0, rxjs.map)((registrations) => require_asyncoption.Ok(registrations.map((registration) => ({
+			txHash: _laceio_cardano_core.Cardano.TransactionId(registration.tx_hash),
+			action: registration.action
+		})))), (0, rxjs.catchError)((error) => (0, rxjs.of)(require_asyncoption.Err(error))));
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-withdrawals-provider.ts
+var BlockfrostWithdrawalsProvider = class extends require_blockfrost_tx_submit_provider.BlockfrostProvider {
+	constructor(client, logger) {
+		super(client, logger);
+	}
+	/**
+	* Fetches all withdrawal history for a given reward account.
+	*
+	* @param rewardAccount - CardanoRewardAccount to fetch the withdrawals for
+	* @returns Observable with Result containing all withdrawals or an error
+	*/
+	getAccountWithdrawals({ rewardAccount }) {
+		return (0, rxjs.from)(this.paginatedRequests({
+			endpoint: `accounts/${rewardAccount}/withdrawals?order=desc`,
+			pageSize: 100
+		})).pipe((0, rxjs.map)((withdrawals) => require_asyncoption.Ok(withdrawals.map((withdrawal) => ({
+			txHash: _laceio_cardano_core.Cardano.TransactionId(withdrawal.tx_hash),
+			amount: require_bignum_vo.BigNumber(BigInt(withdrawal.amount))
+		})))), (0, rxjs.catchError)((error) => (0, rxjs.of)(require_asyncoption.Err(error))));
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/provider/blockfrost-tx-evaluation-provider.ts
+const REDEEMER_PURPOSE_BY_NAME = {
+	spend: _laceio_cardano_core.Cardano.RedeemerPurpose.spend,
+	mint: _laceio_cardano_core.Cardano.RedeemerPurpose.mint,
+	certificate: _laceio_cardano_core.Cardano.RedeemerPurpose.certificate,
+	publish: _laceio_cardano_core.Cardano.RedeemerPurpose.certificate,
+	withdrawal: _laceio_cardano_core.Cardano.RedeemerPurpose.withdrawal,
+	withdraw: _laceio_cardano_core.Cardano.RedeemerPurpose.withdrawal,
+	vote: _laceio_cardano_core.Cardano.RedeemerPurpose.vote,
+	propose: _laceio_cardano_core.Cardano.RedeemerPurpose.propose
+};
+const toExUnits = (budget) => {
+	if (typeof budget !== "object" || budget === null) return void 0;
+	const { memory, steps, cpu } = budget;
+	const stepsValue = typeof steps === "number" ? steps : typeof cpu === "number" ? cpu : void 0;
+	if (typeof memory !== "number" || stepsValue === void 0) return void 0;
+	return {
+		memory,
+		steps: stepsValue
+	};
+};
+/** `"<purpose>:<index>"` (v5) or a `{ purpose, index }` object (v6). */
+const toRedeemerRef = (validator) => {
+	const { name, index } = typeof validator === "string" ? {
+		name: validator.split(":")[0],
+		index: Number(validator.split(":")[1] ?? "0")
+	} : {
+		name: validator?.purpose,
+		index: validator?.index ?? 0
+	};
+	const purpose = REDEEMER_PURPOSE_BY_NAME[name?.toLowerCase() ?? ""];
+	if (!purpose || !Number.isInteger(index)) return void 0;
+	return {
+		purpose,
+		index
+	};
+};
+const fromEvaluationResult = (evaluationResult) => Object.entries(evaluationResult).flatMap(([key, value]) => {
+	const ref = toRedeemerRef(key);
+	const budget = toExUnits(value);
+	return ref && budget ? [{
+		...ref,
+		budget
+	}] : [];
+});
+const fromEvaluationEntries = (entries) => entries.flatMap((entry) => {
+	const ref = toRedeemerRef(entry.validator);
+	const budget = toExUnits(entry.budget ?? entry.ex_units);
+	return ref && budget ? [{
+		...ref,
+		budget
+	}] : [];
+});
+/**
+* An empty list only for a collection that was itself empty. A NON-EMPTY
+* collection none of whose entries parsed is a dialect this parser does not
+* know, not a transaction without redeemers — reporting it as `[]` would spend
+* the contract's "no redeemers" answer on the drift this dual parser exists to
+* surface.
+*/
+const parsedOrUnrecognised = (sourceCount, parsed) => sourceCount > 0 && parsed.length === 0 ? void 0 : parsed;
+/**
+* Both dialects, unwrapped from the optional `result` envelope. `undefined`
+* distinguishes "this is not an evaluation" (a fault, an `EvaluationFailure`,
+* an unknown shape, a known envelope carrying only unreadable entries) from a
+* transaction that carries no redeemers, which legitimately evaluates to an
+* empty list.
+*/
+const parseEvaluation = (data) => {
+	const body = typeof data === "object" && data !== null && "result" in data ? data.result : data;
+	if (Array.isArray(body)) {
+		const entries = body;
+		return parsedOrUnrecognised(entries.length, fromEvaluationEntries(entries));
+	}
+	if (typeof body === "object" && body !== null) {
+		const { EvaluationResult: evaluationResult } = body;
+		if (typeof evaluationResult === "object" && evaluationResult !== null) {
+			const result = evaluationResult;
+			return parsedOrUnrecognised(Object.keys(result).length, fromEvaluationResult(result));
+		}
+	}
+};
+/** Truncated so a multi-kilobyte script trace cannot flood the log or the error. */
+const describeUnusableResponse = (data) => {
+	try {
+		return JSON.stringify(data)?.slice(0, 500) ?? "undefined";
+	} catch {
+		return String(data);
+	}
+};
+var BlockfrostTxEvaluationProvider = class extends require_blockfrost_tx_submit_provider.BlockfrostProvider {
+	constructor(client, logger) {
+		super(client, logger);
+	}
+	/**
+	* Evaluate a transaction's per-redeemer execution units.
+	*
+	* @param tx - transaction CBOR (unsigned is fine)
+	* @returns Observable with the per-redeemer budgets, or an error when the
+	* network declined to evaluate (script failure, provider fault, HTTP error).
+	*/
+	evaluateTx({ tx }) {
+		return (0, rxjs.from)(this.request("utils/txs/evaluate", {
+			body: tx,
+			headers: { "Content-Type": "application/cbor" },
+			method: "POST"
+		}).then((data) => {
+			const evaluated = parseEvaluation(data);
+			if (evaluated) return require_asyncoption.Ok(evaluated);
+			const detail = describeUnusableResponse(data);
+			this.logger.warn("evaluateTx: no evaluation in response", detail);
+			return require_asyncoption.Err(new _laceio_cardano_core.ProviderError(_laceio_cardano_core.ProviderFailure.InvalidResponse, void 0, detail));
+		}).catch((error) => require_asyncoption.Err(error)));
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/util.ts
+const serializeMetadatum = ((value, stringifyComposite = false) => {
+	if (typeof value === "string") return value;
+	if (typeof value === "bigint") return value.toString();
+	if (Array.isArray(value)) {
+		const serializedItems = value.map((item) => serializeMetadatum(item));
+		return stringifyComposite ? JSON.stringify(serializedItems) : serializedItems;
+	}
+	if (value instanceof Map) {
+		const serializedEntries = Object.fromEntries([...value.entries()].map(([key, nestedValue]) => [metadatumKeyToString(key), serializeMetadatum(nestedValue)]));
+		return stringifyComposite ? JSON.stringify(serializedEntries) : serializedEntries;
+	}
+	if (value instanceof Uint8Array) try {
+		return new TextDecoder("utf-8", { fatal: true }).decode(value);
+	} catch {
+		return `[Invalid UTF-8: ${value.length} bytes]`;
+	}
+	return String(value);
+});
+const metadatumKeyToString = (value) => serializeMetadatum(value, true);
+const metadatumToSerializableValue = (value) => serializeMetadatum(value);
+const mapToRecord = (map) => [...map?.entries() || []].map(([key, value]) => [key, metadatumToSerializableValue(value)]).reduce((result, [key, value]) => {
+	result[key] = value;
+	return result;
+}, {});
+const mergeDefinedProperties = (properties) => {
+	const definedProperties = properties.filter((property) => property[1] !== void 0);
+	if (definedProperties.length === 0) return;
+	return Object.fromEntries(definedProperties);
+};
+const toContractTokenMetadata = (assetInfo) => ({
+	blockchainSpecific: {
+		metadataSchemaVersion: 1,
+		updatedAt: require_time_vo.Timestamp.now(),
+		policyId: assetInfo.policyId.toString(),
+		files: assetInfo.nftMetadata?.files?.map((file) => ({
+			mediaType: file.mediaType,
+			src: file.src,
+			name: file.name,
+			additionalProperties: mapToRecord(file.otherProperties)
+		}))
+	},
+	decimals: assetInfo.tokenMetadata?.decimals || 0,
+	additionalProperties: mergeDefinedProperties([["description", assetInfo.nftMetadata?.description], ...Object.entries(mapToRecord(assetInfo.nftMetadata?.otherProperties) ?? {})]),
+	image: assetInfo.nftMetadata?.image || assetInfo.tokenMetadata?.icon,
+	isNft: assetInfo.supply === 1n,
+	name: assetInfo.nftMetadata?.name || assetInfo.tokenMetadata?.name || assetInfo.fingerprint,
+	ticker: assetInfo.tokenMetadata?.ticker
+});
+/** Base lovelace metadata; ticker and image are set per-network in Blockfrost dependencies. */
+const LOVELACE_METADATA = {
+	decimals: 6,
+	name: "Cardano",
+	ticker: "ADA",
+	blockchainSpecific: {
+		metadataSchemaVersion: 1,
+		updatedAt: require_time_vo.Timestamp.now()
+	}
+};
+//#endregion
+//#region ../../packages/lib/cardano-provider-core/src/blockfrost-config.ts
+var import_lib = /* @__PURE__ */ require_rolldown_runtime.__toESM(require_lib$1.require_lib());
+const computeBlockfrostConfigIdentifier = ({ clientConfig: { baseUrl, projectId } }) => `${baseUrl}-${projectId}`;
+const getBlockfrostClient = (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(["api", clientConfig.apiVersion], clientConfig.baseUrl),
+		requestInit: { headers: { ...clientConfig.projectId && { project_id: clientConfig.projectId } } }
+	}, { rateLimiter });
+}, computeBlockfrostConfigIdentifier);
+const Blockchains = {
+	Cardano: "data:image/png;base64,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",
+	Bitcoin: "data:image/png;base64,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"
+};
+//#endregion
+//#region ../../packages/module/cardano-provider-blockfrost/src/store/dependencies.ts
+const getNetworkInfoProvider = (0, lodash_memoize.default)((config, logger) => {
+	return new require_blockfrost_tx_submit_provider.BlockfrostNetworkInfoProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getAssetProvider = (0, lodash_memoize.default)((config, logger) => {
+	return new BlockfrostAssetProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getAddressDiscoveryProvider = (0, lodash_memoize.default)((config, logger) => {
+	return new BlockfrostAddressDiscovery(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getInputResolverProvider = (0, lodash_memoize.default)((config, logger) => {
+	return new BlockfrostInputResolverProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getTokensProvider = (0, lodash_memoize.default)((config, logger) => {
+	return new BlockfrostTokensProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getAccountActivityProvider = (0, lodash_memoize.default)((config, logger) => {
+	return new BlockfrostActivityProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getAccountRewardsProvider = (0, lodash_memoize.default)((config, logger) => {
+	return new BlockfrostRewardsProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getAccountDelegationsProvider = (0, lodash_memoize.default)((config, logger) => {
+	return new BlockfrostDelegationsProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getAccountRegistrationsProvider = (0, lodash_memoize.default)((config, logger) => {
+	return new BlockfrostRegistrationsProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getAccountWithdrawalsProvider = (0, lodash_memoize.default)((config, logger) => {
+	return new BlockfrostWithdrawalsProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getStakePoolProvider = (0, lodash_memoize.default)((config, logger) => {
+	return new BlockfrostStakePoolProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getUtxoProvider = (0, lodash_memoize.default)((config, logger) => {
+	return new require_blockfrost_tx_submit_provider.BlockfrostUtxoProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getTxSubmitProvider = (0, lodash_memoize.default)((config, logger) => {
+	return new require_blockfrost_tx_submit_provider.BlockfrostTxSubmitProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getTxEvaluationProvider = (0, lodash_memoize.default)((config, logger) => {
+	return new BlockfrostTxEvaluationProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getGovernanceProvider = (0, lodash_memoize.default)((config, logger) => {
+	return new BlockfrostGovernanceProvider(getBlockfrostClient(config), logger);
+}, computeBlockfrostConfigIdentifier);
+const getBlockfrostConfig = (context, configs) => {
+	const config = configs[context.chainId.networkMagic];
+	if (!config) throw new Error(`Assertion failed: no blockfrost config found (${context.chainId.networkMagic}`);
+	return config;
+};
+const initializeDependencies = async ({ runtime: { config: { cardanoProvider: { blockfrostConfigs } } }, loadModules }, { logger }) => {
+	const bip32Ed25519 = (await loadModules("addons.bip32Ed25519"))[0];
+	const dependencies = {
+		blake2b: (await loadModules("addons.blake2b"))[0],
+		bip32Ed25519
+	};
+	return {
+		cardanoProvider: {
+			getTip: (context) => {
+				return (0, rxjs.from)(getNetworkInfoProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).ledgerTip().then(require_asyncoption.Ok).catch(require_asyncoption.Err));
+			},
+			getProtocolParameters: (context) => {
+				const provider = getNetworkInfoProvider(getBlockfrostConfig(context, blockfrostConfigs), logger);
+				return (0, rxjs.defer)(async () => provider.protocolParameters().then(require_asyncoption.Ok).catch(require_asyncoption.Err));
+			},
+			getEraSummaries: (context) => {
+				const provider = getNetworkInfoProvider(getBlockfrostConfig(context, blockfrostConfigs), logger);
+				return (0, rxjs.defer)(async () => provider.eraSummaries().then(require_asyncoption.Ok).catch(require_asyncoption.Err));
+			},
+			discoverAddresses: ({ xpub, accountIndex, thorough }, context) => {
+				const provider = getAddressDiscoveryProvider(getBlockfrostConfig(context, blockfrostConfigs), logger);
+				const account = new _laceio_cardano_key_management.Bip32Account({
+					extendedAccountPublicKey: xpub,
+					chainId: context.chainId,
+					accountIndex
+				}, dependencies);
+				return provider.discover(account, { thorough }).pipe((0, rxjs.map)((result) => result.map((address) => require_util.toContractAddress(address, context.chainId.networkMagic))));
+			},
+			getTokenMetadata: ({ tokenId }, context) => {
+				if (tokenId === require_const.LOVELACE_TOKEN_ID) {
+					const ticker = require_cardano_network_id_to_network_type.getAdaTokenTickerByNetwork(require_cardano_network_id_to_network_type.cardanoNetworkMagicToNetworkType(context.chainId.networkMagic));
+					return (0, rxjs.of)(require_asyncoption.Ok({
+						...LOVELACE_METADATA,
+						ticker,
+						image: Blockchains.Cardano
+					}));
+				}
+				const provider = getAssetProvider(getBlockfrostConfig(context, blockfrostConfigs), logger);
+				const assetId = _laceio_cardano_core.Cardano.AssetId(tokenId);
+				return (0, rxjs.defer)(async () => provider.getAsset({
+					assetId,
+					extraData: {
+						nftMetadata: true,
+						tokenMetadata: true
+					}
+				}).then((assetInfo) => require_asyncoption.Ok(toContractTokenMetadata(assetInfo))).catch(require_asyncoption.Err));
+			},
+			getTokens: (props, context) => {
+				return getTokensProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getTokens(props);
+			},
+			getAccountRewards: (props, context) => {
+				return getAccountRewardsProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getAccountRewards(props);
+			},
+			getAccountDelegations: (props, context) => {
+				return getAccountDelegationsProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getAccountDelegations(props);
+			},
+			getAccountRegistrations: (props, context) => {
+				return getAccountRegistrationsProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getAccountRegistrations(props);
+			},
+			getAccountWithdrawals: (props, context) => {
+				return getAccountWithdrawalsProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getAccountWithdrawals(props);
+			},
+			getRewardAccountInfo: (props, context) => {
+				return getAccountRewardsProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getRewardAccountInfo(props);
+			},
+			getAccountUtxos: (props, context) => {
+				return getUtxoProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getAccountUtxos(props);
+			},
+			getUtxosAtAddress: (props, context) => {
+				return getUtxoProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getUtxosAtAddress(props);
+			},
+			getAddressTransactionHistory: (props, context) => {
+				return getAccountActivityProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getAddressTransactionHistory(props);
+			},
+			getTransactionDetails: (txId, context) => {
+				return getAccountActivityProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getTransactionDetails(txId);
+			},
+			resolveInput: (txIn, context) => {
+				const provider = getInputResolverProvider(getBlockfrostConfig(context, blockfrostConfigs), logger);
+				return (0, rxjs.defer)(async () => provider.resolveInput(txIn).then(require_asyncoption.Ok).catch(require_asyncoption.Err));
+			},
+			submitTx: (props, context) => {
+				return (0, rxjs.from)(getTxSubmitProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).submitTx(props).then((id) => require_asyncoption.Ok(_laceio_cardano_core.Cardano.TransactionId(id))).catch(require_asyncoption.Err));
+			},
+			evaluateTx: (props, context) => {
+				return getTxEvaluationProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).evaluateTx(props);
+			},
+			getDReps: (context) => {
+				return getGovernanceProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getDReps();
+			}
+		},
+		cardanoStakePoolsProvider: {
+			getMetadata: (poolId, context) => {
+				return (0, rxjs.from)(getStakePoolProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getMetadata(poolId).then(require_asyncoption.Ok).catch(require_asyncoption.Err));
+			},
+			getNetworkData: (context) => {
+				return (0, rxjs.from)(getStakePoolProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getNetworkData().then(require_asyncoption.Ok).catch(require_asyncoption.Err));
+			},
+			getStakePool: (poolId, context) => {
+				return (0, rxjs.from)(getStakePoolProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getStakePool(poolId).then(require_asyncoption.Ok).catch(require_asyncoption.Err));
+			},
+			getStakePools: (context) => {
+				return (0, rxjs.from)(getStakePoolProvider(getBlockfrostConfig(context, blockfrostConfigs), logger).getStakePools().then(require_asyncoption.Ok).catch(require_asyncoption.Err));
+			}
+		}
+	};
+};
+//#endregion
+//#region ../../packages/module/cardano-provider-blockfrost/src/store/init.ts
+const redux = async (props, dependencies) => ({ sideEffectDependencies: await initializeDependencies(props, dependencies) });
+//#endregion
+exports.default = redux;