@laceio/sdk 0.1.0 → 0.1.1-canary.0

package/dist/sdk-1SRu8Ype.cjs

@@ -0,0 +1,1445 @@
+const require_chunk = require("./chunk-9hOWP6kD.cjs");
+const require__polyfill_buffer_patch = require("./_polyfill-buffer-patch-BycQkEkK.cjs");
+const require_Address = require("./Address-AMKTo-dA.cjs");
+const require_isNotNil = require("./isNotNil-CrYIUFry.cjs");
+const require_logging = require("./logging-CbxgIX9V.cjs");
+const require_slice = require("./slice-DLflttAu.cjs");
+const require_src$1 = require("./src-BayYMIjw.cjs");
+const require_secret_box = require("./secret-box-ZfbYwBgS.cjs");
+const require_bytes_vo = require("./bytes.vo-hecRu3YZ.cjs");
+const require_util_selector = require("./util-selector-glXkO-jR.cjs");
+const require_util = require("./util-Cp1h58uD.cjs");
+const require_store = require("./store-C7AneHEY.cjs");
+const require_slice$1 = require("./slice-C4toRM6A.cjs");
+const require_redacted = require("./redacted-DwxIDdIF.cjs");
+const require_feature_flag_key_vo = require("./feature-flag-key.vo-KTIdnzYX.cjs");
+const require_slice$2 = require("./slice-DimtxfAT.cjs");
+const require_slice$3 = require("./slice-B9QKuhi0.cjs");
+const require_lace_context = require("./lace-context-BN0b_ury.cjs");
+const require_slice$4 = require("./slice-Bf4enJKZ.cjs");
+const require_slice$5 = require("./slice-DtitVc9L.cjs");
+const require_slice$6 = require("./slice-CaMfviYu.cjs");
+const require_const = require("./const-D3mCkwrM.cjs");
+const require_slice$7 = require("./slice-BKnGkAkd.cjs");
+const require_actions = require("./actions-BnHFVSr_.cjs");
+let rxjs = require("rxjs");
+let _reduxjs_toolkit = require("@reduxjs/toolkit");
+let lodash_merge = require("lodash/merge.js");
+lodash_merge = require_chunk.__toESM(lodash_merge);
+let redux_observable = require("redux-observable");
+let redux_persist = require("redux-persist");
+let lodash_uniq = require("lodash/uniq.js");
+lodash_uniq = require_chunk.__toESM(lodash_uniq);
+let ts_log = require("ts-log");
+//#region ../../packages/lib/vendor/node_modules/@cardano-sdk/key-management/dist/esm/util/bip39.js
+var import_src = /* @__PURE__ */ require_chunk.__toESM(require_src$1.require_src(), 1);
+const joinMnemonicWords = (mnenomic) => mnenomic.join(" ");
+import_src.validateMnemonic;
+//#endregion
+//#region ../../packages/lib/core/src/encrypt-recovery-phrase.ts
+/**
+* SBV1 (Argon2id + ChaCha20-Poly1305) encryption of a mnemonic recovery phrase:
+* encrypt the utf8 bytes of the space-joined words with the passphrase, returning
+* hex. New wallets are sealed with SBV1; `SecretBox.open` still reads legacy
+* EMIP-003 blobs through the `@lace-lib/vendor` seam (ADR 37/38).
+*/
+const encryptRecoveryPhrase = async (words, passphrase) => require_bytes_vo.HexBytes.fromByteArray(await require_secret_box.SecretBox.seal(require_bytes_vo.ByteArray.fromUTF8(joinMnemonicWords(words)), passphrase));
+//#endregion
+//#region ../../packages/lib/core/src/value-objects/wallet-id.vo.ts
+const WALLET_ID_BYTES = 16;
+const doubleBlake2b128 = (inputHex) => {
+	const digest = require_Address.blake2b.hash(inputHex, WALLET_ID_BYTES);
+	return WalletId(require_Address.blake2b.hash(digest, WALLET_ID_BYTES));
+};
+/**
+* Types a string as a wallet identifier. It checks nothing; the `deriveFrom…`
+* functions derive the identifier a wallet's keys give it.
+*/
+const WalletId = (walletId) => walletId;
+/** Derive a walletId from an extended account public key (xpub). */
+WalletId.deriveFromBip32PublicKey = (xpubHex) => doubleBlake2b128(xpubHex);
+/**
+* Derive a walletId from a hardware device's BIP-32 master key fingerprint
+* (`xfpHex` — 8 hex chars / 4 bytes), domain-separated by `vendorTag` (the device
+* family: `'ledger'`, `'trezor'`).
+*
+* The xfp identifies the master key itself, so it is invariant across derivation
+* paths and across mainnet/testnet (whose account xpubs differ): one physical
+* device is one wallet whichever network its open app served. The vendor tag is
+* what keeps one seed restored onto two device families two wallets — the xfp
+* alone is identical for both. Same double blake2b-128 as the xpub mints, so every
+* id shares one 32-hex format and one collision domain.
+*/
+WalletId.deriveFromHardwareFingerprint = (vendorTag, xfpHex) => doubleBlake2b128(require__polyfill_buffer_patch.import_buffer.Buffer.from(`${vendorTag}:${xfpHex.toLowerCase()}`, "utf8").toString("hex"));
+/** Derive a walletId from a mnemonic — the utf8 bytes of the space-joined words. */
+WalletId.deriveFromMnemonic = (words) => doubleBlake2b128(require__polyfill_buffer_patch.import_buffer.Buffer.from(joinMnemonicWords(words), "utf8").toString("hex"));
+//#endregion
+//#region ../../packages/contract/module/src/redux-persist-storage.ts
+/** The name of the contract a module implements to provide key-value storage. */
+const STORAGE_CONTRACT_NAME = "storage-dependency";
+/**
+* Adapts a key-value storage factory to the redux-persist `Storage` interface,
+* keeping persisted state in the `redux` collection.
+*/
+const createReduxPersistStorage = (keyValueStorageFactory) => {
+	const keyValueStorage = keyValueStorageFactory({ collectionId: "redux" });
+	return {
+		getItem: async (key) => (0, rxjs.firstValueFrom)(keyValueStorage.getValues([key]).pipe((0, rxjs.map)(([value]) => value), (0, rxjs.defaultIfEmpty)(void 0))),
+		removeItem: async (key) => (0, rxjs.firstValueFrom)(keyValueStorage.setValue(key, void 0)),
+		setItem: async (key, value) => (0, rxjs.firstValueFrom)(keyValueStorage.setValue(key, value))
+	};
+};
+/**
+* Finds the module implementing the storage contract, initializes its store on
+* its own and returns the key-value storage factory it provides.
+*
+* @throws Error when no module implements the storage contract or it provides no `createKeyValueStorage`.
+*/
+const findStorageModule = async (props, { logger, ...rest }) => {
+	const storageModule = props.modules.find((m) => m.implements.contracts.some((contract) => contract.name === STORAGE_CONTRACT_NAME));
+	if (!storageModule) throw new Error("No storage module found");
+	const storageModuleStore = await storageModule.store?.load();
+	if (!storageModuleStore) throw new Error(`Module '${storageModule.moduleName}' must implement 'createKeyValueStorage' in store sideEffectDependencies`);
+	const dependencies = {
+		...rest,
+		logger: require_logging.contextLogger(require_logging.contextLogger(logger, storageModule.moduleName), "redux-storage"),
+		reduxPersistStorage: {}
+	};
+	const keyValueStorageFactory = (await storageModuleStore.default({
+		...props,
+		loadModules: () => {
+			throw new Error("Storage module \"store\" cannot load other modules");
+		}
+	}, dependencies)).sideEffectDependencies?.createKeyValueStorage;
+	if (!keyValueStorageFactory) throw new Error(`Module '${storageModule.moduleName}' must implement 'createKeyValueStorage' in store sideEffectDependencies`);
+	return keyValueStorageFactory;
+};
+//#endregion
+//#region ../../packages/contract/module/src/create-store.ts
+const SERIALIZABLE_CHECK_WARN_AFTER_MS = 128;
+const IMMUTABLE_CHECK_WARN_AFTER_MS = 256;
+const createActionObservables = (action$, actions) => {
+	return Object.fromEntries(Object.entries(actions).map(([scope, actionCreators]) => [scope, Object.fromEntries(Object.entries(actionCreators).map(([actionCreatorName, actionCreator]) => [`${actionCreatorName}$`, action$.pipe((0, rxjs.filter)((0, _reduxjs_toolkit.isAnyOf)(actionCreator)), (0, rxjs.share)())]))]));
+};
+/**
+* Maps scoped selectors to observables of the state, keyed `<selectorName>$`.
+* A parameterized selector yields a function of its parameter instead of a
+* value. Each observable emits on change and replays its latest value.
+*/
+const createStateObservables = (state$, selectors) => {
+	return Object.fromEntries(Object.entries(selectors).map(([scope, selectors]) => [scope, Object.fromEntries(Object.entries(selectors).map(([selectorName, selector]) => {
+		const selectorFunction = selector;
+		return [`${selectorName}$`, state$.pipe((0, rxjs.map)((state) => {
+			if (selectorFunction[require_util_selector.IS_PARAMETERIZED] === true) return (parameter) => selectorFunction(state, parameter);
+			if (selectorFunction.length > 1) return (parameter) => selectorFunction(state, parameter);
+			return selectorFunction(state);
+		}), (0, rxjs.distinctUntilChanged)(), (0, rxjs.shareReplay)(1))];
+	}))]));
+};
+const rehydrateStore = async (store) => new Promise((resolve) => {
+	const persistor = (0, redux_persist.persistStore)(store, null, () => {
+		resolve(persistor);
+	});
+});
+const mergeStoreExports = (storeExports, getter) => (0, lodash_merge.default)({}, ...storeExports.map(getter).filter(require_isNotNil.isNotNil));
+/**
+* Builds the app's Redux store from every loaded module store: combines their
+* reducers, middleware and side effects, rehydrates persisted slices, and
+* starts the side effects.
+*/
+const createStore = async (createStoreProps, createStoreDependencies) => {
+	const { loadModules, runtime, lastEnhancer } = createStoreProps;
+	const { logger, reduxPersistStorage, sideEffectDependenciesOverride } = createStoreDependencies;
+	const stores = await loadModules("store");
+	const storeExports = await Promise.all(stores.map(async (s) => s.load().then(async (module) => module.default(createStoreProps, createStoreDependencies))));
+	const selectors = stores.map((s) => s.context.selectors).filter((selectors) => !!selectors).reduce(Object.assign, {});
+	const actions = stores.map((s) => s.context.actions).reduce(Object.assign, {});
+	const persistConfigs = mergeStoreExports(storeExports, (s) => s.persistConfig);
+	const preloadedState = mergeStoreExports(storeExports, (s) => s.preloadedState);
+	const reducer = (0, _reduxjs_toolkit.combineReducers)(Object.assign({}, ...storeExports.map((m) => m.reducers ? Object.fromEntries(Object.entries(m.reducers).map(([key, reducer]) => [key, key in persistConfigs ? (0, redux_persist.persistReducer)({
+		key,
+		storage: reduxPersistStorage,
+		...persistConfigs[key]
+	}, reducer) : reducer])) : void 0)));
+	const initialState = reducer(void 0, { type: "@@lace/initial-state-snapshot" });
+	const toEpic = (sideEffect) => (action$, state$, dependencies) => sideEffect(createActionObservables(action$, actions), createStateObservables(state$, selectors), dependencies).pipe(createStoreProps.noEpicDelay ? (a) => a : (0, rxjs.delay)(0));
+	let actionObservables;
+	let stateObservables;
+	let state$ = null;
+	const captureObservables = (actions, state) => {
+		actionObservables = actions;
+		stateObservables = state;
+		return rxjs.NEVER;
+	};
+	const rootEpic = (0, redux_observable.combineEpics)(...[...storeExports.flatMap(({ sideEffects }) => sideEffects).filter(require_isNotNil.isNotNil), captureObservables].map(toEpic), (_, stateObservable$) => {
+		state$ = stateObservable$;
+		return rxjs.NEVER;
+	});
+	let persistor;
+	const defaultDependencies = {
+		actions,
+		selectors,
+		createKeyValueStorage: () => {
+			throw new Error("This must be overridden by storage module");
+		},
+		__getState: () => {
+			if (!state$) throw new Error("__getState() is not available during SideEffect initialization");
+			return state$.value;
+		},
+		flushPersistedState: () => (0, rxjs.from)(persistor?.flush() ?? Promise.resolve()),
+		runtime,
+		logger,
+		loadModules
+	};
+	const epicMiddleware = (0, redux_observable.createEpicMiddleware)({ dependencies: Object.assign(defaultDependencies, ...storeExports.map(({ sideEffectDependencies }) => sideEffectDependencies), sideEffectDependenciesOverride ?? {}) });
+	const middleware = storeExports.map(({ middleware }) => middleware).filter(require_isNotNil.isNotNil).flat();
+	const store = (0, _reduxjs_toolkit.configureStore)({
+		reducer,
+		preloadedState,
+		devTools: createStoreProps.devTools || false,
+		middleware: (getDefaultMiddleware) => getDefaultMiddleware({
+			immutableCheck: { warnAfter: IMMUTABLE_CHECK_WARN_AFTER_MS },
+			serializableCheck: {
+				ignoredActions: [
+					"accountManagement/attemptAddAccount",
+					"accountManagement/attemptAddInMemoryWalletAccount",
+					"txExecutor/tx-phase-completed",
+					"sendFlow/processingResulted",
+					"cardanoContext/setProtocolParameters",
+					"cardanoContext/setEraSummaries",
+					"cardanoContext/setStakePoolsData",
+					"cardanoContext/setAccountUtxos",
+					redux_persist.FLUSH,
+					redux_persist.REHYDRATE,
+					redux_persist.PAUSE,
+					redux_persist.PERSIST,
+					redux_persist.PURGE,
+					redux_persist.REGISTER
+				],
+				warnAfter: SERIALIZABLE_CHECK_WARN_AFTER_MS
+			}
+		}),
+		enhancers: (getDefaultEnhancers) => {
+			const enhancers = getDefaultEnhancers().prepend([(0, _reduxjs_toolkit.applyMiddleware)(...middleware, epicMiddleware)]);
+			if (lastEnhancer) return enhancers.concat(lastEnhancer);
+			return enhancers;
+		}
+	});
+	if (Object.keys(persistConfigs)) persistor = await rehydrateStore(store);
+	const epicTeardown$ = new rxjs.Subject();
+	epicMiddleware.run((...args) => rootEpic(...args).pipe((0, rxjs.takeUntil)(epicTeardown$)));
+	return {
+		store,
+		initialState,
+		teardown: () => {
+			epicTeardown$.next();
+			epicTeardown$.complete();
+		},
+		actionObservables,
+		stateObservables
+	};
+};
+//#endregion
+//#region ../../packages/contract/module/src/create-module-loader.ts
+const isStoreContract = (contract) => contract.contractType === "store";
+/**
+* Builds the single module formed by applying, once each, the mixins of every
+* store contract the given modules implement or depend on as `zero-or-more`.
+*/
+const reduceMixinsModule = (modules) => {
+	return (0, lodash_uniq.default)(modules.flatMap((laceModule) => [...laceModule.implements.contracts, ...laceModule.dependsOn?.contracts.filter(({ instance }) => instance === "zero-or-more") || []])).filter(isStoreContract).map(({ mixin }) => mixin).filter(require_isNotNil.isNotNil).reduce((laceModule, mixin) => mixin(laceModule), {});
+};
+const parseLoadableKey = (loadableKey) => loadableKey.split(".");
+const moduleOrAddonExport = (m, key) => {
+	const [moduleKey, addonKey] = parseLoadableKey(key);
+	const moduleValue = m[moduleKey];
+	if (addonKey) {
+		if (typeof moduleValue !== "object") return;
+		return moduleValue[addonKey];
+	}
+	return moduleValue;
+};
+/**
+* Creates a {@link ModuleLoader} over the given modules and their contract
+* mixins. Each loaded initializer receives the shared dependencies, a logger
+* scoped to its module and key, and a nested loader of its own.
+*/
+const createModuleLoader = (props, { logger, ...rest }) => {
+	const { modules } = props;
+	const loadModule = async (m, key) => {
+		if (!m) return;
+		const dependencies = {
+			...rest,
+			logger: require_logging.contextLogger(require_logging.contextLogger(logger, m.moduleName), key.replace("load", ""))
+		};
+		const exportValue = moduleOrAddonExport(m, key);
+		if (typeof exportValue === "function") {
+			const defaultExport = (await exportValue()).default;
+			if (typeof defaultExport === "function") return defaultExport({
+				...props,
+				loadModules: createModuleLoader(props, dependencies)
+			}, dependencies);
+			return defaultExport;
+		} else return exportValue;
+	};
+	const mixinsAndModules = [reduceMixinsModule(modules), ...modules];
+	return async (key) => {
+		return (await Promise.all(mixinsAndModules.map(async (m) => loadModule(m, key)))).filter(require_isNotNil.isNotNil);
+	};
+};
+//#endregion
+//#region ../../packages/contract/module/src/value-objects/module-name.vo.ts
+/** Types a string as a module's name, the `moduleName` it declares. It checks nothing. */
+const ModuleName = (moduleName) => moduleName;
+//#endregion
+//#region ../../packages/contract/module/src/value-objects/contract-name.vo.ts
+/** Types a string as a contract's name. It checks nothing. */
+const ContractName = (moduleKind) => moduleKind;
+//#endregion
+//#region ../../packages/contract/module/src/util-mixin.ts
+/**
+* Combines a module's store with a contract mixin's store. Reducers,
+* middleware, side effects, persist config, preloaded state, selectors and
+* actions of both are merged; the mixin's entries win on a key clash.
+*/
+const combineStore = (module, mixinStore) => {
+	const combinedStoreInit = (mixinStoreInit, moduleStoreInit) => async (props, dependencies) => {
+		const loadedModuleStore = await moduleStoreInit?.default(props, dependencies);
+		const loadedMixinStore = await mixinStoreInit.default(props, dependencies);
+		return {
+			middleware: (0, lodash_uniq.default)([...loadedModuleStore?.middleware || [], ...loadedMixinStore.middleware || []]),
+			reducers: {
+				...loadedModuleStore?.reducers,
+				...loadedMixinStore.reducers
+			},
+			persistConfig: {
+				...loadedModuleStore?.persistConfig,
+				...loadedMixinStore.persistConfig
+			},
+			preloadedState: {
+				...loadedModuleStore?.preloadedState,
+				...loadedMixinStore.preloadedState
+			},
+			sideEffectDependencies: {
+				...loadedModuleStore?.sideEffectDependencies,
+				...loadedMixinStore.sideEffectDependencies
+			},
+			sideEffects: (0, lodash_uniq.default)([...loadedModuleStore?.sideEffects || [], ...loadedMixinStore.sideEffects || []])
+		};
+	};
+	return {
+		load: async () => {
+			const moduleStoreInit = await module.store?.load();
+			return { default: combinedStoreInit(await mixinStore.load(), moduleStoreInit) };
+		},
+		context: {
+			actions: {
+				...module.store?.context.actions,
+				...mixinStore.context.actions
+			},
+			selectors: Object.assign({}, module.store?.context.selectors, mixinStore.context.selectors)
+		}
+	};
+};
+/**
+* Creates a contract mixin: a function that patches every module implementing
+* the contract with the properties `patchModule` returns.
+*/
+const createMixin = (patchModule) => (laceModule) => ({
+	...laceModule,
+	addons: laceModule.addons || {},
+	...patchModule(laceModule)
+});
+//#endregion
+//#region ../../packages/contract/storage/src/contract.ts
+/**
+* The contract a storage module implements: it gives every module's side
+* effects `createDocumentStorage` and `createCollectionStorage`, backed by
+* the platform's storage. A wallet loads one storage module; with two,
+* `createLaceWallet` fails with `MultipleImplementationsError`.
+*/
+const storageDependencyContract = require_store.inferContractContext({
+	contractType: "sideEffectDependency",
+	name: ContractName("storage-dependency"),
+	instance: "exactly-one"
+});
+//#endregion
+//#region ../../packages/contract/feature/src/store/index.ts
+var store_default$14 = require_store.inferStoreContext({
+	load: async () => Promise.resolve().then(() => require("./init-B2OUhY5T.cjs")),
+	context: {
+		actions: require_slice$1.featuresActions,
+		selectors: require_slice$1.featuresSelectors
+	}
+});
+//#endregion
+//#region ../../packages/contract/feature/src/contract.ts
+const featureDependencyContract = require_store.inferContractContext({
+	contractType: "sideEffectDependency",
+	name: ContractName("feature-dependency"),
+	instance: "exactly-one"
+});
+require_store.inferContractContext({
+	contractType: "sideEffectDependency",
+	name: ContractName("feature-flag-refresh-trigger-dependency"),
+	instance: "exactly-one"
+});
+const featureStoreContract = require_store.inferContractContext({
+	contractType: "store",
+	name: ContractName("feature-store"),
+	instance: "exactly-one",
+	dependsOn: require_store.combineContracts([storageDependencyContract]),
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, store_default$14) }))
+});
+//#endregion
+//#region ../../packages/contract/analytics/src/store/index.ts
+var store_default$13 = require_store.inferStoreContext({
+	load: async () => Promise.resolve().then(() => require("./init-B6Eg_o6G.cjs")),
+	context: {
+		actions: require_slice$2.analyticsActions,
+		selectors: require_slice$2.analyticsSelectors
+	}
+});
+//#endregion
+//#region ../../packages/contract/analytics/src/contract.ts
+const analyticsProviderDependencyContract = require_store.inferContractContext({
+	contractType: "sideEffectDependency",
+	name: ContractName("analytics-provider-dependency"),
+	instance: "exactly-one"
+});
+const analyticsStoreContract = require_store.inferContractContext({
+	contractType: "store",
+	name: ContractName("analytics-store"),
+	instance: "exactly-one",
+	dependsOn: require_store.combineContracts([analyticsProviderDependencyContract, featureStoreContract]),
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, store_default$13) }))
+});
+//#endregion
+//#region ../../packages/contract/failures/src/contract.ts
+const failuresStoreContract = require_store.inferContractContext({
+	name: ContractName("failures-store"),
+	contractType: "store",
+	instance: "exactly-one",
+	dependsOn: require_store.combineContracts([analyticsStoreContract]),
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, require_store.store_default) }))
+});
+//#endregion
+//#region ../../packages/contract/network/src/store/index.ts
+var store_default$12 = require_store.inferStoreContext({
+	load: async () => Promise.resolve().then(() => require("./init-BZ-WyAIL.cjs")),
+	context: {
+		actions: require_slice$3.networkActions,
+		selectors: require_slice$3.networkSelectors
+	}
+});
+//#endregion
+//#region ../../packages/contract/network/src/contract.ts
+const networkStoreContract = require_store.inferContractContext({
+	name: ContractName("network-store"),
+	contractType: "store",
+	instance: "exactly-one",
+	dependsOn: require_store.combineContracts([featureStoreContract]),
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, store_default$12) }))
+});
+//#endregion
+//#region ../../packages/contract/wallet-repo/src/store/index.ts
+var store_default$11 = require_store.inferStoreContext({
+	load: async () => Promise.resolve().then(() => require("./init-BUpFzYsD.cjs")),
+	context: {
+		actions: require_lace_context.walletsActions,
+		selectors: require_lace_context.walletsSelectors
+	}
+});
+//#endregion
+//#region ../../packages/contract/wallet-repo/src/contract.ts
+/**
+* Store contract for the wallet repository: the persisted `wallets` state
+* holding every wallet, its accounts and the active account. Exactly one
+* module provides it; it depends on the network store.
+*/
+const walletRepoStoreContract = require_store.inferContractContext({
+	contractType: "store",
+	name: ContractName("wallet-repo-store"),
+	instance: "exactly-one",
+	dependsOn: require_store.combineContracts([networkStoreContract]),
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, store_default$11) }))
+});
+require_store.inferContractContext({
+	name: ContractName("request-hw-connection-addon"),
+	instance: "exactly-one",
+	contractType: "addon",
+	provides: { addons: ["loadRequestHWConnections"] }
+});
+require_store.inferContractContext({
+	name: ContractName("search-hw-devices-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadSearchHWDevices"] }
+});
+require_store.inferContractContext({
+	name: ContractName("wallet-identity-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	preloadInServiceWorker: true,
+	provides: { addons: ["loadWalletIdentity"] }
+});
+//#endregion
+//#region ../../packages/contract/wallet-repo/src/wallet-type.ts
+/** The kinds of wallet the wallet repository holds, by who manages their keys. */
+let WalletType = /* @__PURE__ */ function(WalletType) {
+	/**
+	* Keys are held by the wallet: it stores its recovery phrase encrypted under
+	* the app's authentication secret, such as a password the user chooses.
+	* A wallet imported without its recovery phrase stores none.
+	*/
+	WalletType["InMemory"] = "InMemory";
+	/**
+	* Keys, and the seed they derive from, are never stored. The wallet holds
+	* only public keys, and a vault module signs for it, reaching the seed for
+	* each signature wherever the app keeps it.
+	*/
+	WalletType["LazyInMemory"] = "LazyInMemory";
+	/**
+	* Keys are managed by an external Ledger device
+	*/
+	WalletType["HardwareLedger"] = "HardwareLedger";
+	/**
+	* Keys are managed by an external Trezor device
+	*/
+	WalletType["HardwareTrezor"] = "HardwareTrezor";
+	/**
+	* Keys are managed by an external Cardano Seed Signer device.
+	* Like other hardware wallets, the wallet stores only its public keys and
+	* the device signs; it also stores the device master fingerprint (xfp) so
+	* signing requests can target the right device seed.
+	*/
+	WalletType["HardwareSeedSigner"] = "HardwareSeedSigner";
+	/**
+	* Keys are managed by an external Keystone device.
+	* Like other hardware wallets, the wallet stores only its public keys and
+	* the device signs; the device communicates exclusively over QR codes and is
+	* identified by its BIP-32 master fingerprint (xfp) so signing requests can
+	* target the right device seed.
+	*/
+	WalletType["HardwareKeystone"] = "HardwareKeystone";
+	/**
+	* Requires more than 1 set of keys to spend from this wallet.
+	* Some (or all) co-signers are other wallet (InMemory/Hardware)
+	* accounts from this repository.
+	*/
+	WalletType["MultiSig"] = "MultiSig";
+	/** A Cardano script account. */
+	WalletType["CardanoCustody"] = "CardanoCustody";
+	return WalletType;
+}({});
+//#endregion
+//#region ../../packages/contract/activities/src/store/index.ts
+var store_default$10 = require_store.inferStoreContext({
+	load: async () => Promise.resolve().then(() => require("./init-kvn5FlPS.cjs")),
+	context: {
+		actions: require_slice$5.activitiesActions,
+		selectors: require_slice$5.activitiesSelectors
+	}
+});
+//#endregion
+//#region ../../packages/contract/activities/src/contract.ts
+const activitiesStoreContract = require_store.inferContractContext({
+	name: ContractName("activities-store"),
+	contractType: "store",
+	instance: "exactly-one",
+	dependsOn: require_store.combineContracts([failuresStoreContract]),
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, store_default$10) }))
+});
+//#endregion
+//#region ../../packages/contract/addresses/src/store/index.ts
+var store_default$9 = require_store.inferStoreContext({
+	load: async () => Promise.resolve().then(() => require("./init-BpwlQ6wF.cjs")),
+	context: {
+		actions: require_slice$6.addressesActions,
+		selectors: require_slice$6.addressesSelectors
+	}
+});
+//#endregion
+//#region ../../packages/contract/addresses/src/contract.ts
+const addressesStoreContract = require_store.inferContractContext({
+	name: ContractName("addresses-store"),
+	contractType: "store",
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, store_default$9) })),
+	instance: "at-least-one"
+});
+require_store.inferContractContext({
+	name: ContractName("addresses-alias-resolver-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	preloadInServiceWorker: true,
+	provides: { addons: ["loadAddressAliasResolver"] }
+});
+//#endregion
+//#region ../../packages/contract/sync/src/contract.ts
+const syncStoreContract = require_store.inferContractContext({
+	name: ContractName("sync-store"),
+	contractType: "store",
+	instance: "at-least-one",
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, require_slice.store_default) }))
+});
+//#endregion
+//#region ../../packages/contract/tokens/src/store/index.ts
+var store_default$8 = require_store.inferStoreContext({
+	load: async () => Promise.resolve().then(() => require("./init-5SfWgCYD.cjs")),
+	context: {
+		actions: require_slice$4.tokensActions,
+		selectors: require_slice$4.tokensSelectors
+	}
+});
+//#endregion
+//#region ../../packages/contract/tokens/src/contract.ts
+const tokensStoreContract = require_store.inferContractContext({
+	name: ContractName("tokens-store"),
+	contractType: "store",
+	dependsOn: require_store.combineContracts([storageDependencyContract]),
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, store_default$8) })),
+	instance: "at-least-one"
+});
+//#endregion
+//#region ../../packages/contract/cardano-context/src/store/index.ts
+var store_default$7 = require_store.inferStoreContext({
+	load: async () => Promise.resolve().then(() => require("./init-BF-a2p6E.cjs")),
+	context: {
+		actions: require_slice.cardanoContextActions,
+		selectors: require_slice.cardanoContextSelectors
+	}
+});
+//#endregion
+//#region ../../packages/contract/views/src/store/index.ts
+var store_default$6 = require_store.inferStoreContext({
+	load: async () => Promise.resolve().then(() => require("./init-DmyuM9Lo.cjs")),
+	context: {
+		actions: require_slice$7.viewsActions,
+		selectors: require_slice$7.viewsSelectors
+	}
+});
+//#endregion
+//#region ../../packages/contract/views/src/ui-addon-contracts.ts
+const initializeExtensionViewAddonContract = require_store.inferContractContext({
+	name: ContractName("initialize-extension-view-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadInitializeExtensionView"] }
+});
+const initializeMobileViewAddonContract = require_store.inferContractContext({
+	name: ContractName("initialize-mobile-view-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadInitializeMobileView"] }
+});
+const renderRootAddonContract = require_store.inferContractContext({
+	name: ContractName("render-root-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["renderRoot"] }
+});
+const stackPagesAddonContract = require_store.inferContractContext({
+	name: ContractName("stack-pages-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadStackPages"] }
+});
+const tabPagesAddonContract = require_store.inferContractContext({
+	name: ContractName("tab-pages-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadTabPages"] }
+});
+require_store.inferContractContext({
+	name: ContractName("global-overlays-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadGlobalOverlays"] }
+});
+const sheetPagesAddonContract = require_store.inferContractContext({
+	name: ContractName("sheet-pages-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadSheetPages"] }
+});
+require_store.inferContractContext({
+	name: ContractName("load-deep-links-addon"),
+	instance: "exactly-one",
+	contractType: "addon",
+	provides: { addons: ["loadMobileDeepLinks"] }
+});
+//#endregion
+//#region ../../packages/contract/views/src/ui-addon-dependencies.ts
+/**
+* The UI addon contracts the views store depends on, in its dependency
+* order.
+*/
+const viewsUiAddonDependencies = [
+	initializeExtensionViewAddonContract,
+	initializeMobileViewAddonContract,
+	tabPagesAddonContract,
+	stackPagesAddonContract,
+	renderRootAddonContract,
+	sheetPagesAddonContract
+];
+//#endregion
+//#region ../../packages/contract/views/src/contract.ts
+const viewsStoreContract = require_store.inferContractContext({
+	name: ContractName("views-store"),
+	instance: "exactly-one",
+	contractType: "store",
+	dependsOn: require_store.combineContracts([analyticsStoreContract, ...viewsUiAddonDependencies]),
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, store_default$6) }))
+});
+/** Direct import of this is an anti-pattern. OK for tests. */
+const appActions = { app: { reloadApplication: (0, _reduxjs_toolkit.createAction)("app/reloadApplication") } };
+const uiActions = { ui: {
+	showToast: (0, _reduxjs_toolkit.createAction)("ui/showToast"),
+	hideToast: (0, _reduxjs_toolkit.createAction)("ui/hideToast")
+} };
+//#endregion
+//#region ../../packages/contract/app/src/store/index.ts
+var store_default$5 = require_store.inferStoreContext({
+	load: async () => Promise.resolve().then(() => require("./init-CH0yyBof.cjs")),
+	context: { actions: {
+		...appActions,
+		...uiActions
+	} }
+});
+require_store.inferContractContext({
+	name: ContractName("profile-dropdown-wallets-addon"),
+	contractType: "addon",
+	instance: "zero-or-more",
+	provides: { addons: ["loadProfileDropdownWalletsUICustomisations", "loadProfileDropdownMenuItemUICustomisations"] }
+});
+require_store.inferContractContext({
+	name: ContractName("blockchain-specific-app-customizations-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: [
+		"loadAccountUICustomisations",
+		"loadReceiveSheetAddressDataCustomisations",
+		"loadTokenDetailsUICustomisations",
+		"loadPortfolioBannerUICustomisations",
+		"loadAboutPageUICustomisations"
+	] }
+});
+require_store.inferContractContext({
+	name: ContractName("token-details-ui-customisations-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadTokenDetailsUICustomisations"] }
+});
+require_store.inferContractContext({
+	name: ContractName("portfolio-announcements-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadPortfolioAnnouncements"] }
+});
+require_store.inferContractContext({
+	name: ContractName("blockchain-specific-app-settings-page-customizations-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadSettingsPageUICustomisations"] }
+});
+require_store.inferContractContext({
+	name: ContractName("dialogs-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadDialogs"] }
+});
+require_store.inferContractContext({
+	name: ContractName("account-ui-customisation-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadAccountUICustomisations"] }
+});
+require_store.inferContractContext({
+	name: ContractName("send-flow-sheet-ui-customisation-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadSendFlowSheetUICustomisations"] }
+});
+//#endregion
+//#region ../../packages/contract/app/src/ui-addon-dependencies.ts
+/**
+* The UI addon contracts the app store depends on, in its dependency
+* order.
+*/
+const appUiAddonDependencies = [
+	require_store.inferContractContext({
+		name: ContractName("app-context-initialization-addon"),
+		instance: "zero-or-more",
+		contractType: "addon",
+		preloadInServiceWorker: true,
+		provides: { addons: ["loadInitializeAppContext"] }
+	}),
+	require_store.inferContractContext({
+		name: ContractName("app-menu-items-addon"),
+		instance: "zero-or-more",
+		contractType: "addon",
+		provides: { addons: ["loadAppMenuItems"] }
+	}),
+	require_store.inferContractContext({
+		name: ContractName("tab-menu-items-addon"),
+		instance: "zero-or-more",
+		contractType: "addon",
+		provides: { addons: ["loadTabMenuItems"] }
+	})
+];
+//#endregion
+//#region ../../packages/contract/app/src/contract.ts
+const performAppReloadDependencyContract = require_store.inferContractContext({
+	contractType: "sideEffectDependency",
+	name: ContractName("perform-app-reload-dependency"),
+	instance: "exactly-one"
+});
+const appStoreContract = require_store.inferContractContext({
+	name: ContractName("app-store"),
+	instance: "exactly-one",
+	contractType: "store",
+	dependsOn: require_store.combineContracts([
+		viewsStoreContract,
+		...appUiAddonDependencies,
+		analyticsStoreContract,
+		featureStoreContract,
+		tokensStoreContract,
+		performAppReloadDependencyContract
+	]),
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, store_default$5) }))
+});
+//#endregion
+//#region ../../packages/contract/app/src/utils.ts
+const runInitializers = async (initializers) => Promise.all(initializers.map(async (initializer) => initializer()));
+//#endregion
+//#region ../../packages/contract/wallet-active-state/src/contract.ts
+const walletActiveStateDependencyContract = require_store.inferContractContext({
+	contractType: "sideEffectDependency",
+	name: ContractName("wallet-active-state-dependency"),
+	instance: "exactly-one"
+});
+//#endregion
+//#region ../../packages/contract/cardano-context/src/contract.ts
+const cardanoProviderDependencyContract = require_store.inferContractContext({
+	contractType: "sideEffectDependency",
+	name: ContractName("cardano-provider-dependency"),
+	instance: "exactly-one"
+});
+const cardanoInMemorySigningDependencyContract = require_store.inferContractContext({
+	contractType: "sideEffectDependency",
+	name: ContractName("cardano-in-memory-signing-dependency"),
+	instance: "exactly-one"
+});
+/**
+* Implementor must provide sideEffectDependencies (CardanoProviderDependencies)
+*/
+const cardanoProviderStoreContract = require_store.inferContractContext({
+	name: ContractName("cardano-provider-store"),
+	instance: "exactly-one",
+	contractType: "store",
+	dependsOn: require_store.combineContracts([
+		networkStoreContract,
+		activitiesStoreContract,
+		addressesStoreContract,
+		appStoreContract,
+		tokensStoreContract,
+		walletActiveStateDependencyContract,
+		walletRepoStoreContract,
+		cardanoProviderDependencyContract,
+		syncStoreContract,
+		failuresStoreContract,
+		analyticsStoreContract,
+		featureStoreContract
+	]),
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, store_default$7) }))
+});
+const delegationTxBuilderAddonContract = require_store.inferContractContext({
+	name: ContractName("delegation-tx-builder-addon"),
+	instance: "at-least-one",
+	contractType: "addon",
+	preloadInServiceWorker: true,
+	provides: { addons: ["loadDelegationTxBuilder"] }
+});
+const deregistrationTxBuilderAddonContract = require_store.inferContractContext({
+	name: ContractName("deregistration-tx-builder-addon"),
+	instance: "at-least-one",
+	contractType: "addon",
+	preloadInServiceWorker: true,
+	provides: { addons: ["loadDeregistrationTxBuilder"] }
+});
+const voteDelegationTxBuilderAddonContract = require_store.inferContractContext({
+	name: ContractName("vote-delegation-tx-builder-addon"),
+	instance: "at-least-one",
+	contractType: "addon",
+	preloadInServiceWorker: true,
+	provides: { addons: ["loadVoteDelegationTxBuilder"] }
+});
+const earnRewardsTxBuilderAddonContract = require_store.inferContractContext({
+	name: ContractName("earn-rewards-tx-builder-addon"),
+	instance: "at-least-one",
+	contractType: "addon",
+	preloadInServiceWorker: true,
+	provides: { addons: ["loadEarnRewardsTxBuilder"] }
+});
+//#endregion
+//#region ../../packages/contract/signer/src/store/index.ts
+var store_default$4 = require_store.inferStoreContext({
+	load: async () => Promise.resolve().then(() => require("./init-wgiBUmyW.cjs")),
+	context: {
+		actions: {},
+		selectors: {}
+	}
+});
+//#endregion
+//#region ../../packages/contract/signer/src/contract.ts
+const signerFactoryAddonContract = require_store.inferContractContext({
+	name: ContractName("signer-factory-addon"),
+	instance: "at-least-one",
+	contractType: "addon",
+	preloadInServiceWorker: true,
+	provides: { addons: ["loadSignerFactory"] }
+});
+const signerStoreContract = require_store.inferContractContext({
+	name: ContractName("signer-store"),
+	instance: "exactly-one",
+	contractType: "store",
+	dependsOn: require_store.combineContracts([signerFactoryAddonContract]),
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, store_default$4) }))
+});
+//#endregion
+//#region ../../packages/module/cardano-sync/src/store/index.ts
+var store_default$3 = require_store.inferStoreContext({
+	load: async () => Promise.resolve().then(() => require("./init-DexLSprL2.cjs")),
+	context: {
+		actions: {},
+		selectors: {}
+	}
+});
+//#endregion
+//#region ../../packages/module/cardano-sync/src/module.ts
+const cardanoSyncModule = require_store.inferModuleContext({
+	moduleName: ModuleName("cardano-sync"),
+	implements: require_store.combineContracts([]),
+	dependsOn: require_store.combineContracts([cardanoProviderStoreContract, syncStoreContract]),
+	store: store_default$3,
+	feature: {
+		willLoad: (featureFlags) => featureFlags.some((flag) => flag.key === require_const.FEATURE_FLAG_CARDANO),
+		metadata: {
+			name: "CardanoSync",
+			description: "Cardano provider-backed sync executors and round model"
+		}
+	},
+	addons: {}
+});
+//#endregion
+//#region src/app-context.ts
+/** Runs the app-context initializers the loaded modules provide, such as i18n. */
+const initializeAppContext = async (loadModules) => {
+	await runInitializers(await loadModules("addons.loadInitializeAppContext"));
+};
+//#endregion
+//#region src/base-module-store/index.ts
+var base_module_store_default = require_store.inferStoreContext({
+	load: async () => Promise.resolve().then(() => require("./init-BT67pd9x.cjs")),
+	context: {
+		actions: {},
+		selectors: {}
+	}
+});
+//#endregion
+//#region src/base-module.ts
+/**
+* SDK base module - implements the "app shell" store contracts
+* that app-mobile currently provides.
+*
+* NOTE: app-mobile owns too many store contracts that should ideally
+* be implemented by their respective domain modules (e.g., sendFlowStoreContract
+* should be owned by a send-flow domain module, activitiesStoreContract by an
+* activities domain module, etc.). This base module inherits that over-centralization
+* for now. As contracts get properly distributed to domain modules in the future,
+* this base module should shrink.
+*/
+const implementsContracts$1 = require_store.combineContracts([
+	activitiesStoreContract,
+	analyticsStoreContract,
+	analyticsProviderDependencyContract,
+	networkStoreContract,
+	failuresStoreContract,
+	walletActiveStateDependencyContract,
+	walletRepoStoreContract,
+	signerStoreContract
+]);
+const sdkBaseModule = require_store.inferModuleContext({
+	moduleName: ModuleName("lace-sdk-base"),
+	implements: implementsContracts$1,
+	store: base_module_store_default,
+	addons: {}
+});
+//#endregion
+//#region src/cardano-app-module-store/index.ts
+var cardano_app_module_store_default = require_store.inferStoreContext({
+	load: async () => Promise.resolve().then(() => require("./init-xzZPlQwB.cjs")),
+	context: {
+		actions: {},
+		selectors: {}
+	}
+});
+//#endregion
+//#region src/cardano-app-module.ts
+/**
+* The key of the flag that enables Bitcoin accounts. Spelled out here rather
+* than imported from the Bitcoin contract, which is canary code that neither
+* the stable build nor the Cardano entry may carry (ADR 66).
+*/
+const BITCOIN_FEATURE_FLAG_KEY = require_feature_flag_key_vo.FeatureFlagKey("BLOCKCHAIN_BITCOIN");
+/**
+* The app-shell contracts the blockchain modules need, such as the analytics
+* store that failures report to, implemented headless. `createLaceWallet`
+* loads it whenever the Cardano or Bitcoin feature flag is on.
+*/
+const sdkCardanoAppModule = require_store.inferModuleContext({
+	moduleName: ModuleName("lace-sdk-cardano-app"),
+	implements: require_store.combineContracts([
+		appStoreContract,
+		viewsStoreContract,
+		performAppReloadDependencyContract
+	]),
+	store: cardano_app_module_store_default,
+	feature: {
+		willLoad: (featureFlags) => featureFlags.some((flag) => flag.key === require_const.FEATURE_FLAG_CARDANO || flag.key === BITCOIN_FEATURE_FLAG_KEY),
+		metadata: {
+			name: "SdkCardanoApp",
+			description: "Headless app contracts of the blockchain modules"
+		}
+	},
+	addons: {}
+});
+//#endregion
+//#region src/create-lace-wallet.ts
+const parseKey = (key) => {
+	const items = key.split(".");
+	if (items.length < 2) throw new Error(`Invalid key "${key}", expected format: "{scope}.{actionName}"`);
+	return items;
+};
+/**
+* Creates a wallet from a set of modules. The SDK adds its own base modules,
+* keeps the modules whose feature flags are enabled, and checks that every
+* contract a module depends on is implemented, and implemented once where it
+* allows only one. It then loads the modules and returns a wallet whose
+* actions and state are typed from them.
+*
+* @param props - The modules, environment, configuration and feature flags.
+* @returns The wallet, typed from `props.modules`. Rejects with
+* `MissingContractImplementationError` or `MultipleImplementationsError` when
+* the modules do not fit together.
+*/
+const createLaceWallet = async (props) => {
+	const { modules, environment, config, featureFlags = [] } = props;
+	const app = "lace-sdk";
+	const logger = ts_log.dummyLogger;
+	const allModules = [
+		sdkBaseModule,
+		sdkCardanoAppModule,
+		cardanoSyncModule,
+		...modules
+	];
+	const { modulesToLoad } = require_util.selectModules(allModules, featureFlags, environment);
+	const moduleInitProps = {
+		modules: modulesToLoad,
+		runtime: {
+			app,
+			env: environment,
+			config,
+			platform: "web",
+			features: {
+				availableModules: allModules,
+				loaded: {
+					featureFlags,
+					modules: modulesToLoad.map((m) => ({
+						moduleName: m.moduleName,
+						feature: m.feature ? { metadata: m.feature.metadata } : void 0
+					}))
+				}
+			}
+		}
+	};
+	const loadModules = createModuleLoader(moduleInitProps, { logger });
+	const reduxPersistStorage = createReduxPersistStorage(await findStorageModule(moduleInitProps, { logger }));
+	await initializeAppContext(loadModules);
+	const { store, stateObservables, actionObservables } = await createStore({
+		...moduleInitProps,
+		loadModules
+	}, {
+		logger,
+		reduxPersistStorage
+	});
+	const stores = await loadModules("store");
+	const actions = {};
+	for (const s of stores) Object.assign(actions, s.context.actions);
+	const dispatch = (key, ...args) => {
+		const [scope, actionCreatorName] = parseKey(key);
+		const actionCreator = actions[scope]?.[actionCreatorName];
+		if (!actionCreator) throw new Error(`Unknown action: ${key}`);
+		store.dispatch(actionCreator(...args));
+	};
+	return {
+		stateObservables,
+		actionObservables,
+		dispatch,
+		getState: () => store.getState(),
+		_loadModules: loadModules
+	};
+};
+//#endregion
+//#region ../../packages/contract/authentication-prompt/src/value-objects/auth-secret.ts
+const AuthSecret = (authSecret) => require_redacted.Redacted.make(authSecret);
+const fromUTF8 = (utf8string) => AuthSecret(require_bytes_vo.ByteArray.fromUTF8(utf8string));
+const fromHex = (hex) => AuthSecret(require_bytes_vo.HexBytes.toByteArray(hex));
+AuthSecret.fromUTF8 = fromUTF8;
+AuthSecret.fromHex = fromHex;
+//#endregion
+//#region ../../packages/contract/in-memory/src/contract.ts
+const inMemoryIntegrationAddonContract = require_store.inferContractContext({
+	name: ContractName("in-memory-integration-addon"),
+	instance: "at-least-one",
+	contractType: "addon",
+	preloadInServiceWorker: true,
+	provides: { addons: ["loadInMemoryWalletIntegration"] }
+});
+//#endregion
+//#region ../../packages/contract/onboarding-v2/src/store/wallet-creation/wallet-entity.ts
+/**
+* Factory for creating in-memory wallet entities.
+*
+* With `password`: encrypts the recovery phrase and returns an
+* {@link InMemoryWallet}. Without `password`: persists no seed material and
+* returns a {@link LazyInMemoryWallet} — signing relies on an external module
+* re-supplying the mnemonic on demand.
+*/
+const createInMemoryWalletEntityFactory = ({ integrations, logger }) => {
+	const create = async ({ walletName, blockchains, password, order, recoveryPhrase }) => {
+		const walletId = WalletId.deriveFromMnemonic(recoveryPhrase);
+		const integrationResults = await Promise.all(integrations.filter(({ blockchainName }) => blockchains.includes(blockchainName)).map(async (integration) => integration.initializeWallet({
+			recoveryPhrase,
+			walletId,
+			order,
+			walletName,
+			password
+		}, { logger }).then((result) => ({
+			...result,
+			blockchainName: integration.blockchainName
+		}))));
+		const blockchainSpecific = integrationResults.map(({ blockchainName, blockchainSpecificWalletData }) => ({ [blockchainName]: blockchainSpecificWalletData })).reduce((accumulator, value) => ({
+			...accumulator,
+			...value
+		}), {});
+		const accounts = integrationResults.flatMap(({ accounts }) => accounts);
+		if (!password) return {
+			accounts,
+			blockchainSpecific,
+			metadata: {
+				name: walletName,
+				order
+			},
+			type: WalletType.LazyInMemory,
+			walletId
+		};
+		return {
+			accounts,
+			blockchainSpecific,
+			encryptedRecoveryPhrase: await encryptRecoveryPhrase(recoveryPhrase, password),
+			isPassphraseConfirmed: false,
+			metadata: {
+				name: walletName,
+				order
+			},
+			type: WalletType.InMemory,
+			walletId
+		};
+	};
+	return create;
+};
+//#endregion
+//#region src/create-in-memory-wallet-entity.ts
+async function createInMemoryWalletEntity(wallet, props) {
+	return createEntity(wallet, props);
+}
+async function createBlockchainWalletEntity(wallet, blockchainName, props) {
+	return createEntity(wallet, props, blockchainName);
+}
+const createEntity = async (wallet, props, blockchainName) => {
+	const { mnemonicWords, password: rawPassword, walletName, order = 0 } = props;
+	const password = rawPassword ? AuthSecret(require_bytes_vo.ByteArray(rawPassword)) : void 0;
+	const integrations = (await wallet._loadModules("addons.loadInMemoryWalletIntegration")).filter((integration) => !blockchainName || integration.blockchainName === blockchainName);
+	return createInMemoryWalletEntityFactory({
+		integrations,
+		logger: ts_log.dummyLogger
+	})({
+		blockchains: integrations.map((integration) => integration.blockchainName),
+		order,
+		password,
+		recoveryPhrase: mnemonicWords,
+		walletName
+	});
+};
+//#endregion
+//#region ../../packages/module/feature-dev/src/sdk-contracts.ts
+const implementsContracts = require_store.combineContracts([featureStoreContract, featureDependencyContract]);
+//#endregion
+//#region ../../packages/module/feature-dev/src/store/index.ts
+const featureDevActions = { featureDev: { setFeatureFlags: require_actions.setFeatureFlags } };
+var store_default$2 = require_store.inferStoreContext({
+	load: async () => Promise.resolve().then(() => require("./init-8NVWbo302.cjs")),
+	context: {
+		actions: featureDevActions,
+		selectors: {}
+	}
+});
+//#endregion
+//#region ../../packages/module/feature-dev/src/sdk.ts
+/**
+* Feature flags the app sets: the wallet starts with the flags passed to
+* `createLaceWallet`, and dispatching `featureDev.setFeatureFlags` replaces
+* them.
+*/
+var sdk_default$2 = require_store.inferModuleContext({
+	moduleName: ModuleName("feature-dev"),
+	implements: implementsContracts,
+	store: store_default$2,
+	addons: {}
+});
+//#endregion
+//#region ../../packages/module/storage-in-memory/src/store/index.ts
+var store_default$1 = require_store.inferStoreContext({
+	load: async () => Promise.resolve().then(() => require("./init-J8QobR93.cjs")),
+	context: {
+		actions: {},
+		selectors: {}
+	}
+});
+//#endregion
+//#region ../../packages/module/storage-in-memory/src/sdk.ts
+/**
+* In-memory storage: the wallet's persisted state lasts as long as the
+* process.
+*/
+var sdk_default$1 = require_store.inferModuleContext({
+	moduleName: ModuleName("storage-in-memory"),
+	implements: require_store.combineContracts([storageDependencyContract]),
+	store: store_default$1,
+	addons: {}
+});
+//#endregion
+//#region ../../packages/module/storage-web-indexeddb/src/store/index.ts
+var store_default = require_store.inferStoreContext({
+	load: async () => Promise.resolve().then(() => require("./init-bzvl1JhF.cjs")),
+	context: {
+		actions: {},
+		selectors: {}
+	}
+});
+//#endregion
+//#region ../../packages/module/storage-web-indexeddb/src/sdk.ts
+/**
+* Browser storage in IndexedDB: the wallet's persisted state lasts across
+* page loads and sessions.
+*/
+var sdk_default = require_store.inferModuleContext({
+	moduleName: ModuleName("storage-web-indexeddb"),
+	implements: require_store.combineContracts([storageDependencyContract]),
+	store: store_default,
+	addons: {}
+});
+//#endregion
+Object.defineProperty(exports, "AuthSecret", {
+	enumerable: true,
+	get: function() {
+		return AuthSecret;
+	}
+});
+Object.defineProperty(exports, "ContractName", {
+	enumerable: true,
+	get: function() {
+		return ContractName;
+	}
+});
+Object.defineProperty(exports, "ModuleName", {
+	enumerable: true,
+	get: function() {
+		return ModuleName;
+	}
+});
+Object.defineProperty(exports, "WalletId", {
+	enumerable: true,
+	get: function() {
+		return WalletId;
+	}
+});
+Object.defineProperty(exports, "WalletType", {
+	enumerable: true,
+	get: function() {
+		return WalletType;
+	}
+});
+Object.defineProperty(exports, "activitiesStoreContract", {
+	enumerable: true,
+	get: function() {
+		return activitiesStoreContract;
+	}
+});
+Object.defineProperty(exports, "addressesStoreContract", {
+	enumerable: true,
+	get: function() {
+		return addressesStoreContract;
+	}
+});
+Object.defineProperty(exports, "cardanoInMemorySigningDependencyContract", {
+	enumerable: true,
+	get: function() {
+		return cardanoInMemorySigningDependencyContract;
+	}
+});
+Object.defineProperty(exports, "cardanoProviderDependencyContract", {
+	enumerable: true,
+	get: function() {
+		return cardanoProviderDependencyContract;
+	}
+});
+Object.defineProperty(exports, "cardanoProviderStoreContract", {
+	enumerable: true,
+	get: function() {
+		return cardanoProviderStoreContract;
+	}
+});
+Object.defineProperty(exports, "combineStore", {
+	enumerable: true,
+	get: function() {
+		return combineStore;
+	}
+});
+Object.defineProperty(exports, "createBlockchainWalletEntity", {
+	enumerable: true,
+	get: function() {
+		return createBlockchainWalletEntity;
+	}
+});
+Object.defineProperty(exports, "createInMemoryWalletEntity", {
+	enumerable: true,
+	get: function() {
+		return createInMemoryWalletEntity;
+	}
+});
+Object.defineProperty(exports, "createLaceWallet", {
+	enumerable: true,
+	get: function() {
+		return createLaceWallet;
+	}
+});
+Object.defineProperty(exports, "createMixin", {
+	enumerable: true,
+	get: function() {
+		return createMixin;
+	}
+});
+Object.defineProperty(exports, "delegationTxBuilderAddonContract", {
+	enumerable: true,
+	get: function() {
+		return delegationTxBuilderAddonContract;
+	}
+});
+Object.defineProperty(exports, "deregistrationTxBuilderAddonContract", {
+	enumerable: true,
+	get: function() {
+		return deregistrationTxBuilderAddonContract;
+	}
+});
+Object.defineProperty(exports, "earnRewardsTxBuilderAddonContract", {
+	enumerable: true,
+	get: function() {
+		return earnRewardsTxBuilderAddonContract;
+	}
+});
+Object.defineProperty(exports, "failuresStoreContract", {
+	enumerable: true,
+	get: function() {
+		return failuresStoreContract;
+	}
+});
+Object.defineProperty(exports, "featureStoreContract", {
+	enumerable: true,
+	get: function() {
+		return featureStoreContract;
+	}
+});
+Object.defineProperty(exports, "inMemoryIntegrationAddonContract", {
+	enumerable: true,
+	get: function() {
+		return inMemoryIntegrationAddonContract;
+	}
+});
+Object.defineProperty(exports, "networkStoreContract", {
+	enumerable: true,
+	get: function() {
+		return networkStoreContract;
+	}
+});
+Object.defineProperty(exports, "sdk_default", {
+	enumerable: true,
+	get: function() {
+		return sdk_default;
+	}
+});
+Object.defineProperty(exports, "sdk_default$1", {
+	enumerable: true,
+	get: function() {
+		return sdk_default$1;
+	}
+});
+Object.defineProperty(exports, "sdk_default$2", {
+	enumerable: true,
+	get: function() {
+		return sdk_default$2;
+	}
+});
+Object.defineProperty(exports, "signerFactoryAddonContract", {
+	enumerable: true,
+	get: function() {
+		return signerFactoryAddonContract;
+	}
+});
+Object.defineProperty(exports, "storageDependencyContract", {
+	enumerable: true,
+	get: function() {
+		return storageDependencyContract;
+	}
+});
+Object.defineProperty(exports, "syncStoreContract", {
+	enumerable: true,
+	get: function() {
+		return syncStoreContract;
+	}
+});
+Object.defineProperty(exports, "tokensStoreContract", {
+	enumerable: true,
+	get: function() {
+		return tokensStoreContract;
+	}
+});
+Object.defineProperty(exports, "voteDelegationTxBuilderAddonContract", {
+	enumerable: true,
+	get: function() {
+		return voteDelegationTxBuilderAddonContract;
+	}
+});
+Object.defineProperty(exports, "walletActiveStateDependencyContract", {
+	enumerable: true,
+	get: function() {
+		return walletActiveStateDependencyContract;
+	}
+});
+Object.defineProperty(exports, "walletRepoStoreContract", {
+	enumerable: true,
+	get: function() {
+		return walletRepoStoreContract;
+	}
+});