@laceio/sdk 0.1.1-canary.2 → 0.1.1

package/dist/sdk-init-DNd-oQXp.js

@@ -1,1044 +0,0 @@
-import "./_web-crypto-random-bytes-Bo-GTcRS.js";
-import "./_polyfill-buffer-patch-yNxN4d5E.js";
-import "./libsodium-wrappers-BhbOA8dQ.js";
-import "./codecs-Dc1Krpbt.js";
-import { n as HexBytes } from "./bytes.vo-BB7_4JK6.js";
-import { r as Milliseconds, s as Timestamp } from "./time.vo-tNheinXm.js";
-import { t as BigNumber } from "./bignum.vo-CEXOIew0.js";
-import { t as autoDismissFailureOnSuccess } from "./auto-dismiss-failure-on-success-s8MGDEIu.js";
-import "./retry-config-Dmgt28wM.js";
-import { t as ActivityType } from "./activity-type-GsJGWs-3.js";
-import { t as TokenId } from "./token-id.vo-Bvwhr3ZE.js";
-import { t as AuthenticationCancelledError } from "./types-CJT6XF2c.js";
-import { g as MidnightNetworkId, l as MidnightSDKTestNetworkId, x as getProofServerEndpoint, y as assertProofServerRouting } from "./const-BfEnY8fg.js";
-import { n as midnightContextActions } from "./slice-BnTJeMOb.js";
-import { c as toUnshieldedTokenType, o as hasMidnightAccount, s as isInMemoryMidnightAccount, t as convertHttpUrlToWebsocket } from "./utils-CvAW5Yw7.js";
-import { t as midnightWalletsForRuntime } from "./midnight-wallet-DIsAlSn6.js";
-import { c as createProofServerAccess, f as FEATURE_FLAG_MIDNIGHT_SHIELDED_ACTIVITY_ROWS, i as MidnightSyncFailureId, n as watchMidnightAccount, o as createAttestedProofServerAccess, r as watchMidnightAccounts, s as createHttpProofServerTransport, u as createScopedProofServerAccess } from "./watch-Z53L4yoK.js";
-import { n as teeAttestationProgress$ } from "./send-proof-progress-DTK3ZuYB.js";
-import { Percent, deepEquals } from "@laceio/cardano/util";
-import { EMPTY, Observable, catchError, combineLatest, concat, defaultIfEmpty, defer, distinctUntilChanged, exhaustMap, filter, firstValueFrom, forkJoin, from, groupBy, map, merge, mergeMap, of, scan, shareReplay, switchMap, take, takeUntil, throttleTime, throwError, throwIfEmpty, withLatestFrom, zip } from "rxjs";
-import isEqual from "lodash/isEqual.js";
-import { DustAddress, ShieldedAddress, UnshieldedAddress } from "@midnightntwrk/wallet-sdk-address-format";
-import * as ledger from "@midnight-ntwrk/ledger-v8";
-import { PublicKey, UnshieldedWallet } from "@midnightntwrk/wallet-sdk/unshielded";
-import { InMemoryTransactionHistoryStorage, WalletEntrySchema, mergeWalletEntries } from "@midnightntwrk/wallet-sdk";
-import { DustWallet } from "@midnightntwrk/wallet-sdk/dust";
-import { WalletFacade } from "@midnightntwrk/wallet-sdk/facade";
-import { ShieldedWallet } from "@midnightntwrk/wallet-sdk/shielded";
-//#region ../../packages/contract/midnight-context/src/value-objects/midnight-address.vo.ts
-const MidnightShieldedAddress = (address) => address;
-const MidnightUnshieldedAddress = (address) => address;
-const MidnightDustAddress = (address) => address;
-//#endregion
-//#region ../../packages/contract/midnight-context/src/value-objects/serialised-wallet-state.vo.ts
-/**
-* Either encoding. Production only ever constructs this from the SDK's
-* verbatim JSON; the hex form comes back from storage on older profiles.
-*/
-const SerialisedWalletState = (value) => value;
-/**
-* A heuristic over the values we actually persist, not a parse: hex and JSON
-* overlap (`12345678` is both), so nothing can separate them in general. Every
-* blob written here opens with `{`; `[` is headroom for a serialiser that
-* returns a top-level array. Anything else reads as hex, and a wrong guess
-* costs a rebuild from seed, which the restore path already handles.
-*
-* First character only: matching hex across the whole payload cost ~2500ms
-* against 10k documents of 100k characters, against ~8ms here, and was
-* case-sensitive so it missed uppercase hex besides.
-*/
-const isVerbatimJson = (value) => value.startsWith("{") || value.startsWith("[");
-SerialisedWalletState.toJSON = (value) => isVerbatimJson(value) ? value : HexBytes.toUTF8(value);
-//#endregion
-//#region ../../packages/contract/midnight-context/src/midnight-accounts.ts
-/** Two account lists are the same run of accounts when their ids line up in
-* order — the identity the account stream re-emits on. */
-const sameAccounts = (accounts1, accounts2) => {
-	if (accounts1.length !== accounts2.length) return false;
-	for (let index = 0; index < accounts1.length; index++) if (accounts1[index].accountId !== accounts2[index].accountId) return false;
-	return true;
-};
-/**
-* The in-memory Midnight accounts on the active Midnight network, as a stream
-* that only re-emits when the run of account ids actually changes. Emits an
-* empty list while the wallet repo is migrating, so a consumer never acts on a
-* half-migrated repo. Nothing is emitted until a Midnight network is registered.
-*/
-const midnightAccounts$ = (state) => combineLatest([
-	state.wallets.selectActiveNetworkAccounts$,
-	state.midnightContext.selectMidnightBlockchainNetworkId$.pipe(filter(Boolean)),
-	state.wallets.selectIsWalletRepoMigrating$
-]).pipe(map(([accounts, activeNetwork, isWalletRepoMigrating]) => isWalletRepoMigrating ? [] : accounts.filter(isInMemoryMidnightAccount).filter((account) => account.blockchainNetworkId === activeNetwork)), distinctUntilChanged(sameAccounts));
-//#endregion
-//#region ../../packages/contract/midnight-context/src/register-midnight-blockchain-networks.ts
-/**
-* Registers the Midnight networks with the global network store once, the
-* first time it reports Midnight absent. Every loadout with Midnight accounts
-* needs this: `wallets.selectActiveNetworkAccounts` drops the accounts of an
-* unregistered blockchain. The registration lands a tick after this decides,
-* so it sets the networks only while Midnight still has none: a network the
-* consumer selected in between keeps precedence.
-*
-* An existing Midnight account pins the testnet selection to its own network,
-* so a profile created before the network store existed keeps syncing where
-* its account lives; otherwise the default testnet is selected.
-*/
-const registerMidnightBlockchainNetworks = (_, { network: { selectBlockchainNetworks$ }, midnightContext: { selectDefaultTestNetNetworkId$ }, wallets: { selectAll$ } }, { actions }) => selectBlockchainNetworks$.pipe(filter((blockchainNetworks) => !blockchainNetworks?.Midnight), withLatestFrom(selectDefaultTestNetNetworkId$, selectAll$.pipe(map((allWallets) => allWallets.flatMap((wallet) => wallet.accounts)))), map(([, defaultTestNetNetworkId, accounts]) => {
-	const existingMidnightAccount = accounts.find((account) => account.blockchainName === "Midnight");
-	const testnetNetworkId = existingMidnightAccount ? existingMidnightAccount.blockchainSpecific.networkId : defaultTestNetNetworkId;
-	return actions.network.registerBlockchainNetworks({
-		blockchain: "Midnight",
-		mainnet: MidnightNetworkId("mainnet"),
-		testnet: MidnightNetworkId(testnetNetworkId)
-	});
-}));
-//#endregion
-//#region ../../packages/lib/vendor/src/midnight-facade-reservations.ts
-const NO_BALANCING_TRANSACTION = "No balancing transaction was created. Please check your transaction.";
-const releasingOnFailure = async (build) => {
-	const releases = [];
-	const reserve = (transaction, holder) => {
-		if (transaction) releases.push(async () => holder.revertTransaction(transaction));
-		return transaction;
-	};
-	try {
-		return await build(reserve);
-	} catch (error) {
-		await Promise.allSettled(releases.map(async (release) => release()));
-		throw error;
-	}
-};
-const merge$1 = (first, second) => first && second ? first.merge(second) : first ?? second;
-const kindsToBalance = (tokenKindsToBalance = "all") => {
-	const kinds = tokenKindsToBalance === "all" ? [
-		"shielded",
-		"unshielded",
-		"dust"
-	] : tokenKindsToBalance;
-	return {
-		dust: kinds.includes("dust"),
-		shielded: kinds.includes("shielded"),
-		unshielded: kinds.includes("unshielded")
-	};
-};
-/**
-* The wallet SDK's multi-step builds over `facade`, releasing the coins the
-* completed steps reserved when a later step fails. The wallet SDK keeps
-* them, and its caller gets an error with no recipe to release. Each build
-* takes the same steps over the same sub-wallets as its `WalletFacade`
-* namesake and returns the same recipe.
-*/
-const withReservationRelease = (facade) => ({
-	balanceFinalizedTransaction: async (transaction, { shieldedSecretKeys, dustSecretKey }, { ttl, tokenKindsToBalance }) => releasingOnFailure(async (reserve) => {
-		const balance = kindsToBalance(tokenKindsToBalance);
-		const unshieldedBalancing = balance.unshielded ? reserve(await facade.unshielded.balanceFinalizedTransaction(transaction), facade.unshielded) : void 0;
-		const tokenBalancing = merge$1(balance.shielded ? reserve(await facade.shielded.balanceTransaction(shieldedSecretKeys, transaction), facade.shielded) : void 0, unshieldedBalancing);
-		const balancingTransaction = merge$1(tokenBalancing, balance.dust ? await facade.dust.balanceTransactions(dustSecretKey, tokenBalancing ? [transaction, tokenBalancing] : [transaction], ttl) : void 0);
-		if (!balancingTransaction) throw new Error(NO_BALANCING_TRANSACTION);
-		return {
-			type: "FINALIZED_TRANSACTION",
-			originalTransaction: transaction,
-			balancingTransaction
-		};
-	}),
-	balanceUnboundTransaction: async (transaction, { shieldedSecretKeys, dustSecretKey }, { ttl, tokenKindsToBalance }) => releasingOnFailure(async (reserve) => {
-		const balance = kindsToBalance(tokenKindsToBalance);
-		const shieldedBalancing = balance.shielded ? reserve(await facade.shielded.balanceTransaction(shieldedSecretKeys, transaction), facade.shielded) : void 0;
-		const balancedUnshielded = balance.unshielded ? await facade.unshielded.balanceUnboundTransaction(transaction) : void 0;
-		const baseTransaction = balancedUnshielded ?? transaction;
-		const balancingTransaction = merge$1(shieldedBalancing, balance.dust ? await facade.dust.balanceTransactions(dustSecretKey, shieldedBalancing ? [baseTransaction, shieldedBalancing] : [baseTransaction], ttl) : void 0);
-		if (!balancingTransaction && !balancedUnshielded) throw new Error(NO_BALANCING_TRANSACTION);
-		return {
-			type: "UNBOUND_TRANSACTION",
-			baseTransaction,
-			balancingTransaction: balancingTransaction ?? void 0
-		};
-	}),
-	transferTransaction: async (outputs, { shieldedSecretKeys, dustSecretKey }, { ttl, payFees = true }) => releasingOnFailure(async (reserve) => {
-		const shieldedOutputs = outputs.flatMap((output) => output.type === "shielded" ? output.outputs : []);
-		const unshieldedOutputs = outputs.flatMap((output) => output.type === "unshielded" ? output.outputs : []);
-		if (unshieldedOutputs.length === 0 && shieldedOutputs.length === 0) throw new Error("At least one shielded or unshielded output is required.");
-		const transfer = merge$1(shieldedOutputs.length > 0 ? reserve(await facade.shielded.transferTransaction(shieldedSecretKeys, shieldedOutputs), facade.shielded) : void 0, unshieldedOutputs.length > 0 ? reserve(await facade.unshielded.transferTransaction(unshieldedOutputs, ttl), facade.unshielded) : void 0);
-		if (!transfer) throw new Error("Unexpected transaction state.");
-		return {
-			type: "UNPROVEN_TRANSACTION",
-			transaction: merge$1(transfer, payFees ? await facade.dust.balanceTransactions(dustSecretKey, [transfer], ttl) : void 0) ?? transfer
-		};
-	}),
-	initSwap: async ({ desiredInputs, desiredOutputs }, { shieldedSecretKeys, dustSecretKey }, { ttl, payFees = false }) => releasingOnFailure(async (reserve) => {
-		const { shielded: shieldedInputs, unshielded: unshieldedInputs } = desiredInputs;
-		const shieldedOutputs = desiredOutputs.flatMap((output) => output.type === "shielded" ? output.outputs : []);
-		const unshieldedOutputs = desiredOutputs.flatMap((output) => output.type === "unshielded" ? output.outputs : []);
-		const hasShieldedPart = !!shieldedInputs && Object.keys(shieldedInputs).length > 0 || shieldedOutputs.length > 0;
-		const hasUnshieldedPart = !!unshieldedInputs && Object.keys(unshieldedInputs).length > 0 || unshieldedOutputs.length > 0;
-		if (!hasShieldedPart && !hasUnshieldedPart) throw new Error("At least one shielded or unshielded swap is required.");
-		const swap = merge$1(hasShieldedPart && shieldedInputs !== void 0 ? reserve(await facade.shielded.initSwap(shieldedSecretKeys, shieldedInputs, shieldedOutputs), facade.shielded) : void 0, hasUnshieldedPart && unshieldedInputs !== void 0 ? reserve(await facade.unshielded.initSwap(unshieldedInputs, unshieldedOutputs, ttl), facade.unshielded) : void 0);
-		if (!swap) throw new Error("Unexpected transaction state.");
-		return {
-			type: "UNPROVEN_TRANSACTION",
-			transaction: merge$1(swap, payFees ? await facade.dust.balanceTransactions(dustSecretKey, [swap], ttl) : void 0) ?? swap
-		};
-	})
-});
-//#endregion
-//#region ../../packages/module/midnight-sync/src/store/compute-sync-ratio.ts
-const computeConnectedSyncRatio = (applied, highest, isConnected) => isConnected && applied === 0n && highest === 0n ? Percent(1) : computeSyncRatio(applied, highest);
-const computeSyncRatio = (applied, highest) => {
-	if (highest === 0n) {
-		if (applied === 0n) return Percent(0);
-		const ratio = 1 - 1 / (1 + Number(applied) / 1e3);
-		return Percent(Math.min(.99, ratio));
-	}
-	return Percent(Math.min(1, Number(applied) / Number(highest)));
-};
-//#endregion
-//#region ../../packages/module/midnight-sync/src/store/dependencies.ts
-/**
-* Wraps keyManager.keys$ with recovery for AuthenticationCancelledError.
-* If the user cancels the auth prompt, waits for keys to become available
-* from another source (e.g., an unlock triggered by a different flow)
-* and retries.
-*/
-const keysWithAuthCancelledRecovery$ = (keyManager) => keyManager.keys$.pipe(take(1), catchError((error) => {
-	if (!(error instanceof AuthenticationCancelledError)) return throwError(() => error);
-	return keyManager.areKeysAvailable$.pipe(filter((available) => available), take(1), switchMap(() => keyManager.keys$.pipe(take(1))));
-}));
-const STATE_SERIALISATION_THROTTLE_TIME = Milliseconds(5e3);
-const DEFAULT_BATCH_UPDATES = {
-	size: 12,
-	spacing: 4
-};
-/**
-* Restore accepts the legacy `unshieldedTxHistory` key so profiles written
-* before the persisted key was renamed load without a resync; the next persist
-* rewrites the doc under `txHistory`, migrating it lazily.
-*/
-const readPersistedTxHistory = (serializedState) => serializedState.txHistory ?? serializedState.unshieldedTxHistory;
-/**
-* djb2 over the serialized states. The previous-persist comparator must not
-* RETAIN the inputs: keeping the raw serialized strings would pin ~10MB per
-* synced wallet in service worker memory between persist cycles.
-*/
-const fingerprintOf = (parts) => {
-	let hash = 5381;
-	for (const part of parts) for (let index = 0; index < part.length; index += 1) {
-		hash = hash * 33 ^ part.charCodeAt(index);
-		hash |= 0;
-	}
-	return `${hash}:${parts.map((part) => part.length).join(":")}`;
-};
-const getAccountWalletInstance = async ({ account, config, getTemenosLedgerIndexerUrl, store, keyManager }, logger, { createAttestedProver, batchUpdates = DEFAULT_BATCH_UPDATES }) => {
-	const walletState = await firstValueFrom(store.get(String(account.accountId)).pipe(defaultIfEmpty(void 0)));
-	const indexerClientConnection = {
-		indexerHttpUrl: config.indexerAddress,
-		indexerWsUrl: convertHttpUrlToWebsocket(config.indexerAddress),
-		keepAlive: 15e3
-	};
-	const { networkId } = account.blockchainSpecific;
-	const proofServerUrl = getProofServerEndpoint(config.proofServer);
-	if (!proofServerUrl) throw new Error(`Cannot start Midnight wallet: proof server mode "${config.proofServer.kind}" has no HTTP endpoint`);
-	assertProofServerRouting(config.proofServer, !!createAttestedProver);
-	const createAccess = (onProgress) => config.proofServer.kind === "tee-delegated" && createAttestedProver ? createAttestedProofServerAccess(createAttestedProver({
-		networkId,
-		proofServerApiUrl: config.proofServer.url,
-		getLedgerIndexerUrl: async () => {
-			if (!getTemenosLedgerIndexerUrl) throw new Error("Temenos attestation requires a ledger indexer resolver");
-			return getTemenosLedgerIndexerUrl();
-		}
-	}), onProgress) : createProofServerAccess(createHttpProofServerTransport(proofServerUrl));
-	const proofServer = createScopedProofServerAccess(createAccess);
-	const { finalizeRecipe } = proofServer;
-	const configuration = {
-		costParameters: {
-			additionalFeeOverhead: 300000000000000n,
-			feeBlocksMargin: 5
-		},
-		networkId,
-		batchUpdates,
-		indexerClientConnection,
-		relayURL: new URL(convertHttpUrlToWebsocket(config.nodeAddress)),
-		txHistoryStorage: new InMemoryTransactionHistoryStorage(WalletEntrySchema, mergeWalletEntries)
-	};
-	if (walletState) {
-		const { dust, shielded, unshielded } = walletState.serializedState;
-		let restoredTxHistoryStorage;
-		try {
-			restoredTxHistoryStorage = InMemoryTransactionHistoryStorage.restore(SerialisedWalletState.toJSON(readPersistedTxHistory(walletState.serializedState)), WalletEntrySchema, mergeWalletEntries);
-		} catch (error) {
-			logger.warn(`Discarding unreadable persisted Midnight wallet state for account ${account.accountId}; rebuilding from seed`, error instanceof Error ? error.message : String(error));
-			await firstValueFrom(store.removeWhere((state) => state.accountId === account.accountId).pipe(defaultIfEmpty(void 0), catchError((wipeError) => {
-				logger.error(`Failed to discard unreadable Midnight wallet state for account ${account.accountId}`, wipeError);
-				return of(void 0);
-			})));
-		}
-		if (restoredTxHistoryStorage) {
-			configuration.txHistoryStorage = restoredTxHistoryStorage;
-			return {
-				walletFacade: await WalletFacade.init({
-					configuration,
-					provingService: () => proofServer.provingService,
-					shielded: (config) => ShieldedWallet(config).restore(SerialisedWalletState.toJSON(shielded)),
-					unshielded: (config) => UnshieldedWallet(config).restore(SerialisedWalletState.toJSON(unshielded)),
-					dust: (config) => DustWallet(config).restore(SerialisedWalletState.toJSON(dust))
-				}),
-				txHistoryStorage: restoredTxHistoryStorage,
-				proofServerTransport: proofServer.transport,
-				finalizeRecipe
-			};
-		}
-	}
-	const { walletKeys: { dustKeyBuffer, zswapKeyBuffer }, unshieldedKeystore } = await firstValueFrom(keysWithAuthCancelledRecovery$(keyManager));
-	const dustParameters = ledger.LedgerParameters.initialParameters().dust;
-	const txHistoryStorage = new InMemoryTransactionHistoryStorage(WalletEntrySchema, mergeWalletEntries);
-	configuration.txHistoryStorage = txHistoryStorage;
-	return {
-		walletFacade: await WalletFacade.init({
-			configuration,
-			provingService: () => proofServer.provingService,
-			shielded: (config) => ShieldedWallet(config).startWithSeed(zswapKeyBuffer),
-			unshielded: (config) => UnshieldedWallet(config).startWithPublicKey(PublicKey.fromKeyStore(unshieldedKeystore)),
-			dust: (config) => DustWallet(config).startWithSeed(dustKeyBuffer, dustParameters)
-		}),
-		txHistoryStorage,
-		proofServerTransport: proofServer.transport,
-		finalizeRecipe
-	};
-};
-/**
-* Creates an observable MidnightWallet from wallet instances.
-*
-* The nightVerifyingKey is obtained from the wallet state, which works
-* for both restored and new wallets.
-*/
-const createAccountObservableMidnightWallet = ({ account, keyManager, walletFacade, haltPersistence, proofServerTransport, finalizeRecipe }) => {
-	const { networkId } = account.blockchainSpecific;
-	const state$ = walletFacade.state().pipe(shareReplay({
-		bufferSize: 1,
-		refCount: true
-	}));
-	const releasing = withReservationRelease(walletFacade);
-	return state$.pipe(take(1), map((initialState) => {
-		const nightVerifyingKey = initialState.unshielded.capabilities.keys.getPublicKey(initialState.unshielded.state);
-		return {
-			accountId: account.accountId,
-			areKeysAvailable$: keyManager.areKeysAvailable$,
-			networkId,
-			nightVerifyingKey,
-			proofServerTransport,
-			walletId: account.walletId,
-			address$: state$.pipe(map(({ dust, shielded, unshielded }) => ({
-				dust: MidnightDustAddress(DustAddress.codec.encode(networkId, dust.capabilities.keys.getAddress(dust.state)).asString()),
-				shielded: MidnightShieldedAddress(ShieldedAddress.codec.encode(networkId, shielded.address).asString()),
-				unshielded: MidnightUnshieldedAddress(UnshieldedAddress.codec.encode(networkId, unshielded.address).asString())
-			})), distinctUntilChanged(deepEquals)),
-			coinsByTokenType$: state$.pipe(map(({ shielded, unshielded }) => {
-				const shieldedCoins = {};
-				const unshieldedCoins = {};
-				for (const { coin } of shielded.totalCoins) {
-					const previousCoinsList = shieldedCoins[coin.type] || [];
-					shieldedCoins[coin.type] = previousCoinsList.concat({
-						status: "mt_index" in coin ? "available" : "pending",
-						value: BigNumber(coin.value)
-					});
-				}
-				const parseUnshieldedCoins = (status, coins) => {
-					for (const { meta, utxo } of coins) {
-						const tokenType = toUnshieldedTokenType(utxo.type, networkId);
-						unshieldedCoins[tokenType] = (unshieldedCoins[tokenType] || []).concat({
-							status,
-							value: BigNumber(utxo.value),
-							registeredForDustGeneration: meta.registeredForDustGeneration,
-							ownerAddress: utxo.owner
-						});
-					}
-				};
-				parseUnshieldedCoins("pending", unshielded.pendingCoins);
-				parseUnshieldedCoins("available", unshielded.availableCoins);
-				return {
-					shielded: shieldedCoins,
-					unshielded: unshieldedCoins
-				};
-			}), distinctUntilChanged(deepEquals)),
-			syncProgress$: state$.pipe(map(({ dust, shielded, unshielded }) => ({
-				dust: computeConnectedSyncRatio(dust.state.progress.appliedIndex, dust.state.progress.highestRelevantWalletIndex, dust.state.progress.isConnected),
-				shielded: computeConnectedSyncRatio(shielded.state.progress.appliedIndex, shielded.state.progress.highestRelevantWalletIndex, shielded.state.progress.isConnected),
-				unshielded: computeConnectedSyncRatio(unshielded.state.progress.appliedId, unshielded.state.progress.highestTransactionId, unshielded.state.progress.isConnected),
-				isStrictlyComplete: {
-					dust: dust.state.progress.isStrictlyComplete(),
-					shielded: shielded.state.progress.isStrictlyComplete(),
-					unshielded: unshielded.state.progress.isStrictlyComplete()
-				}
-			})), distinctUntilChanged(deepEquals)),
-			transactionHistory$: state$.pipe(throttleTime(500, void 0, {
-				leading: true,
-				trailing: true
-			}), switchMap(() => from(walletFacade.getAllFromTxHistory())), distinctUntilChanged(deepEquals)),
-			balanceFinalizedTransaction: (tx, { ttl, tokenKindsToBalance }) => keyManager.keys$.pipe(take(1), switchMap(({ walletKeys: { dustSecretKey, zswapSecretKeys } }) => from(releasing.balanceFinalizedTransaction(tx, {
-				shieldedSecretKeys: zswapSecretKeys,
-				dustSecretKey
-			}, {
-				ttl,
-				tokenKindsToBalance
-			})))),
-			balanceUnboundTransaction: (tx, { ttl, tokenKindsToBalance }) => keyManager.keys$.pipe(take(1), switchMap(({ walletKeys: { dustSecretKey, zswapSecretKeys } }) => from(releasing.balanceUnboundTransaction(tx, {
-				shieldedSecretKeys: zswapSecretKeys,
-				dustSecretKey
-			}, {
-				ttl,
-				tokenKindsToBalance
-			})))),
-			balanceUnprovenTransaction: (tx, { ttl, tokenKindsToBalance }) => keyManager.keys$.pipe(take(1), switchMap(({ walletKeys: { dustSecretKey, zswapSecretKeys } }) => from(walletFacade.balanceUnprovenTransaction(tx, {
-				shieldedSecretKeys: zswapSecretKeys,
-				dustSecretKey
-			}, {
-				ttl,
-				tokenKindsToBalance
-			})))),
-			calculateTransactionFee: (tx) => from(walletFacade.calculateTransactionFee(tx)),
-			estimateTransactionFee: (tx, options) => keyManager.keys$.pipe(take(1), switchMap(({ walletKeys: { dustSecretKey } }) => from(walletFacade.estimateTransactionFee(tx, dustSecretKey, options)))),
-			deregisterFromDustGeneration: (nightUtxos) => keyManager.keys$.pipe(take(1), switchMap(({ unshieldedKeystore }) => from(walletFacade.deregisterFromDustGeneration(nightUtxos, unshieldedKeystore.getPublicKey(), (data) => unshieldedKeystore.signData(data))))),
-			getTransactionHistoryEntryByHash: (hash) => from(walletFacade.queryTxHistoryByHash(hash)),
-			finalizeRecipe: (recipe, onProgress) => defer(async () => finalizeRecipe(walletFacade, recipe, onProgress)),
-			finalizeTransaction: (recipe) => from(walletFacade.finalizeTransaction(recipe)),
-			registerNightUtxosForDustGeneration: (nightUtxos, dustAddress) => keyManager.keys$.pipe(take(1), switchMap(({ unshieldedKeystore }) => from(walletFacade.registerNightUtxosForDustGeneration(nightUtxos, unshieldedKeystore.getPublicKey(), (data) => unshieldedKeystore.signData(data), dustAddress)))),
-			revert: (recipe) => from(walletFacade.revert(recipe)),
-			state: () => state$,
-			stop: () => {
-				haltPersistence();
-				return from(walletFacade.stop());
-			},
-			signUnprovenTransaction: (tx) => keyManager.keys$.pipe(take(1), switchMap(({ unshieldedKeystore }) => from(walletFacade.signUnprovenTransaction(tx, (data) => unshieldedKeystore.signData(data))))),
-			signRecipe: (recipe) => keyManager.keys$.pipe(take(1), switchMap(({ unshieldedKeystore }) => from(walletFacade.signRecipe(recipe, (data) => unshieldedKeystore.signData(data))))),
-			signData: (data) => keyManager.keys$.pipe(take(1), map(({ unshieldedKeystore }) => ({
-				signature: unshieldedKeystore.signData(data),
-				verifyingKey: unshieldedKeystore.getPublicKey()
-			}))),
-			submitTransaction: (tx) => from(walletFacade.submitTransaction(tx)),
-			transferTransaction: (outputs, { ttl, payFees }) => keyManager.keys$.pipe(take(1), switchMap(({ walletKeys: { dustSecretKey, zswapSecretKeys } }) => from(releasing.transferTransaction(outputs, {
-				shieldedSecretKeys: zswapSecretKeys,
-				dustSecretKey
-			}, {
-				ttl,
-				payFees
-			})))),
-			initSwap: (desiredInputs, desiredOutputs, { ttl, payFees }) => keyManager.keys$.pipe(take(1), switchMap(({ walletKeys: { dustSecretKey, zswapSecretKeys } }) => from(releasing.initSwap({
-				desiredInputs,
-				desiredOutputs
-			}, {
-				shieldedSecretKeys: zswapSecretKeys,
-				dustSecretKey
-			}, {
-				ttl,
-				payFees
-			}))))
-		};
-	}));
-};
-/**
-* Creates and manages the lifecycle of Midnight SDK wallet instances.
-*
-* Lifecycle:
-* - Creates all 3 wallets (Unshielded, Shielded, Dust) via getAccountWalletInstance
-* - Starts UnshieldedWallet immediately (no keys needed)
-* - Starts ShieldedWallet and DustWallet once account keys become available
-*   (one auth prompt; sync then runs for the wallet's lifetime, surviving
-*   the key manager's idle zeroization — see the start step below)
-* - DustWallet is never stopped once started
-*   (SDK limitation: stop() closes Effect runtime, breaking calculateFee)
-* - On unsubscribe: stops all wallets and clears the sync key copy
-*/
-const createAndManageWallets = (props, { logger }, options) => {
-	const { keyManager, account, store } = props;
-	return new Observable((subscriber) => {
-		let walletFacade = null;
-		let syncSecretKeys = null;
-		let syncDustSecretKey = null;
-		let syncStartSubscription = null;
-		let persistSubscription = null;
-		let isDestroyed = false;
-		let isPersistenceHalted = false;
-		const init = async () => {
-			const { walletFacade: facade, txHistoryStorage, proofServerTransport, finalizeRecipe } = await getAccountWalletInstance(props, logger, options);
-			if (isDestroyed) {
-				facade.stop();
-				return;
-			}
-			walletFacade = facade;
-			await walletFacade.unshielded.start();
-			syncStartSubscription = keysWithAuthCancelledRecovery$(keyManager).pipe(switchMap((keys) => {
-				if (!walletFacade) return from(Promise.resolve());
-				syncSecretKeys = ledger.ZswapSecretKeys.fromSeed(keys.walletKeys.zswapKeyBuffer);
-				syncDustSecretKey = ledger.DustSecretKey.fromSeed(keys.walletKeys.dustKeyBuffer);
-				const facade = walletFacade;
-				const syncKeys = syncSecretKeys;
-				const dustSyncKey = syncDustSecretKey;
-				return from((async () => {
-					const failures = [];
-					try {
-						await facade.shielded.start(syncKeys);
-					} catch (error) {
-						logger.error(`Midnight shielded wallet failed to start for account ${account.accountId}:`, error);
-						failures.push(error);
-					}
-					try {
-						await facade.dust.start(dustSyncKey);
-					} catch (error) {
-						logger.error(`Midnight dust wallet failed to start for account ${account.accountId}:`, error);
-						failures.push(error);
-					}
-					if (failures.length > 0) throw failures[0];
-				})());
-			})).subscribe({ error: (error) => {
-				logger.error(`Wallet sync start error for account ${account.accountId}:`, error);
-				subscriber.error(error);
-			} });
-			let lastPersistedFingerprint;
-			const persistOnce = async () => {
-				const [dust, shielded, unshielded, txHistory] = (await firstValueFrom(zip(from(walletFacade.dust.serializeState()), from(walletFacade.shielded.serializeState()), from(walletFacade.unshielded.serializeState()), from(txHistoryStorage.serialize())))).map(SerialisedWalletState);
-				const fingerprint = fingerprintOf([
-					dust,
-					shielded,
-					unshielded,
-					txHistory
-				]);
-				if (fingerprint === lastPersistedFingerprint) return;
-				if (isPersistenceHalted || isDestroyed) return;
-				await firstValueFrom(store.upsert({
-					serializedState: {
-						dust,
-						shielded,
-						unshielded,
-						txHistory
-					},
-					accountId: account.accountId,
-					walletId: account.walletId,
-					networkId: account.blockchainSpecific.networkId
-				}).pipe(defaultIfEmpty(void 0)));
-				lastPersistedFingerprint = fingerprint;
-			};
-			persistSubscription = walletFacade.state().pipe(throttleTime(STATE_SERIALISATION_THROTTLE_TIME, void 0, {
-				leading: true,
-				trailing: true
-			}), exhaustMap(() => from(persistOnce()).pipe(catchError((error) => {
-				logger.error(`Failed to persist wallet state for account ${account.accountId}:`, error);
-				return of(void 0);
-			})))).subscribe();
-			subscriber.next({
-				walletFacade,
-				haltPersistence: () => {
-					isPersistenceHalted = true;
-				},
-				proofServerTransport,
-				finalizeRecipe
-			});
-		};
-		init().catch((error) => {
-			subscriber.error(error);
-		});
-		return () => {
-			isDestroyed = true;
-			syncStartSubscription?.unsubscribe();
-			persistSubscription?.unsubscribe();
-			if (walletFacade) walletFacade.stop().catch(() => void 0).finally(() => {
-				syncSecretKeys?.clear();
-				syncDustSecretKey?.clear();
-			});
-		};
-	});
-};
-/**
-* Starts a Midnight account wallet with full lifecycle management.
-*
-* Creates SDK wallets, manages their start/stop lifecycle, and converts
-* to the MidnightWallet interface used by the rest of the application.
-*/
-const createStartMidnightAccountWallet = (dependencies, options) => (props) => createAndManageWallets(props, dependencies, options).pipe(switchMap(({ walletFacade, haltPersistence, proofServerTransport, finalizeRecipe }) => createAccountObservableMidnightWallet({
-	account: props.account,
-	keyManager: props.keyManager,
-	walletFacade,
-	haltPersistence,
-	proofServerTransport,
-	finalizeRecipe
-})));
-/**
-* The engine's side-effect dependencies. The attested prover is the
-* loadout's: the app proves through the bundled Temenos deployment, which a
-* headless loadout does not ship.
-*/
-const createMidnightSideEffectDependencies = (options = {}) => ({ runtime }, dependencies) => {
-	const midnightWallets$ = midnightWalletsForRuntime(runtime);
-	return {
-		midnightWallets$,
-		teeAttestationProgress$,
-		getMidnightWalletByAccountId: (accountId) => midnightWallets$.pipe(take(1), map((wallets) => wallets[accountId]), switchMap((wallet) => wallet ? of(wallet) : throwError(() => /* @__PURE__ */ new Error(`Could not load midnight wallet for account ${accountId}`)))),
-		stopAllMidnightWallets: () => {
-			const walletsArray = Object.values(midnightWallets$.value);
-			midnightWallets$.next({});
-			if (walletsArray.length === 0) return of(void 0);
-			return forkJoin(walletsArray.map((wallet) => wallet.stop())).pipe(map(() => void 0));
-		},
-		stopMidnightWallet: (accountId) => {
-			const wallet = midnightWallets$.value[accountId];
-			if (!wallet) return of(void 0);
-			const { [accountId]: _, ...remaining } = midnightWallets$.value;
-			midnightWallets$.next(remaining);
-			return wallet.stop().pipe(map(() => void 0));
-		},
-		startMidnightAccountWallet: createStartMidnightAccountWallet(dependencies, options)
-	};
-};
-//#endregion
-//#region ../../packages/module/midnight-sync/src/store/utils/activities.ts
-const toBigInt = (v) => typeof v === "bigint" ? v : BigInt(v);
-const buildTokenBalanceChangesFromUtxos = (createdUtxos, spentUtxos, networkId) => {
-	const changesByToken = /* @__PURE__ */ new Map();
-	for (const u of createdUtxos) {
-		const tokenId = TokenId(toUnshieldedTokenType(u.tokenType, networkId));
-		const existing = changesByToken.get(tokenId);
-		const value = toBigInt(u.value);
-		changesByToken.set(tokenId, {
-			tokenId,
-			amount: existing ? existing.amount + value : value
-		});
-	}
-	for (const u of spentUtxos) {
-		const tokenId = TokenId(toUnshieldedTokenType(u.tokenType, networkId));
-		const existing = changesByToken.get(tokenId);
-		const value = toBigInt(u.value);
-		changesByToken.set(tokenId, {
-			tokenId,
-			amount: existing ? existing.amount - value : -value
-		});
-	}
-	return [...changesByToken.values()].filter(({ amount }) => amount !== 0n).map(({ tokenId, amount }) => ({
-		tokenId,
-		amount: BigNumber(amount)
-	}));
-};
-const getAddressFromUtxos = (createdUtxos, spentUtxos) => {
-	return (createdUtxos[0] ?? spentUtxos[0])?.owner ?? "";
-};
-/**
-* Whether the wallet took part in an unshielded movement in this transaction —
-* the gate for surfacing it as an activity. True for unshielded and mixed sends,
-* and for dust designation (which rotates night UTxOs into the unshielded
-* section). False for shielded-only entries: their values are encrypted and
-* unreadable, and the fee-dust they spend never lands in the unshielded section,
-* so surfacing them would only produce an empty/unknown row.
-*/
-const entryHasUnshieldedActivity = (entry) => (entry.unshielded?.createdUtxos.length ?? 0) > 0 || (entry.unshielded?.spentUtxos.length ?? 0) > 0;
-const mapStatusToActivityType = (status, tokenBalanceChanges) => {
-	switch (status) {
-		case "SUCCESS":
-		case "PARTIAL_SUCCESS": return !tokenBalanceChanges?.length || tokenBalanceChanges.some(({ amount }) => BigInt(amount) > 0n) ? ActivityType.Receive : ActivityType.Send;
-		case "FAILURE": return ActivityType.Failed;
-	}
-};
-/**
-* Resolves the activity type and displayed token amounts for a transaction's
-* unshielded section. A transaction that moved unshielded value but nets to zero
-* is a self-transfer — a plain self-send, or a dust designation, which rotates
-* NIGHT back to the owner — so it is surfaced as {@link ActivityType.Self}.
-* No amount is shown: no value left the wallet, and the intended amount is not
-* recoverable (a self output is indistinguishable from change). Failures keep
-* their Failed type regardless.
-*/
-const deriveUnshieldedActivity = ({ status, createdUtxos, spentUtxos, networkId }) => {
-	const netChanges = buildTokenBalanceChangesFromUtxos(createdUtxos, spentUtxos, networkId);
-	if (status !== "FAILURE" && netChanges.length === 0 && (createdUtxos.length > 0 || spentUtxos.length > 0)) return {
-		type: ActivityType.Self,
-		tokenBalanceChanges: []
-	};
-	return {
-		type: mapStatusToActivityType(status, netChanges),
-		tokenBalanceChanges: netChanges
-	};
-};
-const formatFee = (fees) => fees === null || fees === void 0 ? "0" : String(fees);
-//#endregion
-//#region ../../packages/module/midnight-sync/src/store/side-effects/activities.ts
-const mapTxHistoryEntryToActivity = ({ accountId, txHistoryEntry, networkId }) => {
-	const { hash, timestamp, status } = txHistoryEntry;
-	const { type, tokenBalanceChanges } = deriveUnshieldedActivity({
-		status,
-		createdUtxos: txHistoryEntry.unshielded?.createdUtxos ?? [],
-		spentUtxos: txHistoryEntry.unshielded?.spentUtxos ?? [],
-		networkId
-	});
-	return {
-		accountId,
-		activityId: hash,
-		type,
-		timestamp: Timestamp(timestamp?.getTime() ?? 0),
-		tokenBalanceChanges
-	};
-};
-const mapTxHistoryEntryToActivityDetail = ({ accountId, txHistoryEntry, networkId }) => {
-	const createdUtxos = txHistoryEntry.unshielded?.createdUtxos ?? [];
-	const spentUtxos = txHistoryEntry.unshielded?.spentUtxos ?? [];
-	const activity = mapTxHistoryEntryToActivity({
-		accountId,
-		txHistoryEntry,
-		networkId
-	});
-	const address = getAddressFromUtxos(createdUtxos, spentUtxos);
-	return {
-		...activity,
-		address,
-		fee: formatFee(txHistoryEntry.fees)
-	};
-};
-/**
-* Whether confirmed rows with no unshielded section are shown. They carry no
-* readable value or date, so they render as amount-less "unknown" / 1970 rows;
-* hiding them is the default and the flag restores the earlier behaviour while
-* the product decision is open.
-*/
-const showShieldedOnlyRows$ = (stateObservables) => stateObservables.features.selectLoadedFeatures$.pipe(map((loaded) => loaded.featureFlags.some((flag) => flag.key === FEATURE_FLAG_MIDNIGHT_SHIELDED_ACTIVITY_ROWS)), distinctUntilChanged());
-const updateActivities = (_, stateObservables, { actions, midnightWallets$ }) => midnightWallets$.pipe(scan((accumulator, wallets) => ({
-	current: wallets,
-	added: Object.values(wallets).filter((w) => !(w.accountId in accumulator.current))
-}), {
-	current: {},
-	added: []
-}), mergeMap(({ added }) => added), mergeMap((wallet) => combineLatest([wallet.transactionHistory$, showShieldedOnlyRows$(stateObservables)]).pipe(map(([transactionHistory, showShieldedOnlyRows]) => ({
-	activities: transactionHistory.filter((entry) => showShieldedOnlyRows || entryHasUnshieldedActivity(entry)).map((txHistoryEntry) => mapTxHistoryEntryToActivity({
-		accountId: wallet.accountId,
-		txHistoryEntry,
-		networkId: wallet.networkId
-	})),
-	suppressedActivityIds: showShieldedOnlyRows ? [] : transactionHistory.filter((entry) => !entryHasUnshieldedActivity(entry)).map((entry) => entry.hash)
-})), mergeMap(({ activities, suppressedActivityIds }) => [
-	actions.activities.upsertActivities({
-		accountId: wallet.accountId,
-		activities
-	}),
-	...suppressedActivityIds.length > 0 ? [actions.activities.removeActivities({
-		accountId: wallet.accountId,
-		activityIds: suppressedActivityIds
-	})] : [],
-	actions.activities.setHasLoadedOldestEntry({
-		accountId: wallet.accountId,
-		hasLoadedOldestEntry: true
-	}),
-	actions.activities.setDesiredLoadedActivitiesCount({
-		accountId: wallet.accountId,
-		desiredLoadedActivitiesCount: activities.length
-	})
-]), takeUntil(midnightWallets$.pipe(filter((wallets) => !(wallet.accountId in wallets)))))));
-const loadActivityDetails = ({ activities: { loadActivityDetails$ } }, _, { actions, getMidnightWalletByAccountId, logger }) => loadActivityDetails$.pipe(filter(({ payload: { blockchainName } }) => blockchainName === "Midnight"), map((action) => action.payload.activity), switchMap(({ activityId, accountId }) => getMidnightWalletByAccountId(accountId).pipe(switchMap((wallet) => wallet.getTransactionHistoryEntryByHash(activityId).pipe(map((txHistoryEntry) => {
-	if (!txHistoryEntry) return actions.activities.setActivityDetails({ activityDetails: void 0 });
-	return actions.activities.setActivityDetails({ activityDetails: mapTxHistoryEntryToActivityDetail({
-		accountId: wallet.accountId,
-		txHistoryEntry,
-		networkId: wallet.networkId
-	}) });
-}), catchError((error) => {
-	logger.error("Failed to load Midnight activity details", error);
-	return EMPTY;
-}))), catchError(() => EMPTY))));
-//#endregion
-//#region ../../packages/module/midnight-sync/src/store/side-effects/proof-server-kill-switch.ts
-/** Persist the fallback when a selected provider is disabled or no longer
-* belongs to the source-controlled catalogue. Notify once per affected batch. */
-const migrateUnavailableProofServerSelection = (_, { midnightContext: { selectUnavailableProofServerNetworks$, selectNetworksConfig$, selectNetworksConfigFeatureFlagsOverrides$ } }, { actions }) => selectUnavailableProofServerNetworks$.pipe(distinctUntilChanged(isEqual), filter((networkIds) => networkIds.length > 0), withLatestFrom(selectNetworksConfig$, selectNetworksConfigFeatureFlagsOverrides$), mergeMap(([networkIds, networksConfig, featureFlagsOverrides]) => from([...networkIds.map((networkId) => actions.midnightContext.setUserNetworkConfigOverride({
-	networkId,
-	config: networksConfig[networkId],
-	featureFlagsOverrides: featureFlagsOverrides[networkId] ?? {}
-})), actions.ui.showToast({
-	text: "midnight.proof-server.unavailable",
-	color: "neutral",
-	duration: 8,
-	leftIcon: {
-		name: "AlertTriangle",
-		size: 20
-	}
-})])));
-//#endregion
-//#region ../../packages/module/midnight-sync/src/store/side-effects/resync.ts
-const withMidnightAccounts = (makeSideEffect) => (actionObservables, stateObservables, dependencies) => makeSideEffect(midnightAccounts$(stateObservables))(actionObservables, stateObservables, dependencies);
-const requestResyncWallet = withMidnightAccounts((midnightAccount$) => ({ midnightSync: { requestResync$ } }, _, { actions }) => merge(requestResync$.pipe(withLatestFrom(midnightAccount$), switchMap(([_, accounts]) => {
-	return from([...accounts.map(({ accountId }) => actions.sync.addSyncOperation({
-		accountId,
-		operation: {
-			operationId: `${accountId}-midnight-sync`,
-			status: "Pending",
-			description: "sync.operation.midnight-resync",
-			startedAt: Timestamp(Date.now())
-		}
-	})), actions.midnightSync.resync()]);
-}))));
-const createClearWalletStateOnResync = (store) => withMidnightAccounts((midnightAccounts$) => ({ midnightSync: { resync$ } }, _, { actions, stopAllMidnightWallets, logger }) => resync$.pipe(withLatestFrom(midnightAccounts$), switchMap(([_, midnightAccounts]) => stopAllMidnightWallets().pipe(catchError((error) => {
-	logger.error("Midnight resync: stop failed", error);
-	return of(void 0);
-}), switchMap(() => store.clear().pipe(defaultIfEmpty(void 0), catchError((error) => {
-	logger.error("Midnight resync: state wipe failed", error);
-	return of(void 0);
-}))), switchMap(() => [...midnightAccounts.flatMap(({ accountId }) => [
-	actions.addresses.resetAddresses({ accountId }),
-	actions.tokens.resetAccountTokens({ accountId }),
-	actions.activities.resetActivities({ accountId }),
-	actions.midnightContext.resetAccountDust({ accountId })
-]), actions.midnightSync.restartWalletWatch()])))));
-/**
-* Side-effect that triggers a Midnight wallet resync whenever the config change
-* is made with a feature flag override and the wallet is unlocked.
-*/
-const resyncWalletOnConfigChangeFromFeatureFlags = withMidnightAccounts((midnightAccounts$) => (_, { appLock: { isUnlocked$ }, midnightContext: { selectCurrentNetwork$, selectNetworksConfigFeatureFlagsOverrides$ } }, { actions }) => {
-	return selectNetworksConfigFeatureFlagsOverrides$.pipe(withLatestFrom(isUnlocked$), filter(([_, isUnlocked]) => isUnlocked), switchMap(() => selectCurrentNetwork$.pipe(take(1))), map(({ config }) => config), distinctUntilChanged(deepEquals)).pipe(withLatestFrom(midnightAccounts$), switchMap(([_, midnightAccounts]) => from([...midnightAccounts.map(({ accountId }) => actions.sync.addSyncOperation({
-		accountId,
-		operation: {
-			operationId: `${accountId}-midnight-sync`,
-			status: "Pending",
-			description: "sync.operation.midnight-resync",
-			startedAt: Timestamp(Date.now())
-		}
-	})), actions.midnightSync.resync()])));
-});
-const createDeleteWalletSideEffect = (storage) => ({ wallets: { removeWallet$ } }, { wallets: { selectAll$ } }, { stopMidnightWallet, actions, logger }) => removeWallet$.pipe(withLatestFrom(selectAll$.pipe(map((wallets) => wallets.filter(hasMidnightAccount)))), switchMap(([{ payload }, midnightWallets]) => {
-	const walletId = typeof payload === "string" ? payload : payload.walletId;
-	const targetWallet = midnightWallets.find((w) => w.walletId === walletId);
-	if (!targetWallet) return EMPTY;
-	const allMidnightAccounts = targetWallet.accounts.filter(isInMemoryMidnightAccount);
-	return (allMidnightAccounts.length > 0 ? forkJoin(allMidnightAccounts.map(({ accountId }) => stopMidnightWallet(accountId))) : of([])).pipe(switchMap(() => storage.removeWhere((wallet) => wallet.walletId === walletId).pipe(defaultIfEmpty(void 0), catchError((error) => {
-		logger.error("Midnight delete wallet: state wipe failed", error);
-		return of(void 0);
-	}))), mergeMap(() => allMidnightAccounts.flatMap(({ accountId }) => [
-		actions.addresses.resetAddresses({ accountId }),
-		actions.tokens.resetAccountTokens({ accountId }),
-		actions.activities.resetActivities({ accountId })
-	])));
-}));
-/**
-* Stops one Midnight account's wallet, wipes that account's persisted SDK
-* state, then emits the actions that clear every redux cache the wiped state
-* fed. Scoped to a single account, unlike `createClearWalletStateOnResync`,
-* which wipes the whole chain.
-*
-* A step that errors or completes without emitting is handed to
-* `onStepFailure`: return an observable that emits to carry on with the next
-* step, or one that errors to abort the reset with that error.
-*/
-const stopAndWipeAccountState$ = ({ accountId, actions, store, stop$, onStepFailure }) => stop$.pipe(take(1), throwIfEmpty(() => /* @__PURE__ */ new Error("Midnight account stop did not acknowledge completion")), catchError((error) => onStepFailure("stop", error)), switchMap(() => store.removeWhere((wallet) => wallet?.accountId === accountId).pipe(throwIfEmpty(() => /* @__PURE__ */ new Error("Midnight account storage wipe did not acknowledge completion")), catchError((error) => onStepFailure("wipe", error)))), mergeMap(() => [
-	actions.addresses.resetAddresses({ accountId }),
-	actions.tokens.resetAccountTokens({ accountId }),
-	actions.activities.resetActivities({ accountId }),
-	actions.midnightContext.resetAccountDust({ accountId }),
-	actions.sync.resetAccountSyncStatus({ accountId })
-]));
-/**
-* The extension's per-account "reset sync state": stops and wipes the account,
-* then reloads the app so every engine restarts from empty state. Stop and wipe
-* failures are logged and the reset carries on, because the reload is what
-* recovers the account.
-*
-* The reload is emitted LAST, after the storage write settles: sequencing it
-* inside this chain (rather than firing it from a separate UI tap) is what stops
-* a hard reload from preempting the wipe and leaving the old SDK document to
-* restore from.
-*/
-const createResetSyncStateSideEffect = (store) => withMidnightAccounts((midnightAccounts$) => ({ midnightContext: { resetSyncState$ } }, _, { actions, stopMidnightWallet, logger }) => resetSyncState$.pipe(withLatestFrom(midnightAccounts$), switchMap(([{ payload }, midnightAccounts]) => {
-	const account = midnightAccounts.find(({ accountId }) => accountId === payload.accountId);
-	if (!account) return EMPTY;
-	const { accountId } = account;
-	return concat(stopAndWipeAccountState$({
-		accountId,
-		actions,
-		store,
-		stop$: stopMidnightWallet(accountId),
-		onStepFailure: (step, error) => {
-			logger.error(`Midnight reset sync state: ${step} failed`, error);
-			return of(void 0);
-		}
-	}), of(actions.app.reloadApplication()));
-})));
-/**
-* The headless per-account "reset sync state": stops and wipes the account,
-* then restarts that account's watcher in place, since a headless runtime has
-* no application to reload. The account's sync operation reads Pending while
-* the reset runs and Failed if a stop or wipe fails, so the caller can observe
-* the outcome and retry.
-*/
-const createHeadlessResetSyncStateSideEffect = (store) => withMidnightAccounts((midnightAccounts$) => ({ midnightContext: { resetSyncState$ } }, _, { actions, stopMidnightWallet, logger }) => resetSyncState$.pipe(withLatestFrom(midnightAccounts$), groupBy(([{ payload }]) => payload.accountId), mergeMap((requests$) => requests$.pipe(exhaustMap(([{ payload }, midnightAccounts]) => {
-	const account = midnightAccounts.find(({ accountId }) => accountId === payload.accountId);
-	if (!account) return EMPTY;
-	const { accountId } = account;
-	const pendingOperation = () => actions.sync.addSyncOperation({
-		accountId,
-		operation: {
-			operationId: `${accountId}-midnight-sync`,
-			status: "Pending",
-			description: "sync.operation.midnight-resync",
-			startedAt: Timestamp(Date.now())
-		}
-	});
-	const stop$ = merge(of(void 0), requests$).pipe(switchMap(() => defer(() => stopMidnightWallet(accountId)).pipe(throwIfEmpty(() => /* @__PURE__ */ new Error("Midnight account stop did not acknowledge completion")))));
-	return concat(of(pendingOperation()), stopAndWipeAccountState$({
-		accountId,
-		actions,
-		store,
-		stop$,
-		onStepFailure: (step, error) => {
-			logger.error(`Midnight reset sync state: ${step} failed`, error);
-			return throwError(() => error);
-		}
-	}), defer(() => of(pendingOperation(), actions.midnightSync.restartAccountWatch({ accountId })))).pipe(catchError((error) => {
-		logger.error("Midnight account resync failed", error);
-		const failedAt = Timestamp(Date.now());
-		return of(actions.sync.addSyncOperation({
-			accountId,
-			operation: {
-				operationId: `${accountId}-midnight-sync`,
-				status: "Failed",
-				description: "sync.operation.midnight-resync",
-				error: "sync.error.midnight-sync-failed",
-				startedAt: failedAt,
-				failedAt
-			}
-		}));
-	}));
-})))));
-//#endregion
-//#region ../../packages/module/midnight-sync/src/store/side-effects/sync-failure.ts
-/**
-* Dismiss a Midnight account's sync failure once its own sync recovers.
-*
-* The `completeSyncOperation` for `${accountId}-midnight-sync` is the
-* "recovered" signal, whichever route got there — transparent retry, the
-* failure's tap-to-retry `restartWalletWatch`, or the resubscription `whileActive`
-* performs on unlock.
-*
-* Keyed per-account, so no lookup is needed: a completion for a sibling Midnight
-* account (or a Cardano/Bitcoin one) maps to a different, non-existent
-* MidnightSyncFailureId and no-ops, leaving a still-broken account's failure in
-* place until its OWN sync completes.
-*/
-const autoDismissMidnightSyncFailureOnSyncSuccess = ({ sync: { completeSyncOperation$ } }, { failures: { selectFailureById$ } }) => completeSyncOperation$.pipe(map(({ payload }) => MidnightSyncFailureId(payload.accountId)), autoDismissFailureOnSuccess(selectFailureById$));
-/**
-* On resume, clear the sync failure for every Midnight account.
-*
-* Complements the per-account recovery dismissal above by clearing a stale error
-* immediately, rather than leaving it on screen for the length of the first sync
-* after unlock. No restart is dispatched: `watchMidnightAccounts` ends its pipe
-* with `whileActive`, so resuming already resubscribes every account watcher.
-* Accounts with no failure are a no-op.
-*/
-const autoDismissMidnightSyncFailureOnResume = (_, { wallets: { selectAll$ }, failures: { selectFailureById$ } }, { walletResumed$ }) => walletResumed$.pipe(withLatestFrom(selectAll$), mergeMap(([, wallets]) => from(wallets.flatMap((wallet) => wallet.accounts).filter(isInMemoryMidnightAccount).map((account) => MidnightSyncFailureId(account.accountId)))), autoDismissFailureOnSuccess(selectFailureById$));
-//#endregion
-//#region ../../packages/module/midnight-sync/src/store/side-effects/tee-attestation-progress.ts
-/**
-* Forwards attested-proving progress from the dependency-level stream into
-* redux, where the send-flow checklist UI reads it. Pure mapping — the
-* events originate inside the proving service (ADR 19).
-*/
-const watchTeeAttestationProgress = (_actionObservables, _stateObservables, { actions, teeAttestationProgress$ }) => teeAttestationProgress$.pipe(map((event) => event.type === "begin" ? actions.midnightContext.teeAttestationProgressStarted(event) : actions.midnightContext.teeAttestationProgressUpdated(event)));
-/**
-* Clears the previous run's checklist as soon as a new Midnight transaction
-* starts building, so a redone send never opens the
-* processing screen with stale step results. The attested proving service's
-* `reset` then rebuilds the pending checklist when verification actually
-* begins. The signer owns confirmation resets. Submit must not clear the
-* completed checklist while the transaction is being submitted.
-*/
-const clearTeeAttestationProgressOnNewTx = ({ txExecutor: { txPhaseRequested$ } }, _stateObservables, { actions }) => txPhaseRequested$.pipe(filter(({ payload: { config } }) => config.params.blockchainName === "Midnight" && config.type === "buildTx"), map(() => actions.midnightContext.teeAttestationProgressCleared()));
-//#endregion
-//#region ../../packages/module/midnight-sync/src/store/side-effects/index.ts
-/**
-* The engine's side effects plus the ones a loadout adds over the same
-* persisted wallet-state storage. The engine set reads only the contracts
-* the engine itself depends on; a loadout decides what else it can run.
-*/
-const createInitializeSideEffects = (loadoutSideEffects) => () => [(actionObservables, stateObservables, dependencies) => {
-	const midnightStateStorage = dependencies.createCollectionStorage({
-		collectionId: "midnightWalletState",
-		computeDocId: (wallet) => String(wallet.accountId)
-	});
-	return merge(...[
-		updateActivities,
-		loadActivityDetails,
-		createDeleteWalletSideEffect(midnightStateStorage),
-		createClearWalletStateOnResync(midnightStateStorage),
-		requestResyncWallet,
-		autoDismissMidnightSyncFailureOnResume,
-		autoDismissMidnightSyncFailureOnSyncSuccess,
-		watchMidnightAccounts(midnightStateStorage, watchMidnightAccount),
-		...loadoutSideEffects(midnightStateStorage)
-	].map((sideEffect) => sideEffect(actionObservables, stateObservables, dependencies)));
-}];
-createInitializeSideEffects((storage) => [
-	createResetSyncStateSideEffect(storage),
-	resyncWalletOnConfigChangeFromFeatureFlags,
-	migrateUnavailableProofServerSelection,
-	watchTeeAttestationProgress,
-	clearTeeAttestationProgressOnNewTx
-]);
-//#endregion
-//#region ../../packages/module/midnight-sync/src/store/side-effects/network-config.ts
-/**
-* Applies a loadout's supported networks and default proof servers right
-* after the first action the store handles, which redux-persist dispatches
-* while the store is created. Both therefore hold before the store is handed
-* out and before any side effect starts: a side effect would land a tick
-* later, and a network selected in between would be checked against the
-* contract's full list.
-*/
-const createApplyNetworkDefaultsMiddleware = ({ supportedNetworkIds, defaultProofServers }) => {
-	const { setDefaultProofServers, setSupportedNetworksIds } = midnightContextActions.midnightContext;
-	return (store) => (next) => {
-		let pending = [...supportedNetworkIds ? [setSupportedNetworksIds(supportedNetworkIds)] : [], ...defaultProofServers ? [setDefaultProofServers(defaultProofServers)] : []];
-		return (action) => {
-			const result = next(action);
-			const defaults = pending;
-			pending = [];
-			for (const defaultAction of defaults) store.dispatch(defaultAction);
-			return result;
-		};
-	};
-};
-/**
-* Applies a loadout's endpoint choices as user overrides on startup, so they
-* take precedence over the contract defaults and the feature-flag values
-* without a settings UI to enter them through.
-*/
-const createApplyNetworkConfigOverrides = (overrides) => (_, { midnightContext: { selectNetworksConfig$, selectNetworksConfigFeatureFlagsOverrides$ } }, { actions }) => zip(selectNetworksConfig$.pipe(take(1)), selectNetworksConfigFeatureFlagsOverrides$.pipe(take(1))).pipe(mergeMap(([networksConfig, featureFlagsOverrides]) => Object.entries(overrides).map(([networkId, override]) => actions.midnightContext.setUserNetworkConfigOverride({
-	networkId,
-	config: {
-		...networksConfig[networkId],
-		...override
-	},
-	featureFlagsOverrides: featureFlagsOverrides[networkId]
-}))));
-//#endregion
-//#region ../../packages/module/midnight-sync/src/store/sdk-init.ts
-const assertDefaultTestnetConfigured = (config) => {
-	const networkId = config?.defaultMidnightTestnetNetworkId;
-	if (!networkId || !MidnightSDKTestNetworkId.includes(networkId)) throw new Error(`createLaceWallet needs config.defaultMidnightTestnetNetworkId, the Midnight testnet a wallet starts on: one of ${MidnightSDKTestNetworkId.join(", ")}; got ${String(networkId)}`);
-};
-const createSdkStoreInit = ({ auth, batchUpdates, createAttestedProver, networks = {}, supportedNetworkIds, defaultProofServers }) => {
-	const initializeSideEffects = createInitializeSideEffects((storage) => [
-		registerMidnightBlockchainNetworks,
-		createApplyNetworkConfigOverrides(networks),
-		createHeadlessResetSyncStateSideEffect(storage)
-	]);
-	const initializeDependencies = createMidnightSideEffectDependencies({
-		batchUpdates,
-		createAttestedProver
-	});
-	return (props, dependencies) => {
-		assertDefaultTestnetConfigured(props.runtime.config);
-		return {
-			middleware: [createApplyNetworkDefaultsMiddleware({
-				supportedNetworkIds,
-				defaultProofServers
-			})],
-			sideEffects: initializeSideEffects(props, dependencies),
-			sideEffectDependencies: {
-				...initializeDependencies(props, dependencies),
-				...auth
-			}
-		};
-	};
-};
-//#endregion
-export { createSdkStoreInit };