@laceio/sdk 0.1.1 → 0.1.2-canary.0

package/dist/sdk-Cb-gZnS9.js

@@ -0,0 +1,1241 @@
+import { n as import_buffer } from "./_polyfill-buffer-patch-yNxN4d5E.js";
+import { a as util, r as Crypto } from "./seam-cardano-B_etH4F4.js";
+import { t as SecretBox } from "./secret-box-DUR0ACYz.js";
+import { n as HexBytes, t as ByteArray } from "./bytes.vo-BB7_4JK6.js";
+import { t as IS_PARAMETERIZED } from "./util-selector-BSTsxgne.js";
+import { i as selectModules } from "./util-C8a4fA9p.js";
+import { a as inferStoreContext, i as inferModuleContext, n as combineContracts, r as inferContractContext, t as store_default$15 } from "./store-DuBG8qh5.js";
+import { r as featuresSelectors, t as featuresActions } from "./slice-Bk0Sv05J.js";
+import { t as Redacted } from "./redacted-BmE2aXqr.js";
+import { t as FeatureFlagKey } from "./feature-flag-key.vo-DN_-4-sG.js";
+import { r as analyticsSelectors, t as analyticsActions } from "./slice-DyNs7oWp.js";
+import { i as networkSelectors, n as networkActions } from "./slice-GwiiJRoq.js";
+import { n as walletsSelectors, t as walletsActions } from "./lace-context-BZciB9c7.js";
+import { n as tokensActions, r as tokensSelectors } from "./slice-DBpJ2QGf.js";
+import { r as activitiesSelectors, t as activitiesActions } from "./slice-D-9aPKG-.js";
+import { r as addressesSelectors, t as addressesActions } from "./slice-CU80pbiu.js";
+import { h as store_default$16, r as cardanoContextSelectors, t as cardanoContextActions } from "./slice-qt0uBExh.js";
+import { n as FEATURE_FLAG_CARDANO } from "./const-BJfIK_G-.js";
+import { r as viewsSelectors, t as viewsActions } from "./slice-BPNuHKfw.js";
+import { t as setFeatureFlags } from "./actions-iLXdgL5Y.js";
+import { contextLogger, isNotNil } from "@laceio/cardano/util";
+import { NEVER, Subject, defaultIfEmpty, delay, distinctUntilChanged, filter, firstValueFrom, from, map, share, shareReplay, takeUntil } from "rxjs";
+import { applyMiddleware, combineReducers, configureStore, createAction, isAnyOf } from "@reduxjs/toolkit";
+import merge$1 from "lodash/merge.js";
+import { combineEpics, createEpicMiddleware } from "redux-observable";
+import { FLUSH, PAUSE, PERSIST, PURGE, REGISTER, REHYDRATE, persistReducer, persistStore } from "redux-persist";
+import uniq from "lodash/uniq.js";
+import { dummyLogger } from "ts-log";
+//#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) => HexBytes.fromByteArray(await SecretBox.seal(ByteArray.fromUTF8(util.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 = Crypto.blake2b.hash(inputHex, WALLET_ID_BYTES);
+	return WalletId(Crypto.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(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(import_buffer.Buffer.from(util.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) => firstValueFrom(keyValueStorage.getValues([key]).pipe(map(([value]) => value), defaultIfEmpty(void 0))),
+		removeItem: async (key) => firstValueFrom(keyValueStorage.setValue(key, void 0)),
+		setItem: async (key, value) => 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: contextLogger(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(filter(isAnyOf(actionCreator)), 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(map((state) => {
+			if (selectorFunction[IS_PARAMETERIZED] === true) return (parameter) => selectorFunction(state, parameter);
+			if (selectorFunction.length > 1) return (parameter) => selectorFunction(state, parameter);
+			return selectorFunction(state);
+		}), distinctUntilChanged(), shareReplay(1))];
+	}))]));
+};
+const rehydrateStore = async (store) => new Promise((resolve) => {
+	const persistor = persistStore(store, null, () => {
+		resolve(persistor);
+	});
+});
+const mergeStoreExports = (storeExports, getter) => merge$1({}, ...storeExports.map(getter).filter(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 = combineReducers(Object.assign({}, ...storeExports.map((m) => m.reducers ? Object.fromEntries(Object.entries(m.reducers).map(([key, reducer]) => [key, key in persistConfigs ? 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 : delay(0));
+	let actionObservables;
+	let stateObservables;
+	let state$ = null;
+	const captureObservables = (actions, state) => {
+		actionObservables = actions;
+		stateObservables = state;
+		return NEVER;
+	};
+	const rootEpic = combineEpics(...[...storeExports.flatMap(({ sideEffects }) => sideEffects).filter(isNotNil), captureObservables].map(toEpic), (_, stateObservable$) => {
+		state$ = stateObservable$;
+		return 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: () => from(persistor?.flush() ?? Promise.resolve()),
+		runtime,
+		logger,
+		loadModules
+	};
+	const epicMiddleware = createEpicMiddleware({ dependencies: Object.assign(defaultDependencies, ...storeExports.map(({ sideEffectDependencies }) => sideEffectDependencies), sideEffectDependenciesOverride ?? {}) });
+	const middleware = storeExports.map(({ middleware }) => middleware).filter(isNotNil).flat();
+	const store = 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",
+					FLUSH,
+					REHYDRATE,
+					PAUSE,
+					PERSIST,
+					PURGE,
+					REGISTER
+				],
+				warnAfter: SERIALIZABLE_CHECK_WARN_AFTER_MS
+			}
+		}),
+		enhancers: (getDefaultEnhancers) => {
+			const enhancers = getDefaultEnhancers().prepend([applyMiddleware(...middleware, epicMiddleware)]);
+			if (lastEnhancer) return enhancers.concat(lastEnhancer);
+			return enhancers;
+		}
+	});
+	if (Object.keys(persistConfigs)) persistor = await rehydrateStore(store);
+	const epicTeardown$ = new Subject();
+	epicMiddleware.run((...args) => rootEpic(...args).pipe(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 uniq(modules.flatMap((laceModule) => [...laceModule.implements.contracts, ...laceModule.dependsOn?.contracts.filter(({ instance }) => instance === "zero-or-more") || []])).filter(isStoreContract).map(({ mixin }) => mixin).filter(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: contextLogger(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(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: uniq([...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: uniq([...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 = inferContractContext({
+	contractType: "sideEffectDependency",
+	name: ContractName("storage-dependency"),
+	instance: "exactly-one"
+});
+//#endregion
+//#region ../../packages/contract/feature/src/store/index.ts
+var store_default$14 = inferStoreContext({
+	load: async () => import("./init-NCjgwCZy.js"),
+	context: {
+		actions: featuresActions,
+		selectors: featuresSelectors
+	}
+});
+//#endregion
+//#region ../../packages/contract/feature/src/contract.ts
+const featureDependencyContract = inferContractContext({
+	contractType: "sideEffectDependency",
+	name: ContractName("feature-dependency"),
+	instance: "exactly-one"
+});
+inferContractContext({
+	contractType: "sideEffectDependency",
+	name: ContractName("feature-flag-refresh-trigger-dependency"),
+	instance: "exactly-one"
+});
+const featureStoreContract = inferContractContext({
+	contractType: "store",
+	name: ContractName("feature-store"),
+	instance: "exactly-one",
+	dependsOn: combineContracts([storageDependencyContract]),
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, store_default$14) }))
+});
+//#endregion
+//#region ../../packages/contract/analytics/src/store/index.ts
+var store_default$13 = inferStoreContext({
+	load: async () => import("./init-CNM5m7M2.js"),
+	context: {
+		actions: analyticsActions,
+		selectors: analyticsSelectors
+	}
+});
+//#endregion
+//#region ../../packages/contract/analytics/src/contract.ts
+const analyticsProviderDependencyContract = inferContractContext({
+	contractType: "sideEffectDependency",
+	name: ContractName("analytics-provider-dependency"),
+	instance: "exactly-one"
+});
+const analyticsStoreContract = inferContractContext({
+	contractType: "store",
+	name: ContractName("analytics-store"),
+	instance: "exactly-one",
+	dependsOn: combineContracts([analyticsProviderDependencyContract, featureStoreContract]),
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, store_default$13) }))
+});
+//#endregion
+//#region ../../packages/contract/failures/src/contract.ts
+const failuresStoreContract = inferContractContext({
+	name: ContractName("failures-store"),
+	contractType: "store",
+	instance: "exactly-one",
+	dependsOn: combineContracts([analyticsStoreContract]),
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, store_default$15) }))
+});
+//#endregion
+//#region ../../packages/contract/network/src/store/index.ts
+var store_default$12 = inferStoreContext({
+	load: async () => import("./init-Fw89ZmrR.js"),
+	context: {
+		actions: networkActions,
+		selectors: networkSelectors
+	}
+});
+//#endregion
+//#region ../../packages/contract/network/src/contract.ts
+const networkStoreContract = inferContractContext({
+	name: ContractName("network-store"),
+	contractType: "store",
+	instance: "exactly-one",
+	dependsOn: 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 = inferStoreContext({
+	load: async () => import("./init-BJn-8_hf.js"),
+	context: {
+		actions: walletsActions,
+		selectors: 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 = inferContractContext({
+	contractType: "store",
+	name: ContractName("wallet-repo-store"),
+	instance: "exactly-one",
+	dependsOn: combineContracts([networkStoreContract]),
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, store_default$11) }))
+});
+inferContractContext({
+	name: ContractName("request-hw-connection-addon"),
+	instance: "exactly-one",
+	contractType: "addon",
+	provides: { addons: ["loadRequestHWConnections"] }
+});
+inferContractContext({
+	name: ContractName("search-hw-devices-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadSearchHWDevices"] }
+});
+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 = inferStoreContext({
+	load: async () => import("./init-0zzs9aqU.js"),
+	context: {
+		actions: activitiesActions,
+		selectors: activitiesSelectors
+	}
+});
+//#endregion
+//#region ../../packages/contract/activities/src/contract.ts
+const activitiesStoreContract = inferContractContext({
+	name: ContractName("activities-store"),
+	contractType: "store",
+	instance: "exactly-one",
+	dependsOn: combineContracts([failuresStoreContract]),
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, store_default$10) }))
+});
+//#endregion
+//#region ../../packages/contract/addresses/src/store/index.ts
+var store_default$9 = inferStoreContext({
+	load: async () => import("./init-C8URA2OX.js"),
+	context: {
+		actions: addressesActions,
+		selectors: addressesSelectors
+	}
+});
+//#endregion
+//#region ../../packages/contract/addresses/src/contract.ts
+const addressesStoreContract = inferContractContext({
+	name: ContractName("addresses-store"),
+	contractType: "store",
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, store_default$9) })),
+	instance: "at-least-one"
+});
+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 = inferContractContext({
+	name: ContractName("sync-store"),
+	contractType: "store",
+	instance: "at-least-one",
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, store_default$16) }))
+});
+//#endregion
+//#region ../../packages/contract/tokens/src/store/index.ts
+var store_default$8 = inferStoreContext({
+	load: async () => import("./init-Dnsv155v.js"),
+	context: {
+		actions: tokensActions,
+		selectors: tokensSelectors
+	}
+});
+//#endregion
+//#region ../../packages/contract/tokens/src/contract.ts
+const tokensStoreContract = inferContractContext({
+	name: ContractName("tokens-store"),
+	contractType: "store",
+	dependsOn: 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 = inferStoreContext({
+	load: async () => import("./init-Cigr_tKx.js"),
+	context: {
+		actions: cardanoContextActions,
+		selectors: cardanoContextSelectors
+	}
+});
+//#endregion
+//#region ../../packages/contract/views/src/store/index.ts
+var store_default$6 = inferStoreContext({
+	load: async () => import("./init-kEfUTuG2.js"),
+	context: {
+		actions: viewsActions,
+		selectors: viewsSelectors
+	}
+});
+//#endregion
+//#region ../../packages/contract/views/src/ui-addon-contracts.ts
+const initializeExtensionViewAddonContract = inferContractContext({
+	name: ContractName("initialize-extension-view-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadInitializeExtensionView"] }
+});
+const initializeMobileViewAddonContract = inferContractContext({
+	name: ContractName("initialize-mobile-view-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadInitializeMobileView"] }
+});
+const renderRootAddonContract = inferContractContext({
+	name: ContractName("render-root-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["renderRoot"] }
+});
+const stackPagesAddonContract = inferContractContext({
+	name: ContractName("stack-pages-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadStackPages"] }
+});
+const tabPagesAddonContract = inferContractContext({
+	name: ContractName("tab-pages-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadTabPages"] }
+});
+inferContractContext({
+	name: ContractName("global-overlays-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadGlobalOverlays"] }
+});
+const sheetPagesAddonContract = inferContractContext({
+	name: ContractName("sheet-pages-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadSheetPages"] }
+});
+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 = inferContractContext({
+	name: ContractName("views-store"),
+	instance: "exactly-one",
+	contractType: "store",
+	dependsOn: 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: createAction("app/reloadApplication") } };
+const uiActions = { ui: {
+	showToast: createAction("ui/showToast"),
+	hideToast: createAction("ui/hideToast")
+} };
+//#endregion
+//#region ../../packages/contract/app/src/store/index.ts
+var store_default$5 = inferStoreContext({
+	load: async () => import("./init-C2RgrfZe.js"),
+	context: { actions: {
+		...appActions,
+		...uiActions
+	} }
+});
+inferContractContext({
+	name: ContractName("profile-dropdown-wallets-addon"),
+	contractType: "addon",
+	instance: "zero-or-more",
+	provides: { addons: ["loadProfileDropdownWalletsUICustomisations", "loadProfileDropdownMenuItemUICustomisations"] }
+});
+inferContractContext({
+	name: ContractName("blockchain-specific-app-customizations-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: [
+		"loadAccountUICustomisations",
+		"loadReceiveSheetAddressDataCustomisations",
+		"loadTokenDetailsUICustomisations",
+		"loadPortfolioBannerUICustomisations",
+		"loadAboutPageUICustomisations"
+	] }
+});
+inferContractContext({
+	name: ContractName("token-details-ui-customisations-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadTokenDetailsUICustomisations"] }
+});
+inferContractContext({
+	name: ContractName("portfolio-announcements-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadPortfolioAnnouncements"] }
+});
+inferContractContext({
+	name: ContractName("blockchain-specific-app-settings-page-customizations-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadSettingsPageUICustomisations"] }
+});
+inferContractContext({
+	name: ContractName("dialogs-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadDialogs"] }
+});
+inferContractContext({
+	name: ContractName("account-ui-customisation-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadAccountUICustomisations"] }
+});
+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 = [
+	inferContractContext({
+		name: ContractName("app-context-initialization-addon"),
+		instance: "zero-or-more",
+		contractType: "addon",
+		preloadInServiceWorker: true,
+		provides: { addons: ["loadInitializeAppContext"] }
+	}),
+	inferContractContext({
+		name: ContractName("app-menu-items-addon"),
+		instance: "zero-or-more",
+		contractType: "addon",
+		provides: { addons: ["loadAppMenuItems"] }
+	}),
+	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 = inferContractContext({
+	contractType: "sideEffectDependency",
+	name: ContractName("perform-app-reload-dependency"),
+	instance: "exactly-one"
+});
+const appStoreContract = inferContractContext({
+	name: ContractName("app-store"),
+	instance: "exactly-one",
+	contractType: "store",
+	dependsOn: 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 = inferContractContext({
+	contractType: "sideEffectDependency",
+	name: ContractName("wallet-active-state-dependency"),
+	instance: "exactly-one"
+});
+//#endregion
+//#region ../../packages/contract/cardano-context/src/contract.ts
+const cardanoProviderDependencyContract = inferContractContext({
+	contractType: "sideEffectDependency",
+	name: ContractName("cardano-provider-dependency"),
+	instance: "exactly-one"
+});
+const cardanoInMemorySigningDependencyContract = inferContractContext({
+	contractType: "sideEffectDependency",
+	name: ContractName("cardano-in-memory-signing-dependency"),
+	instance: "exactly-one"
+});
+/**
+* Implementor must provide sideEffectDependencies (CardanoProviderDependencies)
+*/
+const cardanoProviderStoreContract = inferContractContext({
+	name: ContractName("cardano-provider-store"),
+	instance: "exactly-one",
+	contractType: "store",
+	dependsOn: combineContracts([
+		networkStoreContract,
+		activitiesStoreContract,
+		addressesStoreContract,
+		appStoreContract,
+		tokensStoreContract,
+		walletActiveStateDependencyContract,
+		walletRepoStoreContract,
+		cardanoProviderDependencyContract,
+		syncStoreContract,
+		failuresStoreContract,
+		analyticsStoreContract,
+		featureStoreContract
+	]),
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, store_default$7) }))
+});
+const delegationTxBuilderAddonContract = inferContractContext({
+	name: ContractName("delegation-tx-builder-addon"),
+	instance: "at-least-one",
+	contractType: "addon",
+	preloadInServiceWorker: true,
+	provides: { addons: ["loadDelegationTxBuilder"] }
+});
+const deregistrationTxBuilderAddonContract = inferContractContext({
+	name: ContractName("deregistration-tx-builder-addon"),
+	instance: "at-least-one",
+	contractType: "addon",
+	preloadInServiceWorker: true,
+	provides: { addons: ["loadDeregistrationTxBuilder"] }
+});
+const voteDelegationTxBuilderAddonContract = inferContractContext({
+	name: ContractName("vote-delegation-tx-builder-addon"),
+	instance: "at-least-one",
+	contractType: "addon",
+	preloadInServiceWorker: true,
+	provides: { addons: ["loadVoteDelegationTxBuilder"] }
+});
+const earnRewardsTxBuilderAddonContract = 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 = inferStoreContext({
+	load: async () => import("./init-CyAY4Lzl.js"),
+	context: {
+		actions: {},
+		selectors: {}
+	}
+});
+//#endregion
+//#region ../../packages/contract/signer/src/contract.ts
+const signerFactoryAddonContract = inferContractContext({
+	name: ContractName("signer-factory-addon"),
+	instance: "at-least-one",
+	contractType: "addon",
+	preloadInServiceWorker: true,
+	provides: { addons: ["loadSignerFactory"] }
+});
+const signerStoreContract = inferContractContext({
+	name: ContractName("signer-store"),
+	instance: "exactly-one",
+	contractType: "store",
+	dependsOn: 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 = inferStoreContext({
+	load: async () => import("./init-CfTbSEKy.js"),
+	context: {
+		actions: {},
+		selectors: {}
+	}
+});
+//#endregion
+//#region ../../packages/module/cardano-sync/src/module.ts
+const cardanoSyncModule = inferModuleContext({
+	moduleName: ModuleName("cardano-sync"),
+	implements: combineContracts([]),
+	dependsOn: combineContracts([cardanoProviderStoreContract, syncStoreContract]),
+	store: store_default$3,
+	feature: {
+		willLoad: (featureFlags) => featureFlags.some((flag) => flag.key === 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 = inferStoreContext({
+	load: async () => import("./init-atCFur0v.js"),
+	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 = combineContracts([
+	activitiesStoreContract,
+	analyticsStoreContract,
+	analyticsProviderDependencyContract,
+	networkStoreContract,
+	failuresStoreContract,
+	walletActiveStateDependencyContract,
+	walletRepoStoreContract,
+	signerStoreContract
+]);
+const sdkBaseModule = 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 = inferStoreContext({
+	load: async () => import("./init-829HRYcz.js"),
+	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 = 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 = inferModuleContext({
+	moduleName: ModuleName("lace-sdk-cardano-app"),
+	implements: combineContracts([
+		appStoreContract,
+		viewsStoreContract,
+		performAppReloadDependencyContract
+	]),
+	store: cardano_app_module_store_default,
+	feature: {
+		willLoad: (featureFlags) => featureFlags.some((flag) => flag.key === 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 = dummyLogger;
+	const allModules = [
+		sdkBaseModule,
+		sdkCardanoAppModule,
+		cardanoSyncModule,
+		...modules
+	];
+	const { modulesToLoad } = 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) => Redacted.make(authSecret);
+const fromUTF8 = (utf8string) => AuthSecret(ByteArray.fromUTF8(utf8string));
+const fromHex = (hex) => AuthSecret(HexBytes.toByteArray(hex));
+AuthSecret.fromUTF8 = fromUTF8;
+AuthSecret.fromHex = fromHex;
+//#endregion
+//#region ../../packages/contract/in-memory/src/contract.ts
+const inMemoryIntegrationAddonContract = 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(ByteArray(rawPassword)) : void 0;
+	const integrations = (await wallet._loadModules("addons.loadInMemoryWalletIntegration")).filter((integration) => !blockchainName || integration.blockchainName === blockchainName);
+	return createInMemoryWalletEntityFactory({
+		integrations,
+		logger: dummyLogger
+	})({
+		blockchains: integrations.map((integration) => integration.blockchainName),
+		order,
+		password,
+		recoveryPhrase: mnemonicWords,
+		walletName
+	});
+};
+//#endregion
+//#region ../../packages/module/feature-dev/src/sdk-contracts.ts
+const implementsContracts = combineContracts([featureStoreContract, featureDependencyContract]);
+var store_default$2 = inferStoreContext({
+	load: async () => import("./init-B3-1ghyx.js"),
+	context: {
+		actions: { featureDev: { setFeatureFlags } },
+		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 = 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 = inferStoreContext({
+	load: async () => import("./init-A-VyGSNW2.js"),
+	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 = inferModuleContext({
+	moduleName: ModuleName("storage-in-memory"),
+	implements: combineContracts([storageDependencyContract]),
+	store: store_default$1,
+	addons: {}
+});
+//#endregion
+//#region ../../packages/module/storage-web-indexeddb/src/store/index.ts
+var store_default = inferStoreContext({
+	load: async () => import("./init-SZ01tARX2.js"),
+	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 = inferModuleContext({
+	moduleName: ModuleName("storage-web-indexeddb"),
+	implements: combineContracts([storageDependencyContract]),
+	store: store_default,
+	addons: {}
+});
+//#endregion
+export { ContractName as A, walletRepoStoreContract as C, storageDependencyContract as D, featureStoreContract as E, WalletId as M, combineStore as O, WalletType as S, failuresStoreContract as T, walletActiveStateDependencyContract as _, createInMemoryWalletEntity as a, addressesStoreContract as b, createLaceWallet as c, cardanoProviderDependencyContract as d, cardanoProviderStoreContract as f, voteDelegationTxBuilderAddonContract as g, earnRewardsTxBuilderAddonContract as h, createBlockchainWalletEntity as i, ModuleName as j, createMixin as k, signerFactoryAddonContract as l, deregistrationTxBuilderAddonContract as m, sdk_default$1 as n, inMemoryIntegrationAddonContract as o, delegationTxBuilderAddonContract as p, sdk_default$2 as r, AuthSecret as s, sdk_default as t, cardanoInMemorySigningDependencyContract as u, tokensStoreContract as v, networkStoreContract as w, activitiesStoreContract as x, syncStoreContract as y };