@laceio/sdk 0.1.1-canary.2 → 0.1.1

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

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

@@ -0,0 +1,364 @@
+require("./rolldown-runtime-Br2OG8yv.cjs");
+require("./_polyfill-buffer-patch-BnPVerlG.cjs");
+const require_bytes_vo = require("./bytes.vo-Ck5u40RA.cjs");
+const require_util = require("./util-CGzqQ8IV.cjs");
+const require_bignum_vo = require("./bignum.vo-DsG3kNiZ.cjs");
+const require_asyncoption = require("./asyncoption-DYoGuQfP.cjs");
+const require_first_state_of_status = require("./first-state-of-status-OROkXcRv.cjs");
+const require_cardano_network_id_vo = require("./cardano-network-id.vo-DSxrFk9S.cjs");
+const require_const = require("./const-BDEg2Trq.cjs");
+const require_TransactionBuilder = require("./TransactionBuilder-DrB3NVTi.cjs");
+const require_apply_vkey_witnesses = require("./apply-vkey-witnesses-CLzVSWxl.cjs");
+const require_account_guards_stable = require("./account-guards.stable-B1DSSh9D.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 rxjs = require("rxjs");
+let _laceio_cardano_tx_construction = require("@laceio/cardano/tx-construction");
+//#region ../../packages/contract/cardano-context/src/value-objects/cardano-testnet-id.vo.ts
+const CARDANO_CHAIN_ID_BY_TESTNET = {
+	preprod: _laceio_cardano_core.Cardano.ChainIds.Preprod,
+	preview: _laceio_cardano_core.Cardano.ChainIds.Preview,
+	sanchonet: _laceio_cardano_core.Cardano.ChainIds.Sanchonet
+};
+const PREPROD_MAGIC = Number(_laceio_cardano_core.Cardano.ChainIds.Preprod.networkMagic);
+const PREVIEW_MAGIC = Number(_laceio_cardano_core.Cardano.ChainIds.Preview.networkMagic);
+const SANCHONET_MAGIC = Number(_laceio_cardano_core.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 = _laceio_cardano_core.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 = _laceio_cardano_core.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 _laceio_cardano_core.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 ((0, _laceio_cardano_tx_construction.tokenBundleSizeExceedsLimit)(params.maxValueSize)(value.assets)) throw fail(`Output to ${address} exceeds the maximum token bundle size`, "invalid-output");
+	const minimumCoin = BigInt((0, _laceio_cardano_tx_construction.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), _laceio_cardano_core.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 require_TransactionBuilder.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 require_TransactionBuilder.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([
+			(0, rxjs.firstValueFrom)(cardano.cardanoNetworkMagic$),
+			(0, rxjs.firstValueFrom)(cardanoContext.selectProtocolParameters$),
+			(0, rxjs.firstValueFrom)(cardanoContext.selectTip$),
+			(0, rxjs.firstValueFrom)(cardanoContext.selectEraSummaries$),
+			(0, rxjs.firstValueFrom)(cardano.cardanoAccountUtxos$),
+			(0, rxjs.firstValueFrom)(cardano.cardanoAccountUnspendableUtxos$),
+			(0, rxjs.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");
+		require_account_guards_stable.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: require_util.filterSpendableUtxos(accountUtxos[accountId] ?? [], unspendableUtxos[accountId] ?? []),
+			tipSlot: Number(tip.slot),
+			eraSummaries
+		});
+		return {
+			success: true,
+			serializedTx: result.cbor,
+			txId: result.txId,
+			fees: [{
+				tokenId: require_const.LOVELACE_TOKEN_ID,
+				amount: require_bignum_vo.BigNumber(result.fee)
+			}]
+		};
+	} catch (error) {
+		return failure(error instanceof Error ? error : new Error(String(error)), error.code);
+	}
+};
+const makeComposerBuilding = () => (_, stateObservables, dependencies) => require_first_state_of_status.firstStateOfStatus(stateObservables.composerFlow.selectState$, "Building").pipe((0, rxjs.switchMap)((state) => (0, rxjs.from)(buildComposition(state, stateObservables, dependencies)).pipe((0, rxjs.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) => (0, rxjs.forkJoin)([(0, rxjs.from)(_laceio_cardano_crypto.SodiumBip32Ed25519.create()), (0, rxjs.from)(_laceio_cardano_key_management.util.createTxInKeyPathMap(props.tx.body().toCore(), props.knownAddresses, require_util.createInputResolver(props.utxo)))]).pipe((0, rxjs.mergeMap)(([bip32Ed25519, txInKeyPathMap]) => {
+	const encryptedRootPrivateKeyBytes = require_bytes_vo.ByteArray.fromHex(props.encryptedRootPrivateKey);
+	return (0, rxjs.from)(new _laceio_cardano_key_management.InMemoryKeyAgent({
+		accountIndex: props.accountIndex,
+		chainId: props.chainId,
+		encryptedRootPrivateKeyBytes: [...encryptedRootPrivateKeyBytes],
+		extendedAccountPublicKey: props.extendedAccountPublicKey,
+		getPassphrase: async () => props.authSecret,
+		purpose: _laceio_cardano_key_management.KeyPurpose.STANDARD
+	}, {
+		bip32Ed25519,
+		logger,
+		rootPrivateKeyEncryption: require_bytes_vo.SecretBox.isSealed(encryptedRootPrivateKeyBytes) ? {
+			encrypt: require_bytes_vo.SecretBox.seal,
+			decrypt: require_bytes_vo.SecretBox.open
+		} : void 0
+	}).signTransaction(props.tx.body(), {
+		knownAddresses: props.knownAddresses,
+		txInKeyPathMap,
+		scripts: props.tx.toCore().witness.scripts
+	})).pipe((0, rxjs.map)((signatures) => {
+		const witnessSet = props.tx.witnessSet();
+		require_apply_vkey_witnesses.applyVkeyWitnesses(witnessSet, signatures);
+		props.tx.setWitnessSet(witnessSet);
+		return require_asyncoption.Ok(props.tx);
+	}));
+}), (0, rxjs.catchError)((error) => (0, rxjs.of)(require_asyncoption.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(_laceio_cardano_core.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: require_cardano_network_id_vo.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((0, rxjs.filter)((options) => !options?.Cardano), (0, rxjs.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
+exports.default = redux;

package/dist/init-DMtyvYfC.cjs

@@ -0,0 +1,21 @@
+require("./rolldown-runtime-Br2OG8yv.cjs");
+const require_repo_slice = require("./repo-slice-WxetRhMY.cjs");
+let redux_persist = require("redux-persist");
+//#region ../../packages/contract/wallet-repo/src/store/persisted-migrations.stable.ts
+/** The migrations of the persisted `wallets` state: none. */
+const walletsMigrations = {};
+//#endregion
+//#region ../../packages/contract/wallet-repo/src/store/init.ts
+const walletsReducers = { wallets: require_repo_slice.repositorySlice.reducer };
+const storeExports = async () => {
+	return {
+		reducers: walletsReducers,
+		persistConfig: { wallets: {
+			version: 5,
+			migrate: (0, redux_persist.createMigrate)(walletsMigrations)
+		} }
+	};
+};
+//#endregion
+exports.default = storeExports;
+exports.walletsReducers = walletsReducers;

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

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

package/dist/{init-C8URA2OX.js → init-DcYY6zMD.js}

@@ -1,4 +1,4 @@
-import { n as addressesReducers } from "./slice-CU80pbiu.js";
+import { n as addressesReducers } from "./slice-CnyWevM9.js";
 //#region ../../packages/contract/addresses/src/store/init.ts
 const addressesStoreInit = () => ({
 	reducers: addressesReducers,

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

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

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

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

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

@@ -1,8 +1,8 @@
 require("./rolldown-runtime-Br2OG8yv.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");
+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");
 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.ActivityType.Rewards);
+		activitiesMap[key] = list.filter((activity) => activity.type !== require_activity_type_stable.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.ActivityType.Rewards && activity.blockchainSpecific && typeof activity.blockchainSpecific.epoch === "number") {
+		for (const activity of list) if (activity.type === require_activity_type_stable.ActivityType.Rewards && activity.blockchainSpecific && typeof activity.blockchainSpecific.epoch === "number") {
 			const meta = activity.blockchainSpecific;
 			meta.epoch = meta.epoch + REWARD_EPOCH_DISPLAY_OFFSET;
 		}