@laceio/sdk 0.1.1-canary.2 → 0.1.1

package/dist/init-TkPDD750.js

@@ -0,0 +1,363 @@
+import "./libsodium-wrappers-UH0LaOUE.js";
+import { r as SecretBox, t as ByteArray } from "./bytes.vo-TgiwogWF.js";
+import { n as filterSpendableUtxos, t as createInputResolver } from "./util-BaLzwa32.js";
+import { t as BigNumber } from "./bignum.vo-B0rK_PQ1.js";
+import { n as Ok, t as Err } from "./asyncoption-Cw07zPH7.js";
+import { t as firstStateOfStatus } from "./first-state-of-status-DQnMT3ya.js";
+import { t as CardanoNetworkId } from "./cardano-network-id.vo-CK1tNQDg.js";
+import { r as LOVELACE_TOKEN_ID } from "./const-C84qHkjp.js";
+import { n as InputSelectionError, t as TransactionBuilder } from "./TransactionBuilder-V6aLx4SV.js";
+import { t as applyVkeyWitnesses } from "./apply-vkey-witnesses-ClZbpk5w.js";
+import { t as refuseExtensionAccount } from "./account-guards.stable-JRQ5qx2V.js";
+import { InMemoryKeyAgent, KeyPurpose, util } from "@laceio/cardano/key-management";
+import { SodiumBip32Ed25519 } from "@laceio/cardano/crypto";
+import { Cardano, metadatum } from "@laceio/cardano/core";
+import { catchError, filter, firstValueFrom, forkJoin, from, map, mergeMap, of, switchMap } from "rxjs";
+import { computeMinimumCoinQuantity, tokenBundleSizeExceedsLimit } from "@laceio/cardano/tx-construction";
+//#region ../../packages/contract/cardano-context/src/value-objects/cardano-testnet-id.vo.ts
+const CARDANO_CHAIN_ID_BY_TESTNET = {
+	preprod: Cardano.ChainIds.Preprod,
+	preview: Cardano.ChainIds.Preview,
+	sanchonet: Cardano.ChainIds.Sanchonet
+};
+const PREPROD_MAGIC = Number(Cardano.ChainIds.Preprod.networkMagic);
+const PREVIEW_MAGIC = Number(Cardano.ChainIds.Preview.networkMagic);
+const SANCHONET_MAGIC = Number(Cardano.ChainIds.Sanchonet.networkMagic);
+const getCardanoTestnetIdByNetworkMagic = (networkMagic) => {
+	const magic = Number(networkMagic);
+	if (magic === PREPROD_MAGIC) return "preprod";
+	if (magic === PREVIEW_MAGIC) return "preview";
+	if (magic === SANCHONET_MAGIC) return "sanchonet";
+};
+const getCardanoChainIdByTestnetId = (id) => CARDANO_CHAIN_ID_BY_TESTNET[id];
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/composer/resolve-validity-interval.ts
+/** Two hours, matching the send flow's window (`build-tx.ts`). */
+const DEFAULT_VALIDITY_SECONDS = 7200;
+/**
+* The era covering `slot`: the last summary that has already started.
+* Summaries arrive oldest-first, so this walks forward while the next
+* era's start is still at or below the slot.
+*/
+const eraSummaryAtSlot = (eraSummaries, slot) => {
+	let index = 0;
+	while (index + 1 < eraSummaries.length && eraSummaries[index + 1].start.slot <= slot) index++;
+	return eraSummaries[index];
+};
+const secondsToSlots = (seconds, slotLengthMs) => Math.ceil(seconds * 1e3 / slotLengthMs);
+/**
+* Convert a tip-relative duration into the absolute slots a Cardano
+* validity interval needs.
+*
+* @throws If the era summaries are missing/unusable, or the requested
+*   window is not a positive, coherent interval.
+*/
+const resolveValidityInterval = ({ tipSlot, eraSummaries, validitySeconds = DEFAULT_VALIDITY_SECONDS, validityStartSeconds }) => {
+	if (eraSummaries.length === 0) throw new Error("Cannot resolve a validity interval: no Cardano era summaries available");
+	if (!Number.isFinite(validitySeconds) || validitySeconds <= 0) throw new Error(`Validity window must be a positive number of seconds, got ${validitySeconds}`);
+	const { slotLength } = eraSummaryAtSlot(eraSummaries, tipSlot).parameters;
+	if (!Number.isFinite(slotLength) || slotLength <= 0) throw new Error(`Era summary reports an unusable slot length: ${slotLength}`);
+	const invalidHereafter = Cardano.Slot(tipSlot + secondsToSlots(validitySeconds, slotLength));
+	if (validityStartSeconds === void 0) return { invalidHereafter };
+	if (!Number.isFinite(validityStartSeconds) || validityStartSeconds < 0) throw new Error(`Validity start must be a non-negative number of seconds, got ${validityStartSeconds}`);
+	const invalidBefore = Cardano.Slot(tipSlot + secondsToSlots(validityStartSeconds, slotLength));
+	if (invalidBefore >= invalidHereafter) throw new Error(`Validity window is empty: start slot ${invalidBefore} is not before end slot ${invalidHereafter}`);
+	return {
+		invalidBefore,
+		invalidHereafter
+	};
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/composer/build-composer-tx.ts
+/** Failure with a code the side-effect maps to actionable copy. */
+const fail = (message, code) => Object.assign(new Error(message), { code });
+const utxoRefKey = (txIn) => `${txIn.txId}#${txIn.index}`;
+/**
+* An address from the request, as the SDK's payment address.
+*
+* The SDK's own constructor throws an UNCODED `InvalidStringError`, which would
+* reach the side-effect as a build fault rather than as the request mistake it
+* is — a bech32 the user mistyped would then read as "we couldn't build your
+* transaction" instead of "check what you entered".
+*
+* @param what - names the address in the message, since a request may carry
+* several and the failure has to say which one is unusable.
+*/
+const toPaymentAddress = (value, what) => {
+	try {
+		return Cardano.PaymentAddress(value);
+	} catch {
+		throw fail(`${what} is not a Cardano address: "${value}"`, "invalid-address");
+	}
+};
+/**
+* Quantities cross the slice boundary as decimal strings, so a malformed
+* one is a request error rather than a programming error — parse it into
+* a coded failure instead of letting `BigInt` throw an uncoded SyntaxError.
+*/
+const toQuantity = (value, what) => {
+	if (!/^-?\d+$/.test(value)) throw fail(`${what} is not a whole number: "${value}"`, "invalid-output");
+	return BigInt(value);
+};
+const toValue = (output) => {
+	const coins = toQuantity(output.lovelace, `Lovelace amount for the output to ${output.address}`);
+	if (coins < 0n) throw fail(`Output to ${output.address} requests a negative amount of lovelace`, "invalid-output");
+	if (!output.assets || output.assets.length === 0) return { coins };
+	const assets = /* @__PURE__ */ new Map();
+	for (const asset of output.assets) {
+		const quantity = toQuantity(asset.quantity, `Quantity for asset ${asset.assetId}`);
+		if (quantity <= 0n) throw fail(`Asset ${asset.assetId} requests a non-positive quantity`, "invalid-output");
+		const assetId = asset.assetId;
+		assets.set(assetId, (assets.get(assetId) ?? 0n) + quantity);
+	}
+	return {
+		coins,
+		assets
+	};
+};
+/**
+* Raise the output's lovelace to the protocol minimum for its size when
+* the request is below it. An assets-only output can therefore ask for
+* `'0'` and still be spendable.
+*/
+const withMinimumCoin = (address, value, params) => {
+	if (tokenBundleSizeExceedsLimit(params.maxValueSize)(value.assets)) throw fail(`Output to ${address} exceeds the maximum token bundle size`, "invalid-output");
+	const minimumCoin = BigInt(computeMinimumCoinQuantity(params.coinsPerUtxoByte)({
+		address,
+		value
+	}));
+	return value.coins >= minimumCoin ? value : {
+		...value,
+		coins: minimumCoin
+	};
+};
+const parseMetadata = (request) => {
+	if (!request.metadata || request.metadata.length === 0) return void 0;
+	const blob = /* @__PURE__ */ new Map();
+	for (const entry of request.metadata) {
+		if (!/^\d+$/.test(entry.label)) throw fail(`Metadata label "${entry.label}" is not a non-negative integer`, "invalid-metadata");
+		let parsed;
+		try {
+			parsed = JSON.parse(entry.json);
+		} catch (error) {
+			throw fail(`Metadata for label ${entry.label} is not valid JSON: ${error.message}`, "invalid-metadata");
+		}
+		blob.set(BigInt(entry.label), metadatum.jsonToMetadatum(parsed));
+	}
+	return blob;
+};
+const resolveSelectedInputs = (request, spendableUtxos) => {
+	if (!request.selectedInputs || request.selectedInputs.length === 0) return [];
+	const byRef = new Map(spendableUtxos.map((utxo) => [utxoRefKey(utxo[0]), utxo]));
+	return request.selectedInputs.map((ref) => {
+		const utxo = byRef.get(`${ref.txId}#${ref.index}`);
+		if (!utxo) throw fail(`Selected input ${ref.txId}#${ref.index} is not among the account's spendable UTxOs`, "input-unavailable");
+		return utxo;
+	});
+};
+/**
+* The balancer's own failure type is the only signal that the account cannot
+* cover what was asked for — an unaffordable amount is a request mistake, not a
+* build fault, and only the coded form reaches the copy that says so.
+*
+* Tagged rather than replaced: the reported name and message stay the
+* balancer's, which is what names the shortfall for a diagnostic.
+*/
+const codeInputSelectionFailure = async (build) => {
+	try {
+		return await build;
+	} catch (error) {
+		if (error instanceof InputSelectionError) throw Object.assign(error, { code: "insufficient-funds" });
+		throw error;
+	}
+};
+const buildComposerTx = async ({ request, changeAddress, networkMagic, protocolParameters, spendableUtxos, tipSlot, eraSummaries }) => {
+	if (request.outputs.length === 0) throw fail("A composed transaction needs at least one output", "no-outputs");
+	if (spendableUtxos.length === 0) throw fail("The account has no spendable UTxOs to fund this transaction", "no-utxos");
+	const validityInterval = resolveValidityInterval({
+		tipSlot,
+		eraSummaries,
+		validitySeconds: request.validitySeconds,
+		validityStartSeconds: request.validityStartSeconds
+	});
+	const selectedInputs = resolveSelectedInputs(request, spendableUtxos);
+	const selectedReferences = new Set(selectedInputs.map((utxo) => utxoRefKey(utxo[0])));
+	const coverUtxos = spendableUtxos.filter((utxo) => !selectedReferences.has(utxoRefKey(utxo[0])));
+	const builder = new TransactionBuilder(networkMagic, protocolParameters).setChangeAddress(changeAddress).setUnspentOutputs(coverUtxos).setValidityInterval(validityInterval);
+	for (const utxo of selectedInputs) builder.addInput(utxo);
+	const metadataBlob = parseMetadata(request);
+	if (metadataBlob) for (const [label, value] of metadataBlob) builder.setMetadata(label, value);
+	for (const output of request.outputs) {
+		const address = toPaymentAddress(output.address, "The address of an output");
+		builder.addOutput({
+			address,
+			value: withMinimumCoin(address, toValue(output), protocolParameters)
+		});
+	}
+	const transaction = await codeInputSelectionFailure(builder.build());
+	return {
+		cbor: transaction.toCbor(),
+		txId: transaction.getId(),
+		fee: transaction.toCore().body.fee
+	};
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/composer/build-side-effect.ts
+const GENERIC_BUILD_ERROR_KEYS = {
+	title: "v2.composer.build.error.title",
+	subtitle: "v2.composer.build.error.subtitle"
+};
+const BUILD_ERROR_KEYS_BY_CODE = {
+	"no-utxos": {
+		title: "v2.composer.build.error.no-utxos.title",
+		subtitle: "v2.composer.build.error.no-utxos.subtitle"
+	},
+	"no-outputs": {
+		title: "v2.composer.build.error.invalid-request.title",
+		subtitle: "v2.composer.build.error.invalid-request.subtitle"
+	},
+	"invalid-output": {
+		title: "v2.composer.build.error.invalid-request.title",
+		subtitle: "v2.composer.build.error.invalid-request.subtitle"
+	},
+	"invalid-metadata": {
+		title: "v2.composer.build.error.invalid-request.title",
+		subtitle: "v2.composer.build.error.invalid-request.subtitle"
+	},
+	"input-unavailable": {
+		title: "v2.composer.build.error.invalid-request.title",
+		subtitle: "v2.composer.build.error.invalid-request.subtitle"
+	},
+	"invalid-address": {
+		title: "v2.composer.build.error.invalid-request.title",
+		subtitle: "v2.composer.build.error.invalid-request.subtitle"
+	},
+	"insufficient-funds": {
+		title: "v2.composer.build.error.invalid-request.title",
+		subtitle: "v2.composer.build.error.invalid-request.subtitle"
+	}
+};
+const failure = (error, code) => ({
+	success: false,
+	error: {
+		name: error.name,
+		message: error.message
+	},
+	errorTranslationKeys: (code ? BUILD_ERROR_KEYS_BY_CODE[code] : void 0) ?? GENERIC_BUILD_ERROR_KEYS
+});
+const buildComposition = async (state, stateObservables, dependencies) => {
+	try {
+		const { accountId, request } = state;
+		const cardano = dependencies.txExecutorCardano;
+		const cardanoContext = stateObservables.cardanoContext;
+		const [networkMagic, protocolParameters, tip, eraSummaries, accountUtxos, unspendableUtxos, addresses] = await Promise.all([
+			firstValueFrom(cardano.cardanoNetworkMagic$),
+			firstValueFrom(cardanoContext.selectProtocolParameters$),
+			firstValueFrom(cardanoContext.selectTip$),
+			firstValueFrom(cardanoContext.selectEraSummaries$),
+			firstValueFrom(cardano.cardanoAccountUtxos$),
+			firstValueFrom(cardano.cardanoAccountUnspendableUtxos$),
+			firstValueFrom(cardano.cardanoAddresses$)
+		]);
+		if (networkMagic === void 0) throw new Error("Cardano network magic not available");
+		if (!protocolParameters) throw new Error("Cardano protocol parameters not available");
+		if (!tip) throw new Error("Cardano chain tip not available");
+		if (!eraSummaries) throw new Error("Cardano era summaries not available");
+		refuseExtensionAccount(accountId, addresses);
+		const primary = addresses.filter((address) => address.accountId === accountId && address.blockchainName === "Cardano")[0];
+		if (!primary) throw new Error("No Cardano addresses found for account");
+		const result = await buildComposerTx({
+			request,
+			changeAddress: toPaymentAddress(request.changeAddress ?? primary.address, "The change address"),
+			networkMagic,
+			protocolParameters,
+			spendableUtxos: filterSpendableUtxos(accountUtxos[accountId] ?? [], unspendableUtxos[accountId] ?? []),
+			tipSlot: Number(tip.slot),
+			eraSummaries
+		});
+		return {
+			success: true,
+			serializedTx: result.cbor,
+			txId: result.txId,
+			fees: [{
+				tokenId: LOVELACE_TOKEN_ID,
+				amount: BigNumber(result.fee)
+			}]
+		};
+	} catch (error) {
+		return failure(error instanceof Error ? error : new Error(String(error)), error.code);
+	}
+};
+const makeComposerBuilding = () => (_, stateObservables, dependencies) => firstStateOfStatus(stateObservables.composerFlow.selectState$, "Building").pipe(switchMap((state) => from(buildComposition(state, stateObservables, dependencies)).pipe(map((result) => dependencies.actions.composerFlow.buildCompleted({
+	accountId: state.accountId,
+	result
+})))));
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/composer-flow-side-effects.ts
+const composerFlowSideEffects = [makeComposerBuilding()];
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/dependencies.ts
+const initializeDependencies = async (_, { logger }) => ({ cardanoInMemorySigning: { signTransaction: (props) => forkJoin([from(SodiumBip32Ed25519.create()), from(util.createTxInKeyPathMap(props.tx.body().toCore(), props.knownAddresses, createInputResolver(props.utxo)))]).pipe(mergeMap(([bip32Ed25519, txInKeyPathMap]) => {
+	const encryptedRootPrivateKeyBytes = ByteArray.fromHex(props.encryptedRootPrivateKey);
+	return from(new InMemoryKeyAgent({
+		accountIndex: props.accountIndex,
+		chainId: props.chainId,
+		encryptedRootPrivateKeyBytes: [...encryptedRootPrivateKeyBytes],
+		extendedAccountPublicKey: props.extendedAccountPublicKey,
+		getPassphrase: async () => props.authSecret,
+		purpose: KeyPurpose.STANDARD
+	}, {
+		bip32Ed25519,
+		logger,
+		rootPrivateKeyEncryption: SecretBox.isSealed(encryptedRootPrivateKeyBytes) ? {
+			encrypt: SecretBox.seal,
+			decrypt: SecretBox.open
+		} : void 0
+	}).signTransaction(props.tx.body(), {
+		knownAddresses: props.knownAddresses,
+		txInKeyPathMap,
+		scripts: props.tx.toCore().witness.scripts
+	})).pipe(map((signatures) => {
+		const witnessSet = props.tx.witnessSet();
+		applyVkeyWitnesses(witnessSet, signatures);
+		props.tx.setWitnessSet(witnessSet);
+		return Ok(props.tx);
+	}));
+}), catchError((error) => of(Err({
+	code: "SIGNING_FAILED",
+	message: error.message
+})))) } });
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/sdk-extensions.stable.ts
+const sdkExtensionSideEffects = [];
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/side-effects.ts
+const mainnetMagic = Number(Cardano.NetworkMagics.Mainnet);
+const deriveCardanoTestnetOptions = (config) => {
+	const blockfrostConfigs = config.cardanoProvider.blockfrostConfigs;
+	return Object.keys(blockfrostConfigs ?? {}).map((key) => Number(key)).filter((magic) => magic !== mainnetMagic).map(getCardanoTestnetIdByNetworkMagic).filter((id) => Boolean(id)).map((id) => {
+		return {
+			id: CardanoNetworkId(getCardanoChainIdByTestnetId(id).networkMagic),
+			label: id === "preprod" ? "v2.network-status.preprod" : id === "preview" ? "v2.network-status.preview" : "v2.network-status.preprod"
+		};
+	});
+};
+const registerCardanoTestnetOptions = (testnetOptions) => (_, { network: { selectTestnetOptions$ } }, { actions }) => selectTestnetOptions$.pipe(filter((options) => !options?.Cardano), map(() => actions.network.setTestnetOptions({
+	blockchainName: "Cardano",
+	options: testnetOptions
+})));
+const createCardanoSideEffects = (config) => {
+	return [registerCardanoTestnetOptions(deriveCardanoTestnetOptions(config))];
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/init.ts
+const redux = async (props, dependencies) => ({
+	sideEffects: [
+		...createCardanoSideEffects(props.runtime.config),
+		...composerFlowSideEffects,
+		...sdkExtensionSideEffects
+	],
+	sideEffectDependencies: await initializeDependencies(props, dependencies)
+});
+//#endregion
+export { redux as default };

package/dist/{init-C2RgrfZe.js → init-TkPq_Ny_.js}

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

package/dist/{init-5KcGcBb5.cjs → init-U8c9yHYx.cjs}

@@ -1,5 +1,5 @@
 require("./rolldown-runtime-Br2OG8yv.cjs");
-const require_esm_browser = require("./esm-browser-bweqfBlL.cjs");
+const require_esm_browser = require("./esm-browser-DTc9IK3D.cjs");
 let rxjs = require("rxjs");
 //#region ../../packages/contract/app/src/store/side-effects.ts
 require_esm_browser.init_esm_browser();

package/dist/{init-CX0AMQUn.js → init-aJHl-7AO.js}

@@ -1,5 +1,5 @@
-import { t as isReduxPersistState } from "./is-redux-persist-state-yBfq0h_E.js";
-import { n as syncReducers } from "./slice-CK07EBCo.js";
+import { t as isReduxPersistState } from "./is-redux-persist-state-Cxcd0_bM.js";
+import { n as syncReducers } from "./slice-eIwcwKHI.js";
 import { createTransform } from "redux-persist";
 //#region ../../packages/contract/sync/src/store/init.ts
 /**

package/dist/{init-rmt7-fQE.cjs → init-anYu6XB7.cjs}

@@ -1,6 +1,6 @@
 require("./rolldown-runtime-Br2OG8yv.cjs");
-const require_blockchain_network_id_vo = require("./blockchain-network-id.vo-BAKEwGjG.cjs");
-const require_slice = require("./slice-Dqw1ecum.cjs");
+const require_blockchain_network_id_vo = require("./blockchain-network-id.vo-BXpZhvvQ.cjs");
+const require_slice = require("./slice-FioKeHtA.cjs");
 let redux_persist = require("redux-persist");
 //#region ../../packages/contract/address-book/src/store/init.ts
 const store = () => ({

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

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

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

@@ -1,6 +1,6 @@
-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 { 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 { switchMap, withLatestFrom } from "rxjs";
 import { createMigrate } from "redux-persist";
 //#region ../../packages/contract/tokens/src/store/side-effects.ts

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

@@ -1,7 +1,7 @@
-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 { 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 { 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/{is-retriable-error-BUiVJDwH.js → is-retriable-error-BU0e3hVI.js}

@@ -1,4 +1,4 @@
-import { i as errorHasReason } from "./error-DIZOY2Lw.js";
+import { i as errorHasReason } from "./error-BCp9NkPi.js";
 import { ProviderFailure } from "@laceio/cardano/core";
 //#region ../../packages/lib/util-provider/src/is-retriable-error.ts
 /**

package/dist/{is-retriable-error-Dpt860if.cjs → is-retriable-error-CeeuHqDa.cjs}

@@ -1,5 +1,5 @@
 require("./rolldown-runtime-Br2OG8yv.cjs");
-const require_error = require("./error-Cb3EnD0u.cjs");
+const require_error = require("./error-CNIquqT5.cjs");
 let _laceio_cardano_core = require("@laceio/cardano/core");
 //#region ../../packages/lib/util-provider/src/is-retriable-error.ts
 /**

package/dist/{lace-context-BZciB9c7.js → lace-context-CZcNHr4M.js}

@@ -1,7 +1,7 @@
-import { n as markParameterizedSelector } from "./util-selector-BSTsxgne.js";
-import { t as createSelector } from "./reselect-CGoLzEPv.js";
-import { i as networkSelectors } from "./slice-GwiiJRoq.js";
-import { n as repositorySlice, t as repositoryAdapter } from "./repo-slice-RxFm0zDZ.js";
+import { n as markParameterizedSelector } from "./util-selector-CcK-GAdE.js";
+import { t as createSelector } from "./reselect-C06X06oX.js";
+import { i as networkSelectors } from "./slice-CB4SnzMm.js";
+import { n as repositorySlice, t as repositoryAdapter } from "./repo-slice-DwyMhCR1.js";
 import uniq from "lodash/uniq.js";
 import omit from "lodash/omit.js";
 //#region ../../packages/contract/wallet-repo/src/store/lace-context.ts

package/dist/{lace-context-DgR6vLli.cjs → lace-context-fJTDghdp.cjs}

@@ -1,8 +1,8 @@
 const require_rolldown_runtime = require("./rolldown-runtime-Br2OG8yv.cjs");
-const require_util_selector = require("./util-selector-BWPH68_l.cjs");
-const require_reselect = require("./reselect-Bd94u0K-.cjs");
-const require_slice = require("./slice-Bs2aMERu.cjs");
-const require_repo_slice = require("./repo-slice-7X4AYYVm.cjs");
+const require_util_selector = require("./util-selector-BcAncU4L.cjs");
+const require_reselect = require("./reselect-CRDqmQY9.cjs");
+const require_slice = require("./slice-DtaO72qY.cjs");
+const require_repo_slice = require("./repo-slice-WxetRhMY.cjs");
 let lodash_uniq = require("lodash/uniq.js");
 lodash_uniq = require_rolldown_runtime.__toESM(lodash_uniq);
 let lodash_omit = require("lodash/omit.js");