@laceio/sdk 0.1.1 → 0.1.2-canary.1

package/dist/sdk-init-CYViTJY_.cjs

@@ -0,0 +1,3841 @@
+const require_rolldown_runtime = require("./rolldown-runtime-Br2OG8yv.cjs");
+const require__polyfill_buffer_patch = require("./_polyfill-buffer-patch-CM8X7JiY.cjs");
+require("./codecs-Cswkg7Tm.cjs");
+const require_bytes_vo = require("./bytes.vo-BNRquqaO.cjs");
+const require_time_vo = require("./time.vo-D3wWRw9L.cjs");
+const require_bignum_vo = require("./bignum.vo-hx2kuqlA.cjs");
+const require_auto_dismiss_failure_on_success = require("./auto-dismiss-failure-on-success-C-qoJuid.cjs");
+require("./retry-config-BaCfVC1H.cjs");
+const require_activity_type = require("./activity-type-Ch6ljxBy.cjs");
+const require_token_id_vo = require("./token-id.vo-DXv5uS9n.cjs");
+const require_types = require("./types-DWbVZpnF.cjs");
+require("./bn-d3nSOIf7.cjs");
+const require_const = require("./const-BsnjG2_Q.cjs");
+const require_watch = require("./watch-DMF2s-II.cjs");
+const require_slice = require("./slice-Czfp6t84.cjs");
+const require_utils = require("./utils-IXxR-Djh.cjs");
+const require_midnight_wallet = require("./midnight-wallet-XTZc2li7.cjs");
+const require_dist = require("./dist-BtIq4XFn.cjs");
+require("./client-DXBLHk7K.cjs");
+const require_send_proof_progress = require("./send-proof-progress-vmsaSfbz.cjs");
+let _laceio_cardano_util = require("@laceio/cardano/util");
+let rxjs = require("rxjs");
+rxjs = require_rolldown_runtime.__toESM(rxjs);
+let lodash_isEqual = require("lodash/isEqual.js");
+lodash_isEqual = require_rolldown_runtime.__toESM(lodash_isEqual);
+let _midnight_ntwrk_ledger_v8 = require("@midnight-ntwrk/ledger-v8");
+_midnight_ntwrk_ledger_v8 = require_rolldown_runtime.__toESM(_midnight_ntwrk_ledger_v8);
+//#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 : require_bytes_vo.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) => (0, rxjs.combineLatest)([
+	state.wallets.selectActiveNetworkAccounts$,
+	state.midnightContext.selectMidnightBlockchainNetworkId$.pipe((0, rxjs.filter)(Boolean)),
+	state.wallets.selectIsWalletRepoMigrating$
+]).pipe((0, rxjs.map)(([accounts, activeNetwork, isWalletRepoMigrating]) => isWalletRepoMigrating ? [] : accounts.filter(require_utils.isInMemoryMidnightAccount).filter((account) => account.blockchainNetworkId === activeNetwork)), (0, rxjs.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((0, rxjs.filter)((blockchainNetworks) => !blockchainNetworks?.Midnight), (0, rxjs.withLatestFrom)(selectDefaultTestNetNetworkId$, selectAll$.pipe((0, rxjs.map)((allWallets) => allWallets.flatMap((wallet) => wallet.accounts)))), (0, rxjs.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: require_const.MidnightNetworkId("mainnet"),
+		testnet: require_const.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$2 = (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$2(balance.shielded ? reserve(await facade.shielded.balanceTransaction(shieldedSecretKeys, transaction), facade.shielded) : void 0, unshieldedBalancing);
+		const balancingTransaction = merge$2(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$2(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$2(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$2(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$2(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$2(swap, payFees ? await facade.dust.balanceTransactions(dustSecretKey, [swap], ttl) : void 0) ?? swap
+		};
+	})
+});
+//#endregion
+//#region ../../packages/lib/vendor/src/midnight-submission-service.ts
+const observers = /* @__PURE__ */ new WeakMap();
+const awaitDisconnection = (client) => require_const.async((resume) => {
+	if (!client.api.isConnected) {
+		resume(require_const._void);
+		return;
+	}
+	const disconnected = () => {
+		resume(require_const._void);
+	};
+	client.api.once("disconnected", disconnected);
+	return require_const.sync(() => client.api.off("disconnected", disconnected));
+});
+/** Preserve facade submission/rollback semantics while observing its single stream. */
+const createProgressSubmissionService = ({ relayURL }) => {
+	const scope = require_const.runSync(require_const.make$3());
+	const submissions = require_const.runSync(require_const.makeSemaphore(1));
+	const connection = require_watch.PolkadotNodeClient.make({ nodeURL: relayURL }).pipe(require_const.provideService(require_const.Scope, scope), require_const.tap(awaitDisconnection), require_const.cached, require_const.runSync);
+	const submit = async (tx, waitFor = "InBlock") => {
+		const serialized = require_const.from(tx);
+		return connection.pipe(require_const.flatMap((client) => client.sendMidnightTransaction(serialized).pipe(require_watch.tap((event) => require_const.sync(() => observers.get(tx)?.(event._tag))), require_watch.find((event) => event._tag === waitFor), require_watch.runHead, require_const.flatMap(require_const.match$3({
+			onSome: require_const.succeed,
+			onNone: () => require_const.fail$1(new require_watch.TransactionProgressError({
+				message: "Transaction did not reach desired stage",
+				txData: serialized,
+				desiredStage: waitFor
+			}))
+		})), require_const.ensuring(awaitDisconnection(client)))), submissions.withPermits(1), require_const.mapError$1((cause) => new require_watch.SubmissionError({
+			message: "Transaction submission error",
+			cause
+		})), require_const.runPromise);
+	};
+	return {
+		submitTransaction: submit,
+		close: async () => require_const.close(scope, require_const.void_).pipe(require_const.ignoreLogged, require_const.runPromise)
+	};
+};
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v1/CoreWallet.js
+const PublicKey = { fromSecretKey: (secretKey) => {
+	return { publicKey: secretKey.publicKey };
+} };
+const CoreWallet$1 = {
+	init(localState, secretKey, networkId) {
+		return CoreWallet$1.empty(localState, PublicKey.fromSecretKey(secretKey), networkId);
+	},
+	initEmpty(dustParameters, secretKey, networkId) {
+		return CoreWallet$1.empty(new _midnight_ntwrk_ledger_v8.DustLocalState(dustParameters), PublicKey.fromSecretKey(secretKey), networkId);
+	},
+	empty(localState, publicKey, networkId) {
+		return {
+			state: localState,
+			publicKey,
+			networkId,
+			pendingDust: [],
+			progress: require_const.createSyncProgress(),
+			protocolVersion: require_const.MinSupportedVersion
+		};
+	},
+	restore(localState, publicKey, pendingTokens, syncProgress, protocolVersion, networkId) {
+		return {
+			state: localState,
+			publicKey,
+			networkId,
+			pendingDust: pendingTokens,
+			progress: require_const.createSyncProgress(syncProgress),
+			protocolVersion: require_const.ProtocolVersion(protocolVersion)
+		};
+	},
+	applyEventsWithChanges(wallet, secretKey, events, currentTime) {
+		const stateWithChanges = wallet.state.replayEventsWithChanges(secretKey, events);
+		const updatedState = stateWithChanges.state.processTtls(currentTime);
+		const availableNonces = updatedState.utxos.map((utxo) => utxo.nonce);
+		return [{
+			...wallet,
+			state: updatedState,
+			pendingDust: wallet.pendingDust.filter((t) => availableNonces.includes(t.nonce))
+		}, stateWithChanges.changes];
+	},
+	applyFailed(wallet, tx) {
+		const pendingSpendsMap = CoreWallet$1.pendingDustToMap(wallet.pendingDust);
+		const [updatedState, removedNullifiers] = require_const.pipe(require_const.pipe([...tx.intents?.values() ?? []], require_const.flatMap$3((intent) => {
+			const spendTime = intent.dustActions?.ctime;
+			return (intent.dustActions?.spends ?? []).map((spend) => ({
+				spend,
+				spendTime
+			}));
+		}), require_const.filterMap$1(({ spend, spendTime }) => require_const.pipe(require_const.fromNullable(pendingSpendsMap.get(spend.oldNullifier)), require_const.map$8(() => ({
+			spend,
+			spendTime
+		}))))), require_const.reduce$3([wallet.state, []], ([state, removed], { spend, spendTime }) => [state.processTtls(require_watch.addSeconds(spendTime, wallet.state.params.dustGracePeriodSeconds)), require_const.append$1(removed, spend.oldNullifier)]));
+		return {
+			...wallet,
+			state: updatedState,
+			pendingDust: wallet.pendingDust.filter((coin) => !removedNullifiers.includes(coin.nullifier))
+		};
+	},
+	revertTransaction(wallet, tx) {
+		return CoreWallet$1.applyFailed(wallet, tx);
+	},
+	updateProgress(wallet, { appliedIndex, highestRelevantWalletIndex, highestIndex, highestRelevantIndex, isConnected }) {
+		const updatedProgress = require_const.createSyncProgress({
+			appliedIndex: appliedIndex ?? wallet.progress.appliedIndex,
+			highestRelevantWalletIndex: highestRelevantWalletIndex ?? wallet.progress.highestRelevantWalletIndex,
+			highestIndex: highestIndex ?? wallet.progress.highestIndex,
+			highestRelevantIndex: highestRelevantIndex ?? wallet.progress.highestRelevantIndex,
+			isConnected: isConnected ?? wallet.progress.isConnected
+		});
+		return {
+			...wallet,
+			progress: updatedProgress
+		};
+	},
+	spendCoins(wallet, secretKey, coins, currentTime) {
+		const [output, newState, newPending] = require_const.pipe(coins, require_const.reduce$3([
+			[],
+			wallet.state,
+			wallet.pendingDust
+		], ([spends, localState, pending], { token: coinToSpend, value: takeFee }) => {
+			const [newState, dustSpend] = localState.spend(secretKey, coinToSpend, takeFee, currentTime);
+			const newPending = [...pending, {
+				...coinToSpend,
+				nullifier: dustSpend.oldNullifier
+			}];
+			return [
+				require_const.append$1(spends, dustSpend),
+				newState,
+				newPending
+			];
+		}));
+		return [output, {
+			...wallet,
+			state: newState,
+			pendingDust: newPending
+		}];
+	},
+	pendingDustToMap(coins) {
+		return new Map(coins.map(({ nullifier, ...coins }) => [nullifier, coins]));
+	}
+};
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v1/WalletError.js
+var OtherWalletError$1 = class extends require_const.TaggedError("Wallet.Other") {};
+var SyncWalletError$1 = class extends require_const.TaggedError("Wallet.Sync") {};
+var TransactingError = class extends require_const.TaggedError("Wallet.Transacting") {};
+var InsufficientFundsError$1 = class extends require_const.TaggedError("Wallet.InsufficientFunds") {};
+var TransactionHistoryError$1 = class extends require_const.TaggedError("Wallet.TransactionHistory") {};
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v1/RunningV1Variant.js
+const progress$1 = (state) => {
+	const appliedIndex = state.progress?.appliedIndex ?? 0n;
+	const highestRelevantWalletIndex = state.progress?.highestRelevantWalletIndex ?? 0n;
+	const sourceGap = (state.progress?.highestIndex ?? 0n) - (state.progress?.highestRelevantIndex ?? 0n);
+	const applyGap = highestRelevantWalletIndex - appliedIndex;
+	return [require_watch.ProgressUpdate({
+		sourceGap,
+		applyGap
+	})];
+};
+const protocolVersionChange$1 = (previous, current) => {
+	return previous.protocolVersion != current.protocolVersion ? [require_watch.VersionChange({ change: require_watch.Version({ version: require_const.ProtocolVersion(current.protocolVersion) }) })] : [];
+};
+const V1Tag$1 = Symbol("V1");
+var RunningV1Variant$1 = class {
+	__polyTag__ = V1Tag$1;
+	#scope;
+	#context;
+	#v1Context;
+	state;
+	constructor(scope, context, v1Context) {
+		this.#scope = scope;
+		this.#context = context;
+		this.#v1Context = v1Context;
+		this.state = require_watch.fromEffect(context.stateRef.get).pipe(require_watch.flatMap((initialState) => context.stateRef.changes.pipe(require_watch.mapAccum(initialState, (previous, current) => {
+			return [current, [previous, current]];
+		}))), require_watch.mapConcat(([previous, current]) => {
+			return [
+				require_watch.State({ state: current }),
+				...progress$1(current),
+				...protocolVersionChange$1(previous, current)
+			];
+		}));
+	}
+	startSyncInBackground(startAux) {
+		return this.startSync(startAux).pipe(require_watch.runScoped(require_watch.drain), require_const.forkScoped, require_const.provideService(require_const.Scope, this.#scope));
+	}
+	startSync(startAux) {
+		return require_const.pipe(require_watch.get(this.#context.stateRef), require_watch.fromEffect, require_watch.flatMap((state) => this.#v1Context.syncService.updates(state, startAux)), require_watch.mapEffect((update) => require_watch.modifyEffect(this.#context.stateRef, (state) => require_const.try_({
+			try: () => {
+				const [newState, changesResult] = this.#v1Context.syncCapability.applyUpdate(state, update);
+				return [changesResult, newState];
+			},
+			catch: (err) => new OtherWalletError$1({
+				message: "Error while applying sync update",
+				cause: err
+			})
+		})).pipe(require_const.flatMap(({ changes, protocolVersion }) => changes.length === 0 ? require_const._void : require_const.pipe(require_const.forEach(changes, (change) => require_const.pipe(this.#v1Context.transactionHistoryService.getTransactionDetails(change.source), require_const.flatMap((metadata) => this.#v1Context.transactionHistoryService.put(change, metadata, protocolVersion)), require_const.catchAllCause((cause) => require_watch.error("Error processing tx history metadata", cause))), {
+			discard: true,
+			concurrency: "unbounded"
+		}), require_const.forkScoped)), require_const.provideService(require_const.Scope, this.#scope))), require_watch.tapError((error$2) => require_watch.error(error$2)), require_watch.retry(require_const.pipe(require_watch.exponential(require_const.seconds(1), 2), require_watch.map$1((delay) => {
+			const maxDelay = require_const.minutes(2);
+			const jitter = require_const.millis(Math.floor(Math.random() * 1e3));
+			const delayWithJitter = require_const.toMillis(delay) + require_const.toMillis(jitter);
+			return require_const.millis(Math.min(delayWithJitter, require_const.toMillis(maxDelay)));
+		}))));
+	}
+	createDustGenerationTransaction(currentTime, ttl, nightUtxos, nightVerifyingKey, dustReceiverAddress) {
+		if (nightUtxos.some((utxo) => utxo.type !== (0, _midnight_ntwrk_ledger_v8.nativeToken)().raw)) return require_const.fail$1(new OtherWalletError$1({ message: "Token of a non-Night type received" }));
+		return require_const.gen(this, function* () {
+			const currentState = yield* require_watch.get(this.#context.stateRef);
+			const blockData = yield* this.#v1Context.syncService.blockData();
+			const resolvedTime = currentTime ?? blockData.timestamp;
+			const utxosWithDustValue = this.#v1Context.coinsAndBalancesCapability.estimateDustGeneration(currentState, nightUtxos, resolvedTime);
+			return yield* this.#v1Context.transactingCapability.createDustGenerationTransaction(resolvedTime, ttl, utxosWithDustValue, nightVerifyingKey, dustReceiverAddress).pipe(require_watch.toEffect);
+		});
+	}
+	splitNightUtxosForDustRegistration(currentTime, nightUtxos, isRegistration) {
+		if (nightUtxos.some((utxo) => utxo.type !== (0, _midnight_ntwrk_ledger_v8.nativeToken)().raw)) return require_const.fail$1(new OtherWalletError$1({ message: "Token of a non-Night type received" }));
+		return require_const.gen(this, function* () {
+			const currentState = yield* require_watch.get(this.#context.stateRef);
+			const utxosWithDustValue = this.#v1Context.coinsAndBalancesCapability.estimateDustGeneration(currentState, nightUtxos, currentTime);
+			return this.#v1Context.transactingCapability.splitNightUtxosForDustRegistration(utxosWithDustValue, isRegistration);
+		});
+	}
+	attachDustRegistration(transaction, currentTime, nightVerifyingKey, dustReceiverAddress, feePayment) {
+		return this.#v1Context.transactingCapability.attachDustRegistration(transaction, currentTime, nightVerifyingKey, dustReceiverAddress, feePayment).pipe(require_watch.toEffect);
+	}
+	addDustGenerationSignature(transaction, signature) {
+		return this.#v1Context.transactingCapability.addDustGenerationSignature(transaction, signature).pipe(require_watch.toEffect);
+	}
+	addDustRegistrationSignature(transaction, signature) {
+		return this.#v1Context.transactingCapability.addDustRegistrationSignature(transaction, signature).pipe(require_watch.toEffect);
+	}
+	calculateFee(transactions) {
+		return require_const.pipe(this.#v1Context.syncService.blockData(), require_const.map((blockData) => require_const.pipe(transactions, require_const.map$6((transaction) => this.#v1Context.transactingCapability.calculateFee(transaction, blockData.ledgerParameters)), require_watch.sumBigInt)));
+	}
+	estimateFee(secretKey, transactions, ttl, currentTime) {
+		return require_const.pipe(require_const.all([require_watch.get(this.#context.stateRef), this.#v1Context.syncService.blockData()]), require_const.flatMap(([state, blockData]) => require_const.pipe(this.#v1Context.transactingCapability.estimateFee(secretKey, state, transactions, ttl, currentTime ?? blockData.timestamp, blockData.ledgerParameters), require_watch.toEffect)));
+	}
+	balanceTransactions(secretKey, transactions, ttl, currentTime) {
+		return require_watch.modifyEffect(this.#context.stateRef, (state) => {
+			return require_const.pipe(this.#v1Context.syncService.blockData(), require_const.flatMap((blockData) => this.#v1Context.transactingCapability.balanceTransactions(secretKey, state, transactions, ttl, currentTime ?? blockData.timestamp, blockData.ledgerParameters)));
+		});
+	}
+	revertTransaction(transaction) {
+		return require_watch.updateEffect(this.#context.stateRef, (state) => {
+			return require_const.pipe(this.#v1Context.transactingCapability.revertTransaction(state, transaction), require_watch.toEffect);
+		});
+	}
+};
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v1/Serialization.js
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+const StateSchema$1 = require_const.declare((input) => input instanceof _midnight_ntwrk_ledger_v8.DustLocalState).annotations({ identifier: "ledger.DustLocalState" });
+const Uint8ArraySchema$2 = require_const.declare((input) => input instanceof Uint8Array).annotations({ identifier: "Uint8Array" });
+const StateFromUInt8Array$1 = require_const.asSchema(require_const.transformOrFail(Uint8ArraySchema$2, StateSchema$1, {
+	encode: (state) => {
+		return require_const.try_({
+			try: () => {
+				return state.serialize();
+			},
+			catch: (err) => {
+				return new require_const.Unexpected(err, "Could not serialize local state");
+			}
+		});
+	},
+	decode: (bytes) => require_const.try_({
+		try: () => _midnight_ntwrk_ledger_v8.DustLocalState.deserialize(bytes),
+		catch: (err) => {
+			return new require_const.Unexpected(err, "Could not deserialize local state");
+		}
+	})
+}));
+const HexedState$1 = require_const.pipe(require_const.Uint8ArrayFromHex, require_const.compose(StateFromUInt8Array$1));
+const SnapshotSchema = require_const.Struct({
+	publicKey: require_const.Struct({ publicKey: require_const.BigInt$ }),
+	state: HexedState$1,
+	protocolVersion: require_const.BigInt$,
+	networkId: require_const.String$,
+	offset: require_const.optional(require_const.BigInt$)
+});
+const makeDefaultV1SerializationCapability$1 = () => {
+	return {
+		serialize: (wallet) => {
+			const buildSnapshot = (w) => ({
+				publicKey: w.publicKey,
+				state: w.state,
+				protocolVersion: w.protocolVersion,
+				networkId: w.networkId,
+				offset: w.progress?.appliedIndex
+			});
+			return require_const.pipe(wallet, buildSnapshot, require_const.encodeSync(SnapshotSchema), JSON.stringify);
+		},
+		deserialize: (aux, serialized) => {
+			return require_const.pipe(serialized, require_const.decodeUnknownEither(require_const.parseJson(SnapshotSchema)), require_const.mapLeft((err) => new OtherWalletError$1({
+				message: "Error while deserializing snapshot",
+				cause: err
+			})), require_const.flatMap$4((snapshot) => require_const.try_$1({
+				try: () => CoreWallet$1.restore(snapshot.state, snapshot.publicKey, [], {
+					appliedIndex: snapshot.offset ?? 0n,
+					highestRelevantWalletIndex: 0n,
+					highestIndex: 0n,
+					highestRelevantIndex: 0n
+				}, snapshot.protocolVersion, snapshot.networkId),
+				catch: (err) => new OtherWalletError$1({
+					message: "Error while restoring core wallet",
+					cause: err
+				})
+			})));
+		}
+	};
+};
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v1/Sync.js
+const LedgerEventSchema$1 = require_const.declare((input) => input instanceof _midnight_ntwrk_ledger_v8.Event).annotations({ identifier: "ledger.Event" });
+const LedgerEventFromUInt8Array = require_const.asSchema(require_const.transformOrFail(Uint8ArraySchema$2, LedgerEventSchema$1, {
+	encode: (e) => require_const.try_({
+		try: () => e.serialize(),
+		catch: (err) => new require_const.Unexpected(err, "Could not serialize Ledger Event")
+	}),
+	decode: (bytes) => require_const.try_({
+		try: () => _midnight_ntwrk_ledger_v8.Event.deserialize(bytes),
+		catch: (err) => new require_const.Unexpected(err, "Could not deserialize Ledger Event")
+	})
+}));
+const HexedEvent = require_const.pipe(require_const.Uint8ArrayFromHex, require_const.compose(LedgerEventFromUInt8Array));
+const SyncEventsUpdateSchema = require_const.Struct({
+	id: require_const.Number$,
+	raw: HexedEvent,
+	maxId: require_const.Number$
+});
+const WalletSyncUpdate$1 = { create: (updates, secretKey, timestamp) => {
+	return {
+		updates,
+		secretKey,
+		timestamp
+	};
+} };
+const makeDefaultSyncService = (config) => {
+	const indexerSyncService = makeIndexerSyncService(config);
+	return {
+		updates: (state, secretKey) => {
+			const batchSize = config.batchUpdates?.size ?? 10;
+			const batchTimeout = require_const.millis(config.batchUpdates?.timeout ?? 1);
+			const batchSpacing = config.batchUpdates?.spacing ?? 4;
+			return require_const.pipe(indexerSyncService.subscribeWallet(state), require_watch.groupedWithin(batchSize, batchTimeout), require_watch.map(require_const.toArray), require_watch.map((data) => WalletSyncUpdate$1.create(data, secretKey, /* @__PURE__ */ new Date())), batchSpacing > 0 ? require_watch.schedule(require_watch.spaced(require_const.millis(batchSpacing))) : (eventsStream) => eventsStream, require_watch.provideSomeLayer(indexerSyncService.connectionLayer()));
+		},
+		blockData: () => {
+			return require_const.gen(function* () {
+				return (yield* (yield* require_watch.BlockHash)({ offset: null })).block;
+			}).pipe(require_const.provide(indexerSyncService.queryClient()), require_const.scoped$1, require_const.catchAll((err) => require_const.fail$1(new OtherWalletError$1({
+				message: `Encountered unexpected error: ${err.message}`,
+				cause: err
+			}))), require_const.flatMap((blockData) => {
+				if (!blockData) throw new OtherWalletError$1({ message: "Unable to fetch block data" });
+				return require_watch.ledgerTry(() => ({
+					hash: blockData.hash,
+					height: blockData.height,
+					ledgerParameters: _midnight_ntwrk_ledger_v8.LedgerParameters.deserialize(require__polyfill_buffer_patch.import_buffer.Buffer.from(blockData.ledgerParameters, "hex")),
+					timestamp: new Date(blockData.timestamp)
+				}));
+			}));
+		}
+	};
+};
+const makeIndexerSyncService = (config) => {
+	return {
+		queryClient() {
+			return require_const.pipe(require_watch.layer$1({ url: config.indexerClientConnection.indexerHttpUrl }), require_const.mapError((error) => new OtherWalletError$1(error)));
+		},
+		connectionLayer() {
+			const { indexerClientConnection } = config;
+			return require_watch.createWebSocketUrl(indexerClientConnection.indexerHttpUrl, indexerClientConnection.indexerWsUrl).pipe(require_const.flatMap$4((url) => require_watch.make(url)), require_const.match$4({
+				onLeft: (error) => require_const.fail(error),
+				onRight: (url) => require_watch.layer({
+					url,
+					keepAlive: indexerClientConnection.keepAlive
+				})
+			}), require_const.mapError((e) => new SyncWalletError$1({
+				message: "Failed to to obtain correct indexer URLs",
+				cause: e
+			})));
+		},
+		subscribeWallet(state) {
+			const { appliedIndex } = state.progress;
+			const bufferSize = config.indexerClientConnection.bufferSize ?? 1e4;
+			const resumeThreshold = config.indexerClientConnection.resumeThreshold ?? 100;
+			const resumeFrom = appliedIndex - 1n;
+			return require_const.pipe(require_watch.DustLedgerEvents.runWithBackpressure({
+				bufferSize,
+				resumeThreshold,
+				from: resumeFrom,
+				variables: (cursor) => ({ id: cursor < 0n ? null : Number(cursor) }),
+				key: (r) => BigInt(r.dustLedgerEvents.id)
+			}), require_watch.mapEffect((subscription) => require_const.pipe(require_const.decodeUnknownEither(SyncEventsUpdateSchema)(subscription.dustLedgerEvents), require_const.mapLeft((err) => new SyncWalletError$1(err)), require_watch.toEffect)), require_watch.mapError((error) => new SyncWalletError$1(error)));
+		}
+	};
+};
+const makeDefaultSyncCapability = () => {
+	return { applyUpdate(state, wrappedUpdate) {
+		const { updates, secretKey } = wrappedUpdate;
+		if (updates.length === 0) return [state, {
+			changes: [],
+			protocolVersion: Number(state.protocolVersion)
+		}];
+		const appliedIndex = state.progress.appliedIndex;
+		const freshUpdates = updates.filter((u) => BigInt(u.id) > appliedIndex);
+		const highestRelevantWalletIndex = BigInt(updates.at(-1).maxId);
+		const [newState, changes] = freshUpdates.length === 0 ? [state, []] : CoreWallet$1.applyEventsWithChanges(state, secretKey, freshUpdates.map((u) => u.raw), wrappedUpdate.timestamp);
+		const updatedState = CoreWallet$1.updateProgress(newState, {
+			appliedIndex: freshUpdates.length === 0 ? appliedIndex : BigInt(freshUpdates.at(-1).id),
+			highestRelevantWalletIndex,
+			isConnected: true
+		});
+		return [updatedState, {
+			changes,
+			protocolVersion: Number(updatedState.protocolVersion)
+		}];
+	} };
+};
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v1/TransactionHistory.js
+const DustUtxoInfoSchema = require_const.Struct({
+	initialValue: require_const.BigInt$,
+	nonce: require_const.BigInt$,
+	seq: require_const.Number$,
+	backingNight: require_const.String$,
+	mtIndex: require_const.BigInt$
+});
+const DustSectionSchema = require_const.Struct({
+	receivedUtxos: require_const.Array$(DustUtxoInfoSchema),
+	spentUtxos: require_const.Array$(DustUtxoInfoSchema)
+});
+require_const.Struct({
+	hash: require_const.TransactionHashSchema,
+	protocolVersion: require_const.Number$,
+	status: require_const.TransactionHistoryStatusSchema,
+	dust: DustSectionSchema
+});
+const utxoEquals = require_const.equivalence(DustUtxoInfoSchema);
+const mergeDustSections = (existing, incoming) => ({
+	receivedUtxos: require_const.unionWith$1(existing.receivedUtxos, incoming.receivedUtxos, utxoEquals),
+	spentUtxos: require_const.unionWith$1(existing.spentUtxos, incoming.spentUtxos, utxoEquals)
+});
+const convertQualifiedDustOutput = (utxo) => ({
+	initialValue: utxo.initialValue,
+	nonce: utxo.nonce,
+	seq: utxo.seq,
+	backingNight: utxo.backingNight,
+	mtIndex: utxo.mtIndex
+});
+const convertUpdateToStorageEntry$1 = (changes, metadata, protocolVersion) => ({
+	hash: changes.source,
+	protocolVersion,
+	status: metadata.status,
+	dust: {
+		receivedUtxos: changes.receivedUtxos.map(convertQualifiedDustOutput),
+		spentUtxos: changes.spentUtxos.map(convertQualifiedDustOutput)
+	}
+});
+const upsertDustEntry = (txHistoryStorage, entry) => require_const.tryPromise({
+	try: () => txHistoryStorage.upsert(entry),
+	catch: (e) => new TransactionHistoryError$1({
+		message: `Failed to upsert history entry for ${entry.hash}`,
+		cause: e
+	})
+});
+const makeDefaultTransactionHistoryService$1 = (config, _getContext) => {
+	const txHistoryStorage = config.txHistoryStorage;
+	const queryClientLayer = require_watch.layer$1({ url: config.indexerClientConnection.indexerHttpUrl });
+	return {
+		put: (changes, metadata, protocolVersion) => {
+			return upsertDustEntry(txHistoryStorage, convertUpdateToStorageEntry$1(changes, metadata, protocolVersion));
+		},
+		getTransactionDetails: (hash) => require_const.gen(function* () {
+			const tx = (yield* (yield* require_watch.TransactionHistoryDetail)({ transactionHash: hash })).transactions[0];
+			const rawStatus = tx.__typename === "RegularTransaction" ? tx.transactionResult.status : void 0;
+			const status = rawStatus === "FAILURE" || rawStatus === "PARTIAL_SUCCESS" ? rawStatus : "SUCCESS";
+			return {
+				hash: tx.hash,
+				timestamp: tx.block.timestamp,
+				status
+			};
+		}).pipe(require_const.provide(queryClientLayer), require_const.scoped$1, require_const.retry(require_watch.exponential(require_const.seconds(1)).pipe(require_watch.compose(require_watch.recurs(3)))), require_const.mapError$1((cause) => new TransactionHistoryError$1({
+			message: `Failed to fetch transaction metadata for ${hash}`,
+			cause
+		})))
+	};
+};
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v1/Keys.js
+const makeDefaultKeysCapability$1 = () => {
+	return {
+		getPublicKey: (state) => {
+			return state.publicKey.publicKey;
+		},
+		getAddress: (state) => {
+			return new require_dist.DustAddress(state.publicKey.publicKey);
+		}
+	};
+};
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v1/CoinsAndBalances.js
+const chooseCoin = (coins) => coins.filter((coin) => coin.value > 0n).toSorted((a, b) => Number(a.value - b.value)).at(0);
+const FAKE_NONCE = "0".repeat(64);
+const makeDefaultCoinsAndBalancesCapability$1 = (_config, getContext) => {
+	const getWalletBalance = (state, time) => {
+		return state.state.walletBalance(time);
+	};
+	const getGenerationInfo = (state, coin) => {
+		const info = state.state.generationInfo(coin);
+		return info && info.dtime ? {
+			...info,
+			dtime: /* @__PURE__ */ new Date(+info.dtime)
+		} : info;
+	};
+	const resolveTime = (state, time) => time ?? state.state.syncTime;
+	const toFullInfo = (state, coins, time) => coins.flatMap((coin) => {
+		const genInfo = getGenerationInfo(state, coin);
+		return genInfo ? [{
+			token: coin,
+			...getFullDustInfo(state.state.params, genInfo, coin, time)
+		}] : [];
+	});
+	const availableDustTokens = (state) => {
+		const pendingSpends = new Set([...state.pendingDust.values()].map((coin) => coin.nonce));
+		return require_const.pipe(state.state.utxos, require_const.filter$2((coin) => !pendingSpends.has(coin.nonce)));
+	};
+	const getAvailableCoins = (state, time) => toFullInfo(state, availableDustTokens(state), resolveTime(state, time));
+	const getPendingCoins = (state, time) => toFullInfo(state, state.pendingDust, resolveTime(state, time));
+	const getTotalCoins = (state, time) => {
+		const effectiveTime = resolveTime(state, time);
+		return [...getAvailableCoins(state, effectiveTime), ...getPendingCoins(state, effectiveTime)];
+	};
+	const getAvailableCoinsWithGeneratedDust = (state, currentTime) => getAvailableCoins(state, currentTime).map((info) => ({
+		token: info.token,
+		value: info.generatedNow
+	}));
+	const getFullDustInfo = (parameters, genInfo, coin, currentTime) => {
+		const generatedValue = _midnight_ntwrk_ledger_v8.updatedValue(coin.ctime, coin.initialValue, genInfo, currentTime, parameters);
+		return {
+			dtime: genInfo.dtime,
+			maxCap: genInfo.value * parameters.nightDustRatio,
+			maxCapReachedAt: require_watch.addSeconds(coin.ctime, parameters.timeToCapSeconds),
+			generatedNow: generatedValue,
+			rate: genInfo.value * parameters.generationDecayRate
+		};
+	};
+	const estimateDustGeneration = (state, nightUtxos, currentTime) => {
+		const dustPublicKey = getContext().keysCapability.getPublicKey(state);
+		return require_const.pipe(nightUtxos, require_const.map$6((utxo) => {
+			const genInfo = fakeGenerationInfo(utxo, dustPublicKey);
+			const fakeDustCoin = fakeDustToken(dustPublicKey, utxo);
+			return {
+				utxo,
+				dust: getFullDustInfo(state.state.params, genInfo, fakeDustCoin, currentTime)
+			};
+		}));
+	};
+	/** Create a fake generation info for a given Utxo. It allows to estimate the Dust generation from it */
+	const fakeGenerationInfo = (utxo, dustPublicKey) => {
+		return {
+			value: utxo.value,
+			owner: dustPublicKey,
+			nonce: FAKE_NONCE,
+			dtime: void 0
+		};
+	};
+	/** Create a fake dust coin for a given Utxo. It allows to estimate full details of the Dust generation from it */
+	const fakeDustToken = (dustPublicKey, utxo) => ({
+		initialValue: 0n,
+		owner: dustPublicKey,
+		nonce: 0n,
+		seq: 0,
+		ctime: utxo.ctime,
+		backingNight: "",
+		mtIndex: 0n
+	});
+	const splitNightUtxos = (utxos) => {
+		const [guaranteed, fallible] = require_const.pipe(utxos, require_const.sort(require_const.pipe(require_const.bigint, require_const.reverse, require_const.mapInput$1((coin) => coin.dust.generatedNow))), require_const.splitAt$1(1));
+		return {
+			guaranteed,
+			fallible
+		};
+	};
+	return {
+		getWalletBalance,
+		getAvailableCoins,
+		getPendingCoins,
+		getTotalCoins,
+		getAvailableCoinsWithGeneratedDust,
+		getGenerationInfo,
+		estimateDustGeneration,
+		splitNightUtxos
+	};
+};
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v1/Utils.js
+const SignatureMarker = {
+	signature: "signature",
+	signatureErased: "signature-erased"
+};
+const ProofMarker = {
+	proof: "proof",
+	preProof: "pre-proof",
+	noProof: "no-proof"
+};
+const BindingMarker = {
+	binding: "binding",
+	preBinding: "pre-binding",
+	noBinding: "no-binding"
+};
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v1/Transacting.js
+const makeDefaultTransactingCapability$1 = (config, getContext) => {
+	return new TransactingCapabilityImplementation$1(config.networkId, config.costParameters, () => getContext().coinSelection, () => getContext().coinsAndBalancesCapability, () => getContext().keysCapability);
+};
+/**
+* Distributes the fee across multiple inputs, draining smaller inputs first when the fee exceeds any single input's
+* value. Finds the next available intent segment id in a transaction.
+*
+* Fallible intent segments occupy the range `[1, 65535]`; segment `0` is reserved for the guaranteed section and is
+* never returned.
+*
+* @param transaction - Transaction whose intent map is inspected.
+* @returns `Some(segmentId)` with the lowest unused id, or `None` if all 65535 fallible segments are taken.
+*/
+const findAvailableSegmentId = (transaction) => {
+	const used = new Set(transaction.intents?.keys() ?? []);
+	return require_const.pipe(require_const.range$1(1, 65535), require_const.findFirst$2((segmentId) => !used.has(segmentId)));
+};
+/**
+* Distributes the fee across multiple inputs, draining smaller inputs first when the fee exceeds any single input's
+* value.
+*/
+const distributeFeeAcrossInputs = (inputs, fee) => inputs.reduce(({ result, remaining }, input) => {
+	const deduction = remaining >= input.value ? input.value : remaining;
+	return {
+		result: [...result, {
+			...input,
+			value: deduction
+		}],
+		remaining: remaining - deduction
+	};
+}, {
+	result: [],
+	remaining: fee
+}).result;
+var TransactingCapabilityImplementation$1 = class TransactingCapabilityImplementation$1 {
+	networkId;
+	costParams;
+	getCoinSelection;
+	getCoins;
+	getKeys;
+	constructor(networkId, costParams, getCoinSelection, getCoins, getKeys) {
+		this.getCoins = getCoins;
+		this.networkId = networkId;
+		this.costParams = costParams;
+		this.getCoinSelection = getCoinSelection;
+		this.getKeys = getKeys;
+	}
+	createDustGenerationTransaction(currentTime, ttl, nightUtxos, nightVerifyingKey, dustReceiverAddress) {
+		const makeOffer = (utxos) => {
+			if (utxos.length === 0) return require_const.none();
+			const totalValue = require_const.pipe(utxos, require_const.map$7((coin) => coin.utxo.value), require_const.sumAll);
+			const inputs = utxos.map(({ utxo }) => ({
+				...utxo,
+				owner: nightVerifyingKey
+			}));
+			const output = {
+				owner: (0, _midnight_ntwrk_ledger_v8.addressFromKey)(nightVerifyingKey),
+				type: (0, _midnight_ntwrk_ledger_v8.nativeToken)().raw,
+				value: totalValue
+			};
+			return require_const.some(_midnight_ntwrk_ledger_v8.UnshieldedOffer.new(inputs, [output], []));
+		};
+		return require_const.gen$1(this, function* () {
+			const receiver = dustReceiverAddress ? dustReceiverAddress.data : void 0;
+			return yield* require_watch.ledgerTry(() => {
+				const network = this.networkId;
+				const splitResult = this.getCoins().splitNightUtxos(nightUtxos);
+				const feePayment = receiver ? require_const.pipe(splitResult.guaranteed, require_const.filter$3((coin) => !coin.utxo.registeredForDustGeneration), require_const.map$7((coin) => coin.dust.generatedNow), require_const.sumAll) : 0n;
+				const maybeGuaranteedOffer = makeOffer(splitResult.guaranteed);
+				const maybeFallibleOffer = makeOffer(splitResult.fallible);
+				const dustRegistration = new _midnight_ntwrk_ledger_v8.DustRegistration(SignatureMarker.signature, nightVerifyingKey, receiver, feePayment);
+				const dustActions = new _midnight_ntwrk_ledger_v8.DustActions(SignatureMarker.signature, ProofMarker.preProof, currentTime, [], [dustRegistration]);
+				const intent = require_const.pipe(_midnight_ntwrk_ledger_v8.Intent.new(ttl), (intent) => require_const.match$3(maybeGuaranteedOffer, {
+					onNone: () => intent,
+					onSome: (guaranteedOffer) => {
+						intent.guaranteedUnshieldedOffer = guaranteedOffer;
+						return intent;
+					}
+				}), (intent) => require_const.match$3(maybeFallibleOffer, {
+					onNone: () => intent,
+					onSome: (fallibleOffer) => {
+						intent.fallibleUnshieldedOffer = fallibleOffer;
+						return intent;
+					}
+				}), (intent) => {
+					intent.dustActions = dustActions;
+					return intent;
+				});
+				return _midnight_ntwrk_ledger_v8.Transaction.fromParts(network, void 0, void 0, intent);
+			});
+		});
+	}
+	splitNightUtxosForDustRegistration(utxosWithDustValue, isRegistration) {
+		const splitResult = this.getCoins().splitNightUtxos(utxosWithDustValue);
+		const feePayment = isRegistration ? require_const.pipe(splitResult.guaranteed, require_const.filter$3((coin) => !coin.utxo.registeredForDustGeneration), require_const.map$7((coin) => coin.dust.generatedNow), require_const.sumAll) : 0n;
+		return {
+			guaranteedUtxos: splitResult.guaranteed,
+			fallibleUtxos: splitResult.fallible,
+			feePayment
+		};
+	}
+	attachDustRegistration(transaction, currentTime, nightVerifyingKey, dustReceiverAddress, feePayment) {
+		return require_const.gen$1(this, function* () {
+			const intent = transaction.intents?.get(1);
+			if (!intent) return yield* require_const.left(new TransactingError({ message: "No intent found at segment 1; expected an intent built by rotateUtxos" }));
+			if (intent.dustActions !== void 0 && intent.dustActions.registrations.length > 0) return yield* require_const.left(new TransactingError({ message: "Intent at segment 1 already has a dust registration attached" }));
+			return yield* require_watch.ledgerTry(() => {
+				const receiver = dustReceiverAddress ? dustReceiverAddress.data : void 0;
+				const dustRegistration = new _midnight_ntwrk_ledger_v8.DustRegistration(SignatureMarker.signature, nightVerifyingKey, receiver, feePayment);
+				const dustActions = new _midnight_ntwrk_ledger_v8.DustActions(SignatureMarker.signature, ProofMarker.preProof, currentTime, [], [dustRegistration]);
+				const newIntent = _midnight_ntwrk_ledger_v8.Intent.deserialize(SignatureMarker.signature, ProofMarker.preProof, BindingMarker.preBinding, intent.serialize());
+				newIntent.dustActions = dustActions;
+				const newTransaction = _midnight_ntwrk_ledger_v8.Transaction.deserialize(SignatureMarker.signature, ProofMarker.preProof, BindingMarker.preBinding, transaction.serialize());
+				newTransaction.intents = newTransaction.intents.set(1, newIntent);
+				return newTransaction;
+			});
+		});
+	}
+	addDustRegistrationSignature(transaction, signatureData) {
+		return require_const.gen$1(this, function* () {
+			const intent = transaction.intents?.get(1);
+			if (!intent) return yield* require_const.left(new TransactingError({ message: "No intent found in the transaction intents with segment = 1" }));
+			const { dustActions } = intent;
+			if (!dustActions) return yield* require_const.left(new TransactingError({ message: "No dustActions found in intent" }));
+			const [registration, ...restRegistrations] = dustActions.registrations;
+			if (!registration) return yield* require_const.left(new TransactingError({ message: "No registrations found in dustActions" }));
+			return yield* require_watch.ledgerTry(() => {
+				const signature = new _midnight_ntwrk_ledger_v8.SignatureEnabled(signatureData);
+				const registrationWithSignature = new _midnight_ntwrk_ledger_v8.DustRegistration(signature.instance, registration.nightKey, registration.dustAddress, registration.allowFeePayment, signature);
+				const newDustActions = new _midnight_ntwrk_ledger_v8.DustActions(signature.instance, ProofMarker.preProof, dustActions.ctime, dustActions.spends, [registrationWithSignature, ...restRegistrations]);
+				const newIntent = _midnight_ntwrk_ledger_v8.Intent.deserialize(signature.instance, ProofMarker.preProof, BindingMarker.preBinding, intent.serialize());
+				newIntent.dustActions = newDustActions;
+				const newTransaction = _midnight_ntwrk_ledger_v8.Transaction.deserialize(signature.instance, ProofMarker.preProof, BindingMarker.preBinding, transaction.serialize());
+				newTransaction.intents = newTransaction.intents.set(1, newIntent);
+				return newTransaction;
+			});
+		});
+	}
+	addDustGenerationSignature(transaction, signatureData) {
+		return require_const.gen$1(this, function* () {
+			const intent = transaction.intents?.get(1);
+			if (!intent) return yield* require_const.left(new TransactingError({ message: "No intent found in the transaction intents with segment = 1" }));
+			const { dustActions, guaranteedUnshieldedOffer, fallibleUnshieldedOffer } = intent;
+			if (!dustActions) return yield* require_const.left(new TransactingError({ message: "No dustActions found in intent" }));
+			if (!guaranteedUnshieldedOffer) return yield* require_const.left(new TransactingError({ message: "No guaranteedUnshieldedOffer found in intent" }));
+			const [registration, ...restRegistrations] = dustActions.registrations;
+			if (!registration) return yield* require_const.left(new TransactingError({ message: "No registrations found in dustActions" }));
+			return yield* require_watch.ledgerTry(() => {
+				const signature = new _midnight_ntwrk_ledger_v8.SignatureEnabled(signatureData);
+				const registrationWithSignature = new _midnight_ntwrk_ledger_v8.DustRegistration(signature.instance, registration.nightKey, registration.dustAddress, registration.allowFeePayment, signature);
+				const newDustActions = new _midnight_ntwrk_ledger_v8.DustActions(signature.instance, ProofMarker.preProof, dustActions.ctime, dustActions.spends, [registrationWithSignature, ...restRegistrations]);
+				const newIntent = _midnight_ntwrk_ledger_v8.Intent.deserialize(signature.instance, ProofMarker.preProof, BindingMarker.preBinding, intent.serialize());
+				newIntent.dustActions = newDustActions;
+				const inputsLen = guaranteedUnshieldedOffer.inputs.length;
+				const signatures = [];
+				for (let i = 0; i < inputsLen; ++i) signatures.push(guaranteedUnshieldedOffer.signatures.at(i) ?? signatureData);
+				newIntent.guaranteedUnshieldedOffer = guaranteedUnshieldedOffer.addSignatures(signatures);
+				if (fallibleUnshieldedOffer) {
+					const inputsLen = fallibleUnshieldedOffer.inputs.length;
+					const signatures = [];
+					for (let i = 0; i < inputsLen; ++i) signatures.push(fallibleUnshieldedOffer.signatures.at(i) ?? signatureData);
+					newIntent.fallibleUnshieldedOffer = fallibleUnshieldedOffer.addSignatures(signatures);
+				}
+				const newTransaction = _midnight_ntwrk_ledger_v8.Transaction.deserialize(signature.instance, ProofMarker.preProof, BindingMarker.preBinding, transaction.serialize());
+				newTransaction.intents = newTransaction.intents.set(1, newIntent);
+				return newTransaction;
+			});
+		});
+	}
+	calculateFee(transaction, ledgerParams) {
+		return transaction.feesWithMargin(ledgerParams, this.costParams.feeBlocksMargin) + (this.costParams.additionalFeeOverhead ?? 0n);
+	}
+	dryRunFee(recipeInputs, transactions, secretKey, state, ttl, currentTime, ledgerParams) {
+		const network = this.networkId;
+		const [spends] = CoreWallet$1.spendCoins(state, secretKey, recipeInputs, currentTime);
+		const intent = _midnight_ntwrk_ledger_v8.Intent.new(ttl);
+		intent.dustActions = new _midnight_ntwrk_ledger_v8.DustActions(SignatureMarker.signature, ProofMarker.preProof, currentTime, [...spends], []);
+		const [first, ...rest] = transactions.map((tx) => tx.eraseProofs());
+		const mergedExisting = first ? rest.reduce((acc, tx) => acc.merge(tx), first) : void 0;
+		const segmentId = mergedExisting ? require_const.getOrElse(findAvailableSegmentId(mergedExisting), () => 1) : 1;
+		const erasedBalancing = _midnight_ntwrk_ledger_v8.Transaction.fromParts(network).addIntent({
+			tag: "specific",
+			value: segmentId
+		}, intent).eraseProofs();
+		const mergedTx = mergedExisting ? mergedExisting.merge(erasedBalancing) : erasedBalancing;
+		return this.calculateFee(mergedTx, ledgerParams);
+	}
+	static feeImbalance(transaction, totalFee) {
+		const [_, imbalance] = transaction.imbalances(0, totalFee).entries().find(([tt, _]) => tt.tag === "dust") ?? [];
+		return imbalance ?? 0n;
+	}
+	computeBalancingRecipe(secretKey, state, transactions, ttl, currentTime, ledgerParams) {
+		const initialFees = transactions.reduce((total, transaction) => total + TransactingCapabilityImplementation$1.feeImbalance(transaction, this.calculateFee(transaction, ledgerParams)), 0n);
+		const dust = this.getCoins().getAvailableCoinsWithGeneratedDust(state, currentTime);
+		return require_const.pipe(require_const.iterate({
+			currentFee: initialFees,
+			recipeInputs: [],
+			converged: false
+		}, {
+			while: (s) => !s.converged,
+			body: ({ currentFee }) => require_const.try_({
+				try: () => {
+					const recipeInputs = require_watch.getBalanceRecipe({
+						coins: dust.map((coin) => ({
+							type: "dust",
+							value: coin.value,
+							token: coin.token
+						})),
+						initialImbalances: require_watch.Imbalances.fromEntry("dust", currentFee),
+						feeTokenType: "dust",
+						coinSelection: this.getCoinSelection(),
+						transactionCostModel: {
+							inputFeeOverhead: 0n,
+							outputFeeOverhead: 0n
+						},
+						createOutput: (coin) => coin,
+						isCoinEqual: (a, b) => a.token.nonce === b.token.nonce
+					}).inputs.map(({ token, value }) => ({
+						token,
+						value
+					}));
+					const newFee = this.dryRunFee(recipeInputs, transactions, secretKey, state, ttl, currentTime, ledgerParams);
+					return {
+						currentFee: newFee,
+						recipeInputs,
+						converged: newFee <= recipeInputs.reduce((sum, input) => sum + input.value, 0n)
+					};
+				},
+				catch: (err) => {
+					if (err instanceof require_watch.InsufficientFundsError) return new InsufficientFundsError$1({
+						message: err.message,
+						tokenType: err.tokenType
+					});
+					else return new OtherWalletError$1({
+						message: err instanceof Error ? err.message : "Dust balancing failed",
+						cause: err
+					});
+				}
+			})
+		}), require_const.either, require_const.runSync, require_const.map$9(({ currentFee, recipeInputs }) => ({
+			fee: currentFee,
+			recipeInputs: distributeFeeAcrossInputs(recipeInputs, currentFee)
+		})));
+	}
+	estimateFee(secretKey, state, transactions, ttl, currentTime, ledgerParams) {
+		return require_const.pipe(this.computeBalancingRecipe(secretKey, state, transactions, ttl, currentTime, ledgerParams), require_const.map$9(({ fee }) => fee));
+	}
+	balanceTransactions(secretKey, state, transactions, ttl, currentTime, ledgerParams) {
+		const networkId = this.networkId;
+		return require_const.pipe(this.computeBalancingRecipe(secretKey, state, transactions, ttl, currentTime, ledgerParams), require_const.flatMap$4(({ recipeInputs }) => {
+			return require_watch.ledgerTry(() => {
+				const intent = _midnight_ntwrk_ledger_v8.Intent.new(ttl);
+				const [spends, updatedState] = CoreWallet$1.spendCoins(state, secretKey, recipeInputs, currentTime);
+				intent.dustActions = new _midnight_ntwrk_ledger_v8.DustActions(SignatureMarker.signature, ProofMarker.preProof, currentTime, [...spends], []);
+				const [first, ...rest] = transactions.map((tx) => tx.eraseProofs());
+				const mergedExisting = first ? rest.reduce((acc, tx) => acc.merge(tx), first) : void 0;
+				const segmentId = mergedExisting ? require_const.getOrElse(findAvailableSegmentId(mergedExisting), () => 1) : 1;
+				return [_midnight_ntwrk_ledger_v8.Transaction.fromParts(networkId).addIntent({
+					tag: "specific",
+					value: segmentId
+				}, intent), updatedState];
+			});
+		}));
+	}
+	revertTransaction(state, transaction) {
+		return require_const.try_$1({
+			try: () => CoreWallet$1.revertTransaction(state, transaction),
+			catch: (err) => {
+				return new OtherWalletError$1({
+					message: `Error while reverting transaction ${transaction.identifiers().at(0)}`,
+					cause: err
+				});
+			}
+		});
+	}
+};
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v1/V1Builder.js
+var V1Builder$1 = class V1Builder$1 {
+	#buildState;
+	constructor(buildState = {}) {
+		this.#buildState = buildState;
+	}
+	withDefaults() {
+		return this.withDefaultTransactionType().withSyncDefaults().withSerializationDefaults().withTransactingDefaults().withCoinsAndBalancesDefaults().withTransactionHistoryDefaults().withKeysDefaults().withCoinSelectionDefaults();
+	}
+	withTransactionType() {
+		return new V1Builder$1({
+			...this.#buildState,
+			transactingCapability: void 0
+		});
+	}
+	withDefaultTransactionType() {
+		return this.withTransactionType();
+	}
+	withSyncDefaults() {
+		return this.withSync(makeDefaultSyncService, makeDefaultSyncCapability);
+	}
+	withSync(syncService, syncCapability) {
+		return new V1Builder$1({
+			...this.#buildState,
+			syncService,
+			syncCapability
+		});
+	}
+	withSerializationDefaults() {
+		return this.withSerialization(makeDefaultV1SerializationCapability$1);
+	}
+	withSerialization(serializationCapability) {
+		return new V1Builder$1({
+			...this.#buildState,
+			serializationCapability
+		});
+	}
+	withTransactingDefaults() {
+		return this.withTransacting(makeDefaultTransactingCapability$1);
+	}
+	withTransacting(transactingCapability) {
+		return new V1Builder$1({
+			...this.#buildState,
+			transactingCapability
+		});
+	}
+	withCoinSelection(coinSelection) {
+		return new V1Builder$1({
+			...this.#buildState,
+			coinSelection
+		});
+	}
+	withCoinSelectionDefaults() {
+		return this.withCoinSelection(() => chooseCoin);
+	}
+	withCoinsAndBalancesDefaults() {
+		return this.withCoinsAndBalances(makeDefaultCoinsAndBalancesCapability$1);
+	}
+	withCoinsAndBalances(coinsAndBalancesCapability) {
+		return new V1Builder$1({
+			...this.#buildState,
+			coinsAndBalancesCapability
+		});
+	}
+	withTransactionHistoryDefaults() {
+		return this.withTransactionHistory(makeDefaultTransactionHistoryService$1);
+	}
+	withTransactionHistory(transactionHistoryService) {
+		return new V1Builder$1({
+			...this.#buildState,
+			transactionHistoryService
+		});
+	}
+	withKeysDefaults() {
+		return this.withKeys(makeDefaultKeysCapability$1);
+	}
+	withKeys(keysCapability) {
+		return new V1Builder$1({
+			...this.#buildState,
+			keysCapability
+		});
+	}
+	build(configuration) {
+		const v1Context = this.#buildContextFromBuildState(configuration);
+		return {
+			__polyTag__: V1Tag$1,
+			coinsAndBalances: v1Context.coinsAndBalancesCapability,
+			keys: v1Context.keysCapability,
+			serialization: v1Context.serializationCapability,
+			transactionHistory: v1Context.transactionHistoryService,
+			start(context) {
+				return require_const.gen(function* () {
+					return new RunningV1Variant$1(yield* require_const.Scope, context, v1Context);
+				});
+			},
+			migrateState(prevState) {
+				return require_const.succeed(prevState);
+			},
+			deserializeState: (serialized) => {
+				return v1Context.serializationCapability.deserialize(null, serialized);
+			}
+		};
+	}
+	#buildContextFromBuildState(configuration) {
+		if (!isBuildStateFull$1(this.#buildState)) throw new Error("Not all components are configured in V1 Builder");
+		const { syncCapability, syncService, transactingCapability, serializationCapability, coinSelection, coinsAndBalancesCapability, keysCapability, transactionHistoryService } = this.#buildState;
+		const getContext = () => context;
+		const context = {
+			serializationCapability: serializationCapability(configuration, getContext),
+			syncCapability: syncCapability(configuration, getContext),
+			syncService: syncService(configuration, getContext),
+			transactingCapability: transactingCapability(configuration, getContext),
+			coinsAndBalancesCapability: coinsAndBalancesCapability(configuration, getContext),
+			keysCapability: keysCapability(configuration, getContext),
+			coinSelection: coinSelection(configuration, getContext),
+			transactionHistoryService: transactionHistoryService(configuration, getContext)
+		};
+		return context;
+	}
+};
+const isBuildStateFull$1 = (buildState) => {
+	return [
+		"syncService",
+		"syncCapability",
+		"transactingCapability",
+		"coinSelection",
+		"serializationCapability",
+		"coinsAndBalancesCapability",
+		"keysCapability",
+		"transactionHistoryService"
+	].every((key) => typeof buildState[key] == "function");
+};
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/DustWallet.js
+var DustWalletState = class DustWalletState {
+	static mapState = (variant) => (state) => {
+		const { serialization, coinsAndBalances, keys } = variant;
+		const { transactionHistory } = variant;
+		return new DustWalletState(state, {
+			serialization,
+			coinsAndBalances,
+			keys
+		}, { transactionHistory });
+	};
+	protocolVersion;
+	state;
+	capabilities;
+	services;
+	get totalCoins() {
+		return this.capabilities.coinsAndBalances.getTotalCoins(this.state);
+	}
+	get availableCoins() {
+		return this.capabilities.coinsAndBalances.getAvailableCoins(this.state);
+	}
+	get pendingCoins() {
+		return this.capabilities.coinsAndBalances.getPendingCoins(this.state);
+	}
+	get publicKey() {
+		return this.capabilities.keys.getPublicKey(this.state);
+	}
+	get address() {
+		return this.capabilities.keys.getAddress(this.state);
+	}
+	get progress() {
+		return this.state.progress;
+	}
+	constructor(state, capabilities, services) {
+		this.protocolVersion = state.version;
+		this.state = state.state;
+		this.capabilities = capabilities;
+		this.services = services;
+	}
+	balance(time) {
+		return this.capabilities.coinsAndBalances.getWalletBalance(this.state, time);
+	}
+	estimateDustGeneration(nightUtxos, currentTime) {
+		return this.capabilities.coinsAndBalances.estimateDustGeneration(this.state, nightUtxos, currentTime);
+	}
+	serialize() {
+		return this.capabilities.serialization.serialize(this.state);
+	}
+};
+function DustWallet(configuration) {
+	return CustomDustWallet(configuration, new V1Builder$1().withDefaults());
+}
+function CustomDustWallet(configuration, builder) {
+	const buildArgs = [configuration];
+	const BaseWallet = require_watch.WalletBuilder.init().withVariant(require_const.MinSupportedVersion, builder).build(...buildArgs);
+	return class CustomDustWalletImplementation extends BaseWallet {
+		static startWithSeed(seed, dustParameters) {
+			const dustSecretKey = _midnight_ntwrk_ledger_v8.DustSecretKey.fromSeed(seed);
+			return CustomDustWalletImplementation.startFirst(CustomDustWalletImplementation, CoreWallet$1.initEmpty(dustParameters, dustSecretKey, CustomDustWalletImplementation.configuration.networkId));
+		}
+		static startWithSecretKey(secretKey, dustParameters) {
+			return CustomDustWalletImplementation.startFirst(CustomDustWalletImplementation, CoreWallet$1.initEmpty(dustParameters, secretKey, CustomDustWalletImplementation.configuration.networkId));
+		}
+		static restore(serializedState) {
+			const deserialized = CustomDustWalletImplementation.allVariantsRecord()[V1Tag$1].variant.deserializeState(serializedState).pipe(require_const.getOrThrow$1);
+			return CustomDustWalletImplementation.startFirst(CustomDustWalletImplementation, deserialized);
+		}
+		state;
+		constructor(runtime, scope) {
+			super(runtime, scope);
+			this.state = this.rawState.pipe(rxjs.map(DustWalletState.mapState(CustomDustWalletImplementation.allVariantsRecord()[V1Tag$1].variant)), rxjs.shareReplay({
+				refCount: true,
+				bufferSize: 1
+			}));
+		}
+		start(secretKey) {
+			return this.runtime.dispatch({ [V1Tag$1]: (v1) => v1.startSyncInBackground(secretKey) }).pipe(require_const.runPromise);
+		}
+		async createDustGenerationTransaction(currentTime, ttl, nightUtxos, nightVerifyingKey, dustReceiverAddress) {
+			return this.runtime.dispatch({ [V1Tag$1]: (v1) => v1.createDustGenerationTransaction(currentTime, ttl, nightUtxos, nightVerifyingKey, dustReceiverAddress) }).pipe(require_const.runPromise);
+		}
+		async splitNightUtxosForDustRegistration(currentTime, nightUtxos, isRegistration) {
+			return this.runtime.dispatch({ [V1Tag$1]: (v1) => v1.splitNightUtxosForDustRegistration(currentTime, nightUtxos, isRegistration) }).pipe(require_const.runPromise);
+		}
+		async attachDustRegistration(transaction, currentTime, nightVerifyingKey, dustReceiverAddress, feePayment) {
+			return this.runtime.dispatch({ [V1Tag$1]: (v1) => v1.attachDustRegistration(transaction, currentTime, nightVerifyingKey, dustReceiverAddress, feePayment) }).pipe(require_const.runPromise);
+		}
+		addDustGenerationSignature(transaction, signature) {
+			return this.runtime.dispatch({ [V1Tag$1]: (v1) => v1.addDustGenerationSignature(transaction, signature) }).pipe(require_const.runPromise);
+		}
+		addDustRegistrationSignature(transaction, signature) {
+			return this.runtime.dispatch({ [V1Tag$1]: (v1) => v1.addDustRegistrationSignature(transaction, signature) }).pipe(require_const.runPromise);
+		}
+		calculateFee(transactions) {
+			return this.runtime.dispatch({ [V1Tag$1]: (v1) => v1.calculateFee(transactions) }).pipe(require_const.runPromise);
+		}
+		estimateFee(secretKey, transactions, ttl, currentTime) {
+			const effectiveTtl = ttl ?? new Date(Date.now() + 3600 * 1e3);
+			return this.runtime.dispatch({ [V1Tag$1]: (v1) => v1.estimateFee(secretKey, transactions, effectiveTtl, currentTime) }).pipe(require_const.runPromise);
+		}
+		balanceTransactions(secretKey, transactions, ttl, currentTime) {
+			return this.runtime.dispatch({ [V1Tag$1]: (v1) => v1.balanceTransactions(secretKey, transactions, ttl, currentTime) }).pipe(require_const.runPromise);
+		}
+		revertTransaction(transaction) {
+			return this.runtime.dispatch({ [V1Tag$1]: (v1) => v1.revertTransaction(transaction) }).pipe(require_const.runPromise);
+		}
+		waitForSyncedState(allowedGap = 0n) {
+			return rxjs.firstValueFrom(this.state.pipe(rxjs.filter((state) => state.state.progress.isCompleteWithin(allowedGap))));
+		}
+		async waitForGeneratedDust(nightUtxos, requiredAmount, clock, opts) {
+			if (nightUtxos.length === 0) throw Error("At least one Night UTXO is required.");
+			if (requiredAmount <= 0n) return;
+			const timeoutMs = opts?.timeoutMs ?? 3e5;
+			await rxjs.firstValueFrom(rxjs.combineLatest([this.state, rxjs.timer(0, 1e3)]).pipe(rxjs.filter(([dustState]) => {
+				return dustState.estimateDustGeneration(nightUtxos, clock.now()).filter((u) => !u.utxo.registeredForDustGeneration).reduce((max, u) => u.dust.generatedNow > max ? u.dust.generatedNow : max, 0n) >= requiredAmount;
+			}), rxjs.timeout({ first: timeoutMs })));
+		}
+		serializeState() {
+			return rxjs.firstValueFrom(this.state).then((state) => state.serialize());
+		}
+		getAddress() {
+			return rxjs.firstValueFrom(this.state).then((state) => state.address);
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v1/WalletError.js
+const WalletError = {
+	other(err) {
+		let message;
+		if (err) if (typeof err == "object" && "message" in err) message = String(err.message);
+		else if (typeof err == "string") message = err;
+		else message = "";
+		else message = "";
+		return new OtherWalletError({
+			message: `Other wallet error: ${message}`,
+			cause: err
+		});
+	},
+	submission(err) {
+		return new SubmissionError({
+			message: `Transaction submission error: ${err && typeof err == "object" && "message" in err ? String(err.message) : ""}`,
+			cause: err
+		});
+	}
+};
+var OtherWalletError = class extends require_const.TaggedError("Wallet.Other") {};
+var SyncWalletError = class extends require_const.TaggedError("Wallet.Sync") {};
+var SubmissionError = class extends require_const.TaggedError("Wallet.SubmissionWalletError") {};
+var InsufficientFundsError = class extends require_const.TaggedError("Wallet.InsufficientFunds") {};
+var InvalidCoinHashesError = class extends require_const.TaggedError("Wallet.InvalidCoinHashes") {};
+var TransactionHistoryError = class extends require_const.TaggedError("Wallet.TransactionHistory") {};
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v1/RunningV1Variant.js
+const progress = (state) => {
+	const appliedIndex = state.progress?.appliedIndex ?? 0n;
+	const highestRelevantWalletIndex = state.progress?.highestRelevantWalletIndex ?? 0n;
+	const sourceGap = (state.progress?.highestIndex ?? 0n) - (state.progress?.highestRelevantIndex ?? 0n);
+	const applyGap = highestRelevantWalletIndex - appliedIndex;
+	return [require_watch.ProgressUpdate({
+		sourceGap,
+		applyGap
+	})];
+};
+const protocolVersionChange = (previous, current) => {
+	return previous.protocolVersion != current.protocolVersion ? [require_watch.VersionChange({ change: require_watch.Version({ version: require_const.ProtocolVersion(current.protocolVersion) }) })] : [];
+};
+const V1Tag = Symbol("V1");
+var RunningV1Variant = class {
+	__polyTag__ = V1Tag;
+	#scope;
+	#context;
+	#v1Context;
+	state;
+	constructor(scope, context, v1Context) {
+		this.#scope = scope;
+		this.#context = context;
+		this.#v1Context = v1Context;
+		this.state = require_watch.fromEffect(context.stateRef.get).pipe(require_watch.flatMap((initialState) => context.stateRef.changes.pipe(require_watch.mapAccum(initialState, (previous, current) => {
+			return [current, [previous, current]];
+		}))), require_watch.mapConcat(([previous, current]) => {
+			return [
+				require_watch.State({ state: current }),
+				...progress(current),
+				...protocolVersionChange(previous, current)
+			];
+		}));
+	}
+	startSyncInBackground(startAux) {
+		return this.startSync(startAux).pipe(require_watch.runScoped(require_watch.drain), require_const.forkScoped, require_const.provideService(require_const.Scope, this.#scope));
+	}
+	startSync(startAux) {
+		return require_const.pipe(require_watch.get(this.#context.stateRef), require_watch.fromEffect, require_watch.flatMap((state) => this.#v1Context.syncService.updates(state, startAux)), require_watch.mapEffect((update) => require_watch.modifyEffect(this.#context.stateRef, (state) => require_const.try_({
+			try: () => {
+				const [newState, changesResult] = this.#v1Context.syncCapability.applyUpdate(state, update);
+				return [changesResult, newState];
+			},
+			catch: (err) => new OtherWalletError({
+				message: "Error while applying sync update",
+				cause: err
+			})
+		})).pipe(require_const.flatMap(({ changes, protocolVersion }) => changes.length === 0 ? require_const._void : require_const.pipe(require_const.forEach(changes, (change) => require_const.pipe(this.#v1Context.transactionHistoryService.getTransactionDetails(change.source), require_const.flatMap((metadata) => this.#v1Context.transactionHistoryService.put(change, metadata, protocolVersion)), require_const.catchAllCause((cause) => require_watch.error("Error processing tx history metadata", cause))), {
+			discard: true,
+			concurrency: "unbounded"
+		}), require_const.forkScoped)), require_const.provideService(require_const.Scope, this.#scope))), require_watch.tapError((error$1) => require_watch.error(error$1)), require_watch.retry(require_const.pipe(require_watch.exponential(require_const.seconds(1), 2), require_watch.map$1((delay) => {
+			const maxDelay = require_const.minutes(2);
+			const jitter = require_const.millis(Math.floor(Math.random() * 1e3));
+			const delayWithJitter = require_const.toMillis(delay) + require_const.toMillis(jitter);
+			return require_const.millis(Math.min(delayWithJitter, require_const.toMillis(maxDelay)));
+		}))));
+	}
+	balanceTransaction(secretKeys, tx) {
+		return require_watch.modifyEffect(this.#context.stateRef, (state) => {
+			return require_const.pipe(this.#v1Context.transactingCapability.balanceTransaction(secretKeys, state, tx), require_watch.toEffect);
+		});
+	}
+	transferTransaction(secretKeys, outputs) {
+		return require_watch.modifyEffect(this.#context.stateRef, (state) => {
+			return require_const.pipe(this.#v1Context.transactingCapability.makeTransfer(secretKeys, state, outputs), require_watch.toEffect);
+		});
+	}
+	initSwap(secretKeys, desiredInputs, desiredOutputs) {
+		return require_watch.modifyEffect(this.#context.stateRef, (state) => {
+			return require_const.pipe(this.#v1Context.transactingCapability.initSwap(secretKeys, state, desiredInputs, desiredOutputs), require_watch.toEffect);
+		});
+	}
+	revertTransaction(transaction) {
+		return require_watch.updateEffect(this.#context.stateRef, (state) => {
+			return require_const.pipe(this.#v1Context.transactingCapability.revertTransaction(state, transaction), require_watch.toEffect);
+		});
+	}
+	serializeState(state) {
+		return this.#v1Context.serializationCapability.serialize(state);
+	}
+};
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v1/CoreWallet.js
+const PublicKeys = { fromSecretKeys: (secretKeys) => {
+	return {
+		coinPublicKey: secretKeys.coinPublicKey,
+		encryptionPublicKey: secretKeys.encryptionPublicKey
+	};
+} };
+const CoinHashesMap = {
+	empty: {},
+	pickAllCoins(state) {
+		return [...state.coins, ...state.pendingOutputs.values().map(([coin]) => coin)];
+	},
+	assertValid(map, state) {
+		const coins = CoinHashesMap.pickAllCoins(state);
+		const coinNonces = new Set(require_const.map$7(coins, (coin) => coin.nonce));
+		const definedNonces = new Set(Object.keys(map));
+		const missingNonces = coinNonces.difference(definedNonces);
+		return missingNonces.size === 0 ? require_const.void_$2 : require_const.left(missingNonces);
+	},
+	updateWithCoins(secretKeys, existing, coins) {
+		return require_const.fromIterableWith(coins, (coin) => [coin.nonce, existing[coin.nonce] ?? {
+			commitment: _midnight_ntwrk_ledger_v8.coinCommitment(coin, secretKeys.coinPublicKey),
+			nullifier: _midnight_ntwrk_ledger_v8.coinNullifier(coin, secretKeys.coinSecretKey)
+		}]);
+	},
+	updateWithNewCoins(secretKeys, existing, coins) {
+		const newMap = CoinHashesMap.updateWithCoins(secretKeys, CoinHashesMap.empty, coins);
+		return require_const.union$2(existing, newMap, (a) => a);
+	},
+	init(secretKeys, coins) {
+		return CoinHashesMap.updateWithCoins(secretKeys, {}, coins);
+	}
+};
+const CoreWallet = {
+	init(localState, secretKeys, networkId) {
+		return {
+			state: localState,
+			publicKeys: PublicKeys.fromSecretKeys(secretKeys),
+			networkId,
+			coinHashes: CoinHashesMap.init(secretKeys, CoinHashesMap.pickAllCoins(localState)),
+			progress: require_const.createSyncProgress(),
+			protocolVersion: require_const.MinSupportedVersion
+		};
+	},
+	empty(publicKeys, networkId) {
+		return {
+			state: new _midnight_ntwrk_ledger_v8.ZswapLocalState(),
+			publicKeys,
+			networkId,
+			coinHashes: CoinHashesMap.empty,
+			progress: require_const.createSyncProgress(),
+			protocolVersion: require_const.MinSupportedVersion
+		};
+	},
+	restore(localState, secretKeys, syncProgress, protocolVersion, networkId) {
+		return {
+			state: localState,
+			publicKeys: PublicKeys.fromSecretKeys(secretKeys),
+			networkId,
+			coinHashes: CoinHashesMap.init(secretKeys, CoinHashesMap.pickAllCoins(localState)),
+			progress: require_const.createSyncProgress(syncProgress),
+			protocolVersion: require_const.ProtocolVersion(protocolVersion)
+		};
+	},
+	restoreWithCoinHashes(publicKeys, localState, coinHashes, syncProgress, protocolVersion, networkId) {
+		return CoinHashesMap.assertValid(coinHashes, localState).pipe(require_const.mapBoth$3({
+			onLeft: (missingNonces) => new InvalidCoinHashesError({
+				message: "Missing coin hashes for coins present in the state",
+				missingNonces
+			}),
+			onRight: () => ({
+				state: localState,
+				publicKeys,
+				networkId,
+				coinHashes,
+				progress: require_const.createSyncProgress(syncProgress),
+				protocolVersion: require_const.ProtocolVersion(protocolVersion)
+			})
+		}));
+	},
+	initEmpty(keys, networkId) {
+		return this.empty(PublicKeys.fromSecretKeys(keys), networkId);
+	},
+	applyCollapsedUpdate(wallet, collapsed) {
+		const newState = wallet.state.applyCollapsedUpdate(collapsed);
+		return {
+			...wallet,
+			state: newState
+		};
+	},
+	apply(wallet, secretKeys, offer) {
+		const newState = wallet.state.apply(secretKeys, offer);
+		const newCoinHashes = CoinHashesMap.updateWithCoins(secretKeys, wallet.coinHashes, CoinHashesMap.pickAllCoins(newState));
+		return {
+			...wallet,
+			state: newState,
+			coinHashes: newCoinHashes
+		};
+	},
+	replayEventsWithChanges(wallet, secretKeys, events) {
+		const stateWithChanges = wallet.state.replayEventsWithChanges(secretKeys, events);
+		const newState = stateWithChanges.state;
+		const newCoinHashes = CoinHashesMap.updateWithCoins(secretKeys, wallet.coinHashes, CoinHashesMap.pickAllCoins(newState));
+		return [{
+			...wallet,
+			state: newState,
+			coinHashes: newCoinHashes
+		}, stateWithChanges.changes];
+	},
+	updateProgress(wallet, { appliedIndex, highestRelevantWalletIndex, highestIndex, highestRelevantIndex, isConnected }) {
+		const updatedProgress = require_const.createSyncProgress({
+			appliedIndex: appliedIndex ?? wallet.progress.appliedIndex,
+			highestRelevantWalletIndex: highestRelevantWalletIndex ?? wallet.progress.highestRelevantWalletIndex,
+			highestIndex: highestIndex ?? wallet.progress.highestIndex,
+			highestRelevantIndex: highestRelevantIndex ?? wallet.progress.highestRelevantIndex,
+			isConnected: isConnected ?? wallet.progress.isConnected
+		});
+		return {
+			...wallet,
+			progress: updatedProgress
+		};
+	},
+	addTransaction(wallet, _tx) {
+		return wallet;
+	},
+	revertTransaction(wallet, tx) {
+		const newState = wallet.state.revertTransaction(tx);
+		return {
+			...wallet,
+			state: newState
+		};
+	},
+	updateTxHistory(wallet, _newTxs) {
+		return wallet;
+	},
+	spendCoins(wallet, secretKeys, coins, segment) {
+		const [offers, newLocalState] = require_const.pipe(coins, require_const.reduce$3([[], wallet.state], ([accOffers, localState], coinToSpend) => {
+			const [nextState, newInput] = localState.spend(secretKeys, coinToSpend, segment);
+			const inputOffer = _midnight_ntwrk_ledger_v8.ZswapOffer.fromInput(newInput, coinToSpend.type, coinToSpend.value);
+			return [accOffers.concat([inputOffer]), nextState];
+		}));
+		return [offers, {
+			...wallet,
+			state: newLocalState
+		}];
+	},
+	watchCoins(wallet, secretKeys, coins) {
+		const newLocalState = coins.reduce((localState, coin) => localState.watchFor(wallet.publicKeys.coinPublicKey, coin), wallet.state);
+		const newCoinHashes = CoinHashesMap.updateWithNewCoins(secretKeys, wallet.coinHashes, coins);
+		return {
+			...wallet,
+			state: newLocalState,
+			coinHashes: newCoinHashes
+		};
+	}
+};
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v1/Serialization.js
+const StateSchema = require_const.declare((input) => input instanceof _midnight_ntwrk_ledger_v8.ZswapLocalState).annotations({ identifier: "ledger.ZswapLocalState" });
+const Uint8ArraySchema$1 = require_const.declare((input) => input instanceof Uint8Array).annotations({ identifier: "Uint8Array" });
+const StateFromUInt8Array = () => require_const.asSchema(require_const.transformOrFail(Uint8ArraySchema$1, StateSchema, {
+	encode: (state) => {
+		return require_const.try_({
+			try: () => {
+				return state.serialize();
+			},
+			catch: (err) => {
+				return new require_const.Unexpected(err, "Could not serialize local state");
+			}
+		});
+	},
+	decode: (bytes) => require_const.try_({
+		try: () => _midnight_ntwrk_ledger_v8.ZswapLocalState.deserialize(bytes),
+		catch: (err) => {
+			return new require_const.Unexpected(err, "Could not deserialize local state");
+		}
+	})
+}));
+const HexedState = () => require_const.pipe(require_const.Uint8ArrayFromHex, require_const.compose(StateFromUInt8Array()));
+const makeDefaultV1SerializationCapability = () => {
+	const SnapshotSchema = require_const.Struct({
+		publicKeys: require_const.Struct({
+			coinPublicKey: require_const.String$,
+			encryptionPublicKey: require_const.String$
+		}),
+		state: HexedState(),
+		protocolVersion: require_const.BigInt$,
+		offset: require_const.optional(require_const.BigInt$),
+		networkId: require_const.String$,
+		coinHashes: require_const.Record({
+			key: require_const.String$,
+			value: require_const.Struct({
+				nullifier: require_const.String$,
+				commitment: require_const.String$
+			})
+		})
+	});
+	return {
+		serialize: (wallet) => {
+			const buildSnapshot = (w) => ({
+				publicKeys: w.publicKeys,
+				state: w.state,
+				protocolVersion: w.protocolVersion,
+				networkId: w.networkId,
+				offset: w.progress?.appliedIndex,
+				coinHashes: w.coinHashes
+			});
+			return require_const.pipe(wallet, buildSnapshot, require_const.encodeSync(SnapshotSchema), JSON.stringify);
+		},
+		deserialize: (aux, serialized) => {
+			return require_const.pipe(serialized, require_const.decodeUnknownEither(require_const.parseJson(SnapshotSchema)), require_const.mapLeft((err) => WalletError.other(err)), require_const.flatMap$4((snapshot) => CoreWallet.restoreWithCoinHashes(snapshot.publicKeys, snapshot.state, snapshot.coinHashes, {
+				appliedIndex: snapshot.offset ?? 0n,
+				highestRelevantWalletIndex: 0n,
+				highestIndex: 0n,
+				highestRelevantIndex: 0n,
+				isConnected: false
+			}, snapshot.protocolVersion, snapshot.networkId)));
+		}
+	};
+};
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v1/Sync.js
+const Uint8ArraySchema = require_const.declare((input) => input instanceof Uint8Array).annotations({ identifier: "Uint8Array" });
+const WalletSyncUpdate = { create: (updates, secretKeys) => {
+	return {
+		updates,
+		secretKeys
+	};
+} };
+const LedgerEventSchema = require_const.declare((input) => input instanceof _midnight_ntwrk_ledger_v8.Event).annotations({ identifier: "ledger.Event" });
+const LedgerEventFromUint8Array = require_const.transformOrFail(Uint8ArraySchema, LedgerEventSchema, {
+	encode: (event) => require_const.try_({
+		try: () => event.serialize(),
+		catch: (error) => new require_const.Unexpected(error, "Could not serialize ledger event")
+	}),
+	decode: (bytes) => require_const.try_({
+		try: () => _midnight_ntwrk_ledger_v8.Event.deserialize(bytes),
+		catch: (error) => new require_const.Unexpected(error, "Could not deserialize ledger event")
+	})
+});
+const HexedLedgerEvent = require_const.pipe(require_const.Uint8ArrayFromHex, require_const.compose(LedgerEventFromUint8Array));
+const EventsSyncUpdatePayload = require_const.Struct({
+	id: require_const.Number$,
+	raw: require_const.String$,
+	protocolVersion: require_const.Number$,
+	maxId: require_const.Number$
+});
+const EventsSyncUpdate = require_const.TaggedStruct("EventsSyncUpdate", {
+	id: require_const.Number$,
+	protocolVersion: require_const.Number$,
+	maxId: require_const.Number$,
+	event: LedgerEventSchema
+});
+const EventsSyncUpdateFromPayload = require_const.transformOrFail(EventsSyncUpdatePayload, EventsSyncUpdate, {
+	decode: (input) => require_const.pipe(require_const.decodeUnknownEither(HexedLedgerEvent)(input.raw), require_const.map$9((event) => ({
+		_tag: "EventsSyncUpdate",
+		id: input.id,
+		protocolVersion: input.protocolVersion,
+		maxId: input.maxId,
+		event
+	})), require_const.mapLeft((error) => new require_const.Unexpected(error, "Failed to decode ledger event payload")), require_watch.toEffect),
+	encode: (output) => require_const.pipe(require_const.encodeEither(HexedLedgerEvent)(output.event), require_const.map$9((raw) => ({
+		id: output.id,
+		raw,
+		protocolVersion: output.protocolVersion,
+		maxId: output.maxId
+	})), require_const.mapLeft((error) => new require_const.Unexpected(error, "Failed to encode ledger event payload")), require_watch.toEffect)
+});
+const makeEventsSyncService = (config) => {
+	return { updates: (state, secretKeys) => {
+		const { indexerClientConnection } = config;
+		const webSocketUrlResult = require_watch.createWebSocketUrl(indexerClientConnection.indexerHttpUrl, indexerClientConnection.indexerWsUrl);
+		if (require_const.isLeft(webSocketUrlResult)) return require_watch.fail(new SyncWalletError(/* @__PURE__ */ new Error(`Could not derive WebSocket URL from indexer HTTP URL: ${webSocketUrlResult.left.message}`)));
+		const indexerWsUrlResult = require_watch.make(webSocketUrlResult.right);
+		if (require_const.isLeft(indexerWsUrlResult)) return require_watch.fail(new SyncWalletError(/* @__PURE__ */ new Error(`Invalid indexer WS URL: ${indexerWsUrlResult.left.message}`)));
+		const indexerWsUrl = indexerWsUrlResult.right;
+		const resumeFrom = (state.progress?.appliedIndex ?? 0n) - 1n;
+		const batchSize = config.batchUpdates?.size ?? 10;
+		const batchTimeout = require_const.millis(config.batchUpdates?.timeout ?? 1);
+		const batchSpacing = config.batchUpdates?.spacing ?? 4;
+		const bufferSize = config.indexerClientConnection.bufferSize ?? 1e4;
+		const resumeThreshold = config.indexerClientConnection.resumeThreshold ?? 100;
+		const eventsStream = require_const.pipe(require_watch.ZswapEvents.runWithBackpressure({
+			bufferSize,
+			resumeThreshold,
+			from: resumeFrom,
+			variables: (cursor) => ({ id: cursor < 0n ? null : Number(cursor) }),
+			key: (r) => BigInt(r.zswapLedgerEvents.id)
+		}), require_watch.provideLayer(require_watch.layer({
+			url: indexerWsUrl,
+			keepAlive: config.indexerClientConnection.keepAlive
+		})), require_watch.mapError((error) => new SyncWalletError(error)), require_watch.mapEffect((subscription) => require_const.pipe(subscription.zswapLedgerEvents, require_const.decodeUnknownEither(EventsSyncUpdateFromPayload), require_const.mapLeft((err) => new SyncWalletError(err)), require_watch.toEffect)), require_watch.groupedWithin(batchSize, batchTimeout), require_watch.map(require_const.toArray), require_watch.map((data) => WalletSyncUpdate.create(data, secretKeys)));
+		return batchSpacing > 0 ? require_watch.schedule(eventsStream, require_watch.spaced(require_const.millis(batchSpacing))) : eventsStream;
+	} };
+};
+const makeEventsSyncCapability = () => {
+	return { applyUpdate: (state, wrappedUpdate) => {
+		if (wrappedUpdate.updates.length === 0) return [state, {
+			changes: [],
+			protocolVersion: Number(state.protocolVersion)
+		}];
+		const appliedIndex = state.progress?.appliedIndex ?? 0n;
+		const freshUpdates = wrappedUpdate.updates.filter((u) => BigInt(u.id) > appliedIndex);
+		const lastUpdate = wrappedUpdate.updates.at(-1);
+		const highestRelevantWalletIndex = BigInt(lastUpdate.maxId);
+		const [newState, newChanges] = freshUpdates.length === 0 ? [state, []] : CoreWallet.replayEventsWithChanges(state, wrappedUpdate.secretKeys, freshUpdates.map((u) => u.event));
+		return [CoreWallet.updateProgress(newState, {
+			highestRelevantWalletIndex,
+			appliedIndex: freshUpdates.length === 0 ? appliedIndex : BigInt(freshUpdates.at(-1).id),
+			isConnected: true
+		}), {
+			changes: newChanges,
+			protocolVersion: lastUpdate.protocolVersion
+		}];
+	} };
+};
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v1/TransactionImbalances.js
+const ShieldedCostModel = {
+	inputFeeOverhead: 0n,
+	outputFeeOverhead: 0n
+};
+const TransactionImbalances = new class {
+	empty = () => {
+		return {
+			guaranteed: require_watch.Imbalances.empty(),
+			fallible: /* @__PURE__ */ new Map()
+		};
+	};
+	areBalanced = (imbalances) => {
+		const areGuaranteedAllZeroes = imbalances.guaranteed.entries().every(([, value]) => value === 0n);
+		const areFallibleAllZeroes = Array.from(imbalances.fallible.values()).every((segmentImbalances) => segmentImbalances.entries().every(([, value]) => value === 0n));
+		return areGuaranteedAllZeroes && areFallibleAllZeroes;
+	};
+}();
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v1/TransactionOps.js
+const TransactionOps = new class {
+	default = {
+		getImbalances(tx) {
+			return TransactionOps.shared.getImbalances(tx);
+		},
+		id(tx) {
+			return tx.identifiers().at(0);
+		}
+	};
+	proofErased = {
+		getImbalances(tx) {
+			return TransactionOps.shared.getImbalances(tx);
+		},
+		id(tx) {
+			return tx.identifiers().at(0);
+		}
+	};
+	unproven = {
+		getImbalances(tx) {
+			return TransactionOps.shared.getImbalances(tx);
+		},
+		id(tx) {
+			return tx.identifiers().at(0);
+		}
+	};
+	shared = {
+		getImbalances(tx) {
+			return {
+				guaranteed: TransactionOps.shared.getGuaranteedImbalances(tx),
+				fallible: TransactionOps.shared.getFallibleImbalances(tx)
+			};
+		},
+		getGuaranteedImbalances: (tx) => {
+			const rawGuaranteedImbalances = tx.imbalances(0).entries().filter(([token]) => token.tag === "shielded").map(([token, value]) => {
+				return [token.raw, value];
+			});
+			return require_watch.Imbalances.fromEntries(rawGuaranteedImbalances);
+		},
+		getFallibleImbalances: (tx) => {
+			const fallibleImbalances = Array.from(tx.fallibleOffer?.keys() ?? []).flatMap((segment) => {
+				const rawImbalances = tx.imbalances(segment).entries().filter(([token]) => token.tag === "shielded").map(([token, value]) => {
+					return [token.raw, value];
+				});
+				return [[segment, require_watch.Imbalances.fromEntries(rawImbalances)]];
+			});
+			return new Map(fallibleImbalances);
+		}
+	};
+}();
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v1/Transacting.js
+const makeDefaultTransactingCapability = (config, getContext) => {
+	return new TransactingCapabilityImplementation(config.networkId, () => getContext().coinSelection, () => getContext().coinsAndBalancesCapability, () => getContext().keysCapability, TransactionOps.default);
+};
+var TransactingCapabilityImplementation = class {
+	networkId;
+	getCoinSelection;
+	txOps;
+	getCoins;
+	getKeys;
+	constructor(networkId, getCoinSelection, getCoins, getKeys, txOps) {
+		this.getCoins = getCoins;
+		this.networkId = networkId;
+		this.getCoinSelection = getCoinSelection;
+		this.getKeys = getKeys;
+		this.txOps = txOps;
+	}
+	balanceTransaction(secretKeys, state, tx) {
+		return require_const.gen$1(this, function* () {
+			const coinSelection = this.getCoinSelection();
+			const initialImbalances = this.txOps.getImbalances(tx);
+			if (TransactionImbalances.areBalanced(initialImbalances)) return [void 0, state];
+			const { newState: afterFallible, fallibleOffers } = yield* this.balanceFallibleSection(secretKeys, state, initialImbalances, coinSelection);
+			const { newState: afterGuaranteed, offer: guaranteed } = yield* this.#balanceGuaranteedSection(secretKeys, afterFallible, initialImbalances, coinSelection, require_watch.Imbalances.empty());
+			return [Array.from(fallibleOffers.entries()).reduce((tx, [segment, offer]) => tx.addZswapOffer({
+				tag: "specific",
+				value: segment
+			}, offer), _midnight_ntwrk_ledger_v8.Transaction.fromParts(this.networkId, guaranteed)), afterGuaranteed];
+		});
+	}
+	makeTransfer(secretKeys, state, transfers) {
+		return require_const.gen$1(this, function* () {
+			const positiveTransfers = yield* require_const.pipe(transfers, require_const.filter$2((t) => t.amount > 0n), require_const.match$2({
+				onEmpty: () => require_const.left(new OtherWalletError({ message: "The amount needs to be positive" })),
+				onNonEmpty: (nonEmpty) => require_const.right(nonEmpty)
+			}));
+			const networkId = this.networkId;
+			const { initialOffersAndCoins, selfCoins } = yield* this.#processDesiredOutputs(state, positiveTransfers);
+			const offerToBalance = require_const.pipe(initialOffersAndCoins, require_const.map$6((o) => o.outputOffer), require_watch.fold((a, b) => a.merge(b)));
+			const unprovenTxToBalance = _midnight_ntwrk_ledger_v8.Transaction.fromParts(networkId, offerToBalance);
+			const imbalances = TransactionOps.unproven.getImbalances(unprovenTxToBalance);
+			const { offer, newState } = yield* this.#balanceGuaranteedSection(secretKeys, state, imbalances, this.getCoinSelection(), require_watch.Imbalances.empty());
+			const finalState = CoreWallet.watchCoins(newState, secretKeys, selfCoins);
+			return [unprovenTxToBalance.merge(_midnight_ntwrk_ledger_v8.Transaction.fromParts(networkId, offer)), finalState];
+		});
+	}
+	initSwap(secretKeys, state, desiredInputs, desiredOutputs) {
+		return require_const.gen$1(this, function* () {
+			if (!desiredOutputs.every((output) => output.amount > 0n)) return yield* require_const.left(new OtherWalletError({ message: "The amount needs to be positive" }));
+			if (!Object.entries(desiredInputs).every(([, amount]) => amount > 0n)) return yield* require_const.left(new OtherWalletError({ message: "The input amounts need to be positive" }));
+			const outputsParseResult = yield* this.#processDesiredOutputsPossiblyEmpty(state, desiredOutputs);
+			const inputsParseResult = require_watch.Imbalances.fromEntries(require_const.toEntries(desiredInputs));
+			const networkId = this.networkId;
+			const { offer, newState } = yield* this.#balanceGuaranteedSection(secretKeys, state, TransactionImbalances.empty(), this.getCoinSelection(), inputsParseResult);
+			const finalState = CoreWallet.watchCoins(newState, secretKeys, outputsParseResult.selfCoins);
+			const balancingTx = _midnight_ntwrk_ledger_v8.Transaction.fromParts(networkId, offer);
+			return [outputsParseResult.unprovenTxToBalance ? outputsParseResult.unprovenTxToBalance.merge(balancingTx) : balancingTx, finalState];
+		});
+	}
+	revertTransaction(state, transaction) {
+		return require_const.try_$1({
+			try: () => {
+				return CoreWallet.revertTransaction(state, transaction);
+			},
+			catch: (err) => {
+				return new OtherWalletError({
+					message: `Error while reverting transaction ${transaction.identifiers().at(0)}`,
+					cause: err
+				});
+			}
+		});
+	}
+	#prepareOffer(secretKeys, state, recipe, segment) {
+		const [inputOffers, stateAfterSpends] = CoreWallet.spendCoins(state, secretKeys, recipe.inputs, segment);
+		const stateAfterWatches = CoreWallet.watchCoins(stateAfterSpends, secretKeys, recipe.outputs);
+		const outputOffers = recipe.outputs.map((coin) => {
+			const output = _midnight_ntwrk_ledger_v8.ZswapOutput.new(coin, segment, this.getKeys().getCoinPublicKey(state).toHexString(), this.getKeys().getEncryptionPublicKey(state).toHexString());
+			return _midnight_ntwrk_ledger_v8.ZswapOffer.fromOutput(output, coin.type, coin.value);
+		});
+		return require_const.pipe(require_const.appendAll$1(inputOffers, outputOffers), require_const.match$2({
+			onEmpty: () => require_const.none(),
+			onNonEmpty: (nonEmpty) => require_const.pipe(nonEmpty, require_watch.fold((a, b) => a.merge(b)), require_const.some)
+		}), require_const.map$8((offer) => ({
+			offer,
+			newState: stateAfterWatches
+		})));
+	}
+	balanceFallibleSection(secretKeys, state, imbalances, coinSelection) {
+		return Array.from(imbalances.fallible.entries()).reduce((acc, [segment, segmentImbalances]) => require_const.flatMap$4(acc, ({ fallibleOffers, newState }) => require_const.pipe(require_const.try_$1({
+			try: () => {
+				const fallibleBalanceRecipe = require_watch.getBalanceRecipe({
+					coins: this.getCoins().getAvailableCoins(newState).map((c) => c.coin),
+					initialImbalances: segmentImbalances,
+					transactionCostModel: ShieldedCostModel,
+					feeTokenType: "",
+					coinSelection,
+					createOutput: (coin) => _midnight_ntwrk_ledger_v8.createShieldedCoinInfo(coin.type, coin.value),
+					isCoinEqual: (a, b) => a.type === b.type && a.value === b.value
+				});
+				return this.#prepareOffer(secretKeys, newState, fallibleBalanceRecipe, segment);
+			},
+			catch: (err) => {
+				if (err instanceof require_watch.InsufficientFundsError) return new InsufficientFundsError({
+					message: `Insufficient funds for fallible segment ${segment}`,
+					tokenType: err.tokenType,
+					amount: segmentImbalances.get(err.tokenType) ?? 0n
+				});
+				return new OtherWalletError({
+					message: `Balancing fallible segment ${segment} failed`,
+					cause: err
+				});
+			}
+		}), require_const.map$9(require_const.match$3({
+			onNone: () => ({
+				fallibleOffers,
+				newState
+			}),
+			onSome: (res) => ({
+				fallibleOffers: new Map([...fallibleOffers, [segment, res.offer]]),
+				newState: res.newState
+			})
+		})))), require_const.right({
+			fallibleOffers: /* @__PURE__ */ new Map(),
+			newState: state
+		}));
+	}
+	#balanceGuaranteedSection(secretKeys, state, imbalances, coinSelection, targetImbalances) {
+		return require_const.gen$1(this, function* () {
+			const balanceRecipe = yield* require_const.try_$1({
+				try: () => require_watch.getBalanceRecipe({
+					coins: this.getCoins().getAvailableCoins(state).map((c) => c.coin),
+					initialImbalances: imbalances.guaranteed,
+					transactionCostModel: ShieldedCostModel,
+					feeTokenType: "",
+					coinSelection,
+					createOutput: (coin) => _midnight_ntwrk_ledger_v8.createShieldedCoinInfo(coin.type, coin.value),
+					isCoinEqual: (a, b) => a.nonce === b.nonce,
+					targetImbalances
+				}),
+				catch: (err) => {
+					if (err instanceof require_watch.InsufficientFundsError) return new InsufficientFundsError({
+						message: "Insufficient funds",
+						tokenType: err.tokenType,
+						amount: imbalances.guaranteed.get(err.tokenType) ?? 0n
+					});
+					else return new OtherWalletError({
+						message: "Balancing guaranteed section failed",
+						cause: err
+					});
+				}
+			});
+			return require_const.pipe(this.#prepareOffer(secretKeys, state, balanceRecipe, 0), require_const.match$3({
+				onNone: () => ({
+					offer: void 0,
+					newState: state
+				}),
+				onSome: (result) => result
+			}));
+		});
+	}
+	#processDesiredOutputs(state, transfers) {
+		return require_const.try_$1({
+			try: () => {
+				const initialOffersAndCoins = require_const.pipe(transfers, require_const.map$6((transfer) => {
+					const { receiverAddress, type, amount } = transfer;
+					const coin = _midnight_ntwrk_ledger_v8.createShieldedCoinInfo(type, amount);
+					const output = _midnight_ntwrk_ledger_v8.ZswapOutput.new(coin, 0, receiverAddress.coinPublicKey.toHexString(), receiverAddress.encryptionPublicKey.toHexString());
+					return {
+						coin,
+						outputOffer: _midnight_ntwrk_ledger_v8.ZswapOffer.fromOutput(output, type, amount),
+						isForSelf: receiverAddress.coinPublicKey.equals(this.getKeys().getCoinPublicKey(state))
+					};
+				}));
+				return {
+					initialOffersAndCoins,
+					selfCoins: require_const.flatMap$3(initialOffersAndCoins, ({ coin, isForSelf }) => {
+						if (isForSelf) return [coin];
+						else return [];
+					})
+				};
+			},
+			catch: (err) => {
+				return new OtherWalletError({
+					message: "Failed to process desired outputs",
+					cause: err
+				});
+			}
+		});
+	}
+	#processDesiredOutputsPossiblyEmpty(state, desiredOutputs) {
+		return require_const.pipe(desiredOutputs, require_const.match$2({
+			onEmpty: () => {
+				return require_const.right({
+					imbalances: TransactionImbalances.empty(),
+					selfCoins: [],
+					unprovenTxToBalance: null
+				});
+			},
+			onNonEmpty: (desiredOutputs) => {
+				return require_const.pipe(this.#processDesiredOutputs(state, desiredOutputs), require_const.map$9(({ initialOffersAndCoins, selfCoins }) => {
+					const networkId = this.networkId;
+					const offerToBalance = require_const.pipe(initialOffersAndCoins, require_const.map$6((o) => o.outputOffer), require_watch.fold((a, b) => a.merge(b)));
+					const unprovenTxToBalance = _midnight_ntwrk_ledger_v8.Transaction.fromParts(networkId, offerToBalance);
+					return {
+						imbalances: TransactionOps.unproven.getImbalances(unprovenTxToBalance),
+						selfCoins,
+						unprovenTxToBalance
+					};
+				}));
+			}
+		}));
+	}
+};
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v1/CoinsAndBalances.js
+const calculateBalances = (coins) => coins.reduce((acc, { coin }) => ({
+	...acc,
+	[coin.type]: acc[coin.type] === void 0 ? coin.value : acc[coin.type] + coin.value
+}), {});
+const makeDefaultCoinsAndBalancesCapability = () => {
+	const getAvailableBalances = (state) => {
+		return calculateBalances(getAvailableCoins(state));
+	};
+	const getPendingBalances = (state) => {
+		return calculateBalances(getPendingCoins(state));
+	};
+	const getTotalBalances = (state) => {
+		return require_const.pipe([getAvailableBalances(state), getPendingBalances(state)], require_watch.mergeWithAccumulator(0n, (a, b) => a + b));
+	};
+	const getAvailableCoins = (state) => {
+		const pendingSpends = new Set([...state.state.pendingSpends.values()].map(([coin]) => coin.nonce));
+		return require_const.pipe([...state.state.coins], require_const.filter$2((coin) => !pendingSpends.has(coin.nonce)), require_const.map$6((coin) => {
+			return {
+				coin,
+				commitment: state.coinHashes[coin.nonce].commitment,
+				nullifier: state.coinHashes[coin.nonce].nullifier
+			};
+		}));
+	};
+	const getPendingCoins = (state) => require_const.pipe([...state.state.pendingOutputs.values()], require_const.map$6(([coin, ttl]) => ({
+		coin,
+		ttl,
+		commitment: state.coinHashes[coin.nonce].commitment,
+		nullifier: state.coinHashes[coin.nonce].nullifier
+	})));
+	const getTotalCoins = (state) => [...getAvailableCoins(state), ...getPendingCoins(state)];
+	return {
+		getAvailableBalances,
+		getPendingBalances,
+		getTotalBalances,
+		getAvailableCoins,
+		getPendingCoins,
+		getTotalCoins
+	};
+};
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v1/Keys.js
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+const makeDefaultKeysCapability = () => {
+	return {
+		getCoinPublicKey: (state) => {
+			return new require_dist.ShieldedCoinPublicKey(require__polyfill_buffer_patch.import_buffer.Buffer.from(state.publicKeys.coinPublicKey, "hex"));
+		},
+		getEncryptionPublicKey: (state) => {
+			return new require_dist.ShieldedEncryptionPublicKey(require__polyfill_buffer_patch.import_buffer.Buffer.from(state.publicKeys.encryptionPublicKey, "hex"));
+		},
+		getAddress: (state) => {
+			return new require_dist.ShieldedAddress(new require_dist.ShieldedCoinPublicKey(require__polyfill_buffer_patch.import_buffer.Buffer.from(state.publicKeys.coinPublicKey, "hex")), new require_dist.ShieldedEncryptionPublicKey(require__polyfill_buffer_patch.import_buffer.Buffer.from(state.publicKeys.encryptionPublicKey, "hex")));
+		}
+	};
+};
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v1/TransactionHistory.js
+const QualifiedShieldedCoinInfoSchema = require_const.Struct({
+	type: require_const.String$,
+	nonce: require_const.String$,
+	value: require_const.BigInt$,
+	mtIndex: require_const.BigInt$
+});
+const ShieldedSectionSchema = require_const.Struct({
+	receivedCoins: require_const.Array$(QualifiedShieldedCoinInfoSchema),
+	spentCoins: require_const.Array$(QualifiedShieldedCoinInfoSchema)
+});
+require_const.Struct({
+	hash: require_const.TransactionHashSchema,
+	protocolVersion: require_const.Number$,
+	status: require_const.TransactionHistoryStatusSchema,
+	shielded: ShieldedSectionSchema
+});
+const coinEquals = require_const.equivalence(QualifiedShieldedCoinInfoSchema);
+const mergeShieldedSections = (existing, incoming) => ({
+	receivedCoins: require_const.unionWith$1(existing.receivedCoins, incoming.receivedCoins, coinEquals),
+	spentCoins: require_const.unionWith$1(existing.spentCoins, incoming.spentCoins, coinEquals)
+});
+const convertUpdateToStorageEntry = (changes, metadata, protocolVersion) => ({
+	hash: changes.source,
+	protocolVersion,
+	status: metadata.status,
+	shielded: {
+		receivedCoins: changes.receivedCoins.map(({ mt_index, ...rest }) => ({
+			...rest,
+			mtIndex: mt_index
+		})),
+		spentCoins: changes.spentCoins.map(({ mt_index, ...rest }) => ({
+			...rest,
+			mtIndex: mt_index
+		}))
+	}
+});
+const upsertShieldedEntry = (txHistoryStorage, entry) => require_const.tryPromise({
+	try: () => txHistoryStorage.upsert(entry),
+	catch: (e) => new TransactionHistoryError({
+		message: `Failed to upsert history entry for ${entry.hash}`,
+		cause: e
+	})
+});
+const makeDefaultTransactionHistoryService = (config, _getContext) => {
+	const txHistoryStorage = config.txHistoryStorage;
+	const queryClientLayer = require_watch.layer$1({ url: config.indexerClientConnection.indexerHttpUrl });
+	return {
+		put: (changes, metadata, protocolVersion) => {
+			return upsertShieldedEntry(txHistoryStorage, convertUpdateToStorageEntry(changes, metadata, protocolVersion));
+		},
+		getTransactionDetails: (hash) => require_const.gen(function* () {
+			const tx = (yield* (yield* require_watch.TransactionHistoryDetail)({ transactionHash: hash })).transactions[0];
+			const rawStatus = tx.__typename === "RegularTransaction" ? tx.transactionResult.status : void 0;
+			const status = rawStatus === "FAILURE" || rawStatus === "PARTIAL_SUCCESS" ? rawStatus : "SUCCESS";
+			return {
+				hash: tx.hash,
+				timestamp: tx.block.timestamp,
+				status
+			};
+		}).pipe(require_const.provide(queryClientLayer), require_const.scoped$1, require_const.retry(require_watch.exponential(require_const.seconds(1)).pipe(require_watch.compose(require_watch.recurs(3)))), require_const.mapError$1((cause) => new TransactionHistoryError({
+			message: `Failed to fetch transaction metadata for ${hash}`,
+			cause
+		})))
+	};
+};
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v1/V1Builder.js
+var V1Builder = class V1Builder {
+	#buildState;
+	constructor(buildState = {}) {
+		this.#buildState = buildState;
+	}
+	withDefaults() {
+		return this.withDefaultTransactionType().withSyncDefaults().withSerializationDefaults().withTransactingDefaults().withCoinsAndBalancesDefaults().withTransactionHistoryDefaults().withKeysDefaults().withCoinSelectionDefaults();
+	}
+	withTransactionType() {
+		return new V1Builder({
+			...this.#buildState,
+			transactingCapability: void 0,
+			transactionHistoryService: void 0
+		});
+	}
+	withDefaultTransactionType() {
+		return this.withTransactionType();
+	}
+	withSyncDefaults() {
+		return this.withSync(makeEventsSyncService, makeEventsSyncCapability);
+	}
+	withSync(syncService, syncCapability) {
+		return new V1Builder({
+			...this.#buildState,
+			syncService,
+			syncCapability
+		});
+	}
+	withSerializationDefaults() {
+		return this.withSerialization(makeDefaultV1SerializationCapability);
+	}
+	withSerialization(serializationCapability) {
+		return new V1Builder({
+			...this.#buildState,
+			serializationCapability
+		});
+	}
+	withTransactingDefaults() {
+		return this.withTransacting(makeDefaultTransactingCapability);
+	}
+	withTransacting(transactingCapability) {
+		return new V1Builder({
+			...this.#buildState,
+			transactingCapability
+		});
+	}
+	withCoinSelection(coinSelection) {
+		return new V1Builder({
+			...this.#buildState,
+			coinSelection
+		});
+	}
+	withCoinSelectionDefaults() {
+		return this.withCoinSelection(() => require_watch.chooseCoin);
+	}
+	withCoinsAndBalancesDefaults() {
+		return this.withCoinsAndBalances(makeDefaultCoinsAndBalancesCapability);
+	}
+	withCoinsAndBalances(coinsAndBalancesCapability) {
+		return new V1Builder({
+			...this.#buildState,
+			coinsAndBalancesCapability
+		});
+	}
+	withTransactionHistoryDefaults() {
+		return this.withTransactionHistory(makeDefaultTransactionHistoryService);
+	}
+	withTransactionHistory(transactionHistoryService) {
+		return new V1Builder({
+			...this.#buildState,
+			transactionHistoryService
+		});
+	}
+	withKeysDefaults() {
+		return this.withKeys(makeDefaultKeysCapability);
+	}
+	withKeys(keysCapability) {
+		return new V1Builder({
+			...this.#buildState,
+			keysCapability
+		});
+	}
+	build(configuration) {
+		const v1Context = this.#buildContextFromBuildState(configuration);
+		const { networkId } = configuration;
+		return {
+			__polyTag__: V1Tag,
+			coinsAndBalances: v1Context.coinsAndBalancesCapability,
+			keys: v1Context.keysCapability,
+			serialization: v1Context.serializationCapability,
+			transactionHistory: v1Context.transactionHistoryService,
+			start(context) {
+				return require_const.gen(function* () {
+					return new RunningV1Variant(yield* require_const.Scope, context, v1Context);
+				});
+			},
+			migrateState(_previousState) {
+				const seed = require_const.fromString("0000000000000000000000000000000000000000000000000000000000000001");
+				return require_const.succeed(CoreWallet.empty(PublicKeys.fromSecretKeys(_midnight_ntwrk_ledger_v8.ZswapSecretKeys.fromSeed(seed)), networkId));
+			},
+			deserializeState: (serialized) => {
+				return v1Context.serializationCapability.deserialize(null, serialized);
+			}
+		};
+	}
+	#buildContextFromBuildState(configuration) {
+		if (!isBuildStateFull(this.#buildState)) throw new Error("Not all components are configured in V1 Builder");
+		const { syncCapability, syncService, transactingCapability, serializationCapability, coinSelection, coinsAndBalancesCapability, keysCapability, transactionHistoryService } = this.#buildState;
+		const getContext = () => context;
+		const context = {
+			serializationCapability: serializationCapability(configuration, getContext),
+			syncCapability: syncCapability(configuration, getContext),
+			syncService: syncService(configuration, getContext),
+			transactingCapability: transactingCapability(configuration, getContext),
+			coinsAndBalancesCapability: coinsAndBalancesCapability(configuration, getContext),
+			keysCapability: keysCapability(configuration, getContext),
+			coinSelection: coinSelection(configuration, getContext),
+			transactionHistoryService: transactionHistoryService(configuration, getContext)
+		};
+		return context;
+	}
+};
+const isBuildStateFull = (buildState) => {
+	return [
+		"syncService",
+		"syncCapability",
+		"transactingCapability",
+		"coinSelection",
+		"serializationCapability",
+		"coinsAndBalancesCapability",
+		"keysCapability",
+		"transactionHistoryService"
+	].every((key) => typeof buildState[key] == "function");
+};
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-shielded/dist/ShieldedWallet.js
+var ShieldedWalletState = class ShieldedWalletState {
+	static mapState = (variant) => (state) => {
+		const { serialization, coinsAndBalances, keys } = variant;
+		const { transactionHistory } = variant;
+		return new ShieldedWalletState(state, {
+			serialization,
+			coinsAndBalances,
+			keys
+		}, { transactionHistory });
+	};
+	protocolVersion;
+	state;
+	capabilities;
+	services;
+	get balances() {
+		return this.capabilities.coinsAndBalances.getAvailableBalances(this.state);
+	}
+	get totalCoins() {
+		return this.capabilities.coinsAndBalances.getTotalCoins(this.state);
+	}
+	get availableCoins() {
+		return this.capabilities.coinsAndBalances.getAvailableCoins(this.state);
+	}
+	get pendingCoins() {
+		return this.capabilities.coinsAndBalances.getPendingCoins(this.state);
+	}
+	get coinPublicKey() {
+		return this.capabilities.keys.getCoinPublicKey(this.state);
+	}
+	get encryptionPublicKey() {
+		return this.capabilities.keys.getEncryptionPublicKey(this.state);
+	}
+	get address() {
+		return this.capabilities.keys.getAddress(this.state);
+	}
+	get progress() {
+		return this.state.progress;
+	}
+	constructor(state, capabilities, services) {
+		this.protocolVersion = state.version;
+		this.state = state.state;
+		this.capabilities = capabilities;
+		this.services = services;
+	}
+	serialize() {
+		return this.capabilities.serialization.serialize(this.state);
+	}
+};
+function ShieldedWallet(configuration) {
+	return CustomShieldedWallet(configuration, new V1Builder().withDefaults());
+}
+function CustomShieldedWallet(configuration, builder) {
+	const buildArgs = [configuration];
+	const BaseWallet = require_watch.WalletBuilder.init().withVariant(require_const.MinSupportedVersion, builder).build(...buildArgs);
+	return class CustomShieldedWalletImplementation extends BaseWallet {
+		static startWithSecretKeys(secretKeys) {
+			return CustomShieldedWalletImplementation.startFirst(CustomShieldedWalletImplementation, CoreWallet.initEmpty(secretKeys, CustomShieldedWalletImplementation.configuration.networkId));
+		}
+		static startWithSeed(seed) {
+			const secretKeys = _midnight_ntwrk_ledger_v8.ZswapSecretKeys.fromSeed(seed);
+			return CustomShieldedWalletImplementation.startWithSecretKeys(secretKeys);
+		}
+		static restore(serializedState) {
+			const deserialized = CustomShieldedWalletImplementation.allVariantsRecord()[V1Tag].variant.deserializeState(serializedState).pipe(require_const.getOrThrow$1);
+			return CustomShieldedWalletImplementation.startFirst(CustomShieldedWalletImplementation, deserialized);
+		}
+		state;
+		constructor(runtime, scope) {
+			super(runtime, scope);
+			this.state = this.rawState.pipe(rxjs.map(ShieldedWalletState.mapState(CustomShieldedWalletImplementation.allVariantsRecord()[V1Tag].variant)), rxjs.shareReplay({
+				refCount: true,
+				bufferSize: 1
+			}));
+		}
+		start(secretKeys) {
+			return this.runtime.dispatch({ [V1Tag]: (v1) => v1.startSyncInBackground(secretKeys) }).pipe(require_const.runPromise);
+		}
+		balanceTransaction(secretKeys, tx) {
+			return this.runtime.dispatch({ [V1Tag]: (v1) => v1.balanceTransaction(secretKeys, tx) }).pipe(require_const.runPromise);
+		}
+		transferTransaction(secretKeys, outputs) {
+			return this.runtime.dispatch({ [V1Tag]: (v1) => v1.transferTransaction(secretKeys, outputs) }).pipe(require_const.runPromise);
+		}
+		initSwap(secretKeys, desiredInputs, desiredOutputs) {
+			return this.runtime.dispatch({ [V1Tag]: (v1) => v1.initSwap(secretKeys, desiredInputs, desiredOutputs) }).pipe(require_const.runPromise);
+		}
+		revertTransaction(transaction) {
+			return this.runtime.dispatch({ [V1Tag]: (v1) => v1.revertTransaction(transaction) }).pipe(require_const.runPromise);
+		}
+		waitForSyncedState(allowedGap = 0n) {
+			return rxjs.firstValueFrom(this.state.pipe(rxjs.filter((state) => state.state.progress.isCompleteWithin(allowedGap))));
+		}
+		/**
+		* Serializes the most recent state It's preferable to use [[ShieldedWalletState.serialize]] instead, to know
+		* exactly, which state is serialized
+		*/
+		serializeState() {
+			return rxjs.firstValueFrom(this.state).then((state) => state.serialize());
+		}
+		getAddress() {
+			return rxjs.firstValueFrom(this.state).then((state) => state.address);
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-facade/dist/transaction.js
+const finalizedTransactionTrait = {
+	areAllTxIdsIncluded(tx, txIds) {
+		const txIdsSet = require_const.fromIterable$1(tx.identifiers());
+		const expectedIdSet = require_const.fromIterable$1(txIds);
+		return require_const.isSubset(txIdsSet, expectedIdSet);
+	},
+	deserialize(serialized) {
+		return _midnight_ntwrk_ledger_v8.Transaction.deserialize("signature", "proof", "binding", serialized);
+	},
+	firstId(tx) {
+		return tx.identifiers()[0];
+	},
+	hasTTLExpired(tx, creationTime, now) {
+		const defaultShieldedGracePeriod = _midnight_ntwrk_ledger_v8.LedgerParameters.initialParameters().dust.dustGracePeriodSeconds;
+		const intentTTLs = require_const.pipe(tx.intents?.values().toArray() ?? [], require_const.map$6((i) => i.ttl), require_const.filterMap$1(require_const.make));
+		const hasDustPayments = require_const.pipe(tx.intents?.values().toArray() ?? [], require_const.flatMap$3((i) => i.dustActions?.spends ?? []), require_const.isNonEmptyArray);
+		const hasShieldedOffers = tx.guaranteedOffer != null || (tx.fallibleOffer?.size ?? 0) == 0;
+		const maybeShieldedTTL = hasDustPayments || hasShieldedOffers ? require_const.pipe(creationTime, require_const.addDuration(require_const.seconds(Number(defaultShieldedGracePeriod))), require_const.of$2) : require_const.empty$3();
+		return require_const.pipe(intentTTLs, require_const.appendAll$1(maybeShieldedTTL), (arr) => require_const.isNonEmptyReadonlyArray(arr) ? require_const.some(require_const.min(arr, require_const.mapInput$1(require_const.Date, require_const.toDate))) : require_const.none(), require_const.match$3({
+			onNone: () => false,
+			onSome: (finalTTL) => require_const.distance(finalTTL, now) > 0
+		}));
+	},
+	ids(tx) {
+		return tx.identifiers();
+	},
+	isOneIncludedInOther(tx, otherTx) {
+		const txIds = require_const.fromIterable$1(tx.identifiers());
+		const otherTxIds = require_const.fromIterable$1(otherTx.identifiers());
+		const smallerSize = require_const.min$1(require_const.number)(require_const.size(txIds), require_const.size(otherTxIds));
+		const intersection$1 = require_const.intersection(txIds, otherTxIds);
+		return require_const.size(intersection$1) == smallerSize;
+	},
+	isTx(tx) {
+		return tx instanceof _midnight_ntwrk_ledger_v8.Transaction;
+	},
+	serialize(tx) {
+		return tx.serialize();
+	}
+};
+//#endregion
+//#region ../../node_modules/@midnightntwrk/wallet-sdk-facade/dist/index.js
+/**
+* Full entry schema for transaction history — common fields + all wallet sections. Pass this to
+* `InMemoryTransactionHistoryStorage` to enable serialize/restore.
+*/
+const WalletEntrySchema = require_const.Struct({
+	...require_const.TransactionHistoryCommonSchema.fields,
+	shielded: require_const.optional(ShieldedSectionSchema),
+	unshielded: require_const.optional(require_watch.UnshieldedSectionSchema),
+	dust: require_const.optional(DustSectionSchema)
+});
+const mergeWalletEntries = (existing, incoming) => ({
+	...existing,
+	...incoming,
+	...existing.shielded !== void 0 && incoming.shielded !== void 0 ? { shielded: mergeShieldedSections(existing.shielded, incoming.shielded) } : {},
+	...existing.unshielded !== void 0 && incoming.unshielded !== void 0 ? { unshielded: {
+		...existing.unshielded,
+		...incoming.unshielded
+	} } : {},
+	...existing.dust !== void 0 && incoming.dust !== void 0 ? { dust: mergeDustSections(existing.dust, incoming.dust) } : {}
+});
+const isWalletEntry = require_const.is(WalletEntrySchema);
+const TokenKindsToBalance = new class {
+	allTokenKinds = [
+		"shielded",
+		"unshielded",
+		"dust"
+	];
+	toFlags = (tokenKinds) => {
+		return require_const.pipe(tokenKinds, (kinds) => kinds === "all" ? this.allTokenKinds : kinds, (kinds) => ({
+			shouldBalanceUnshielded: kinds.includes("unshielded"),
+			shouldBalanceShielded: kinds.includes("shielded"),
+			shouldBalanceDust: kinds.includes("dust")
+		}));
+	};
+}();
+const BalancingRecipe = {
+	isRecipe: (value) => {
+		return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string" && [
+			"FINALIZED_TRANSACTION",
+			"UNBOUND_TRANSACTION",
+			"UNPROVEN_TRANSACTION"
+		].includes(value.type);
+	},
+	getTransactions: (recipe) => {
+		switch (recipe.type) {
+			case "FINALIZED_TRANSACTION": return [recipe.originalTransaction, recipe.balancingTransaction];
+			case "UNBOUND_TRANSACTION": {
+				const balancingPart = recipe.balancingTransaction ? [recipe.balancingTransaction] : [];
+				return [recipe.baseTransaction, ...balancingPart];
+			}
+			case "UNPROVEN_TRANSACTION": return [recipe.transaction];
+		}
+	}
+};
+var FacadeState = class {
+	shielded;
+	unshielded;
+	dust;
+	pending;
+	get isSynced() {
+		return this.shielded.state.progress.isStrictlyComplete() && this.dust.state.progress.isStrictlyComplete() && this.unshielded.progress.isStrictlyComplete();
+	}
+	constructor(shielded, unshielded, dust, pending) {
+		this.shielded = shielded;
+		this.unshielded = unshielded;
+		this.dust = dust;
+		this.pending = pending;
+	}
+};
+const DEFAULT_TTL_MS = 3600 * 1e3;
+var WalletFacade = class WalletFacade {
+	static makeDefaultSubmissionService(config) {
+		return require_watch.makeDefaultSubmissionService(config);
+	}
+	static makeDefaultPendingTransactionsService(config) {
+		return require_watch.PendingTransactionsServiceImpl.init({
+			configuration: config,
+			txTrait: finalizedTransactionTrait
+		});
+	}
+	static makeDefaultProvingService(config) {
+		if (config.provingServerUrl) return require_watch.makeDefaultProvingService({ provingServerUrl: config.provingServerUrl });
+		else throw new Error("Missing required configuration: 'provingServerUrl' must be set in config, or provide a custom provingService in init parameters.");
+	}
+	/**
+	* Fetches the current Terms and Conditions from the network indexer.
+	*
+	* This is a static, pre-initialization utility — no wallet instance is required. Wallet builders should call this
+	* before or independently of wallet initialization to display the current T&C to end users and obtain the hash for
+	* content verification.
+	*
+	* The returned `hash` is the hex-encoded SHA-256 hash of the document at `url`. Wallet builders are responsible for
+	* fetching and rendering the document content via `url` in whatever manner suits their application.
+	*
+	* @param configuration - An object with an `indexerClientConnection.indexerHttpUrl`. Any wallet configuration that
+	*   satisfies {@link FetchTermsAndConditionsConfiguration} can be passed directly.
+	* @returns A promise resolving to the current {@link TermsAndConditions}, or rejecting if no Terms and Conditions have
+	*   been set on the network yet.
+	*/
+	static async fetchTermsAndConditions(configuration) {
+		const tc = (await require_watch.runPromise(require_watch.FetchTermsAndConditions, {}, { url: configuration.indexerClientConnection.indexerHttpUrl })).block?.systemParameters?.termsAndConditions;
+		if (!tc) throw new Error("Terms and Conditions are not currently set on the network.");
+		return tc;
+	}
+	/**
+	* Default initialization for {@link WalletFacade}. It is a static method, which takes an object holding configuration
+	* and initialization of necessary components. Specifically - it requires following fields:
+	*
+	* - `configuration` - holding a configuration, which needs to extend {@link DefaultConfiguration} - this way allows to
+	*   convey use-case-specific settings in the same way, as the SDK works by default
+	* - `shielded` - a function taking the configuration and returning shielded wallet (or a promise with such)
+	*   implementing {@link ShieldedWalletAPI}
+	* - `unshielded` - a function taking the configuration and returning unshielded wallet (or a promise with such)
+	*   implementing {@link UnshieldedWalletAPI}
+	* - `dust` - a function taking the configuration and returning Dust wallet (or a promise with such) implementing
+	*   {@link DustWalletAPI} There are some optional services/abstractions to provide, too. If not provided - default
+	*   implementations will be used, each of them is initialized by a function taking the configuration and returning
+	*   proper implementation (wrapped in a {@link Promise} or not).
+	* - `submissionService` - needs to implement {@link SubmissionService} for a {@link ledger.FinalizedTransaction} to
+	*   submit transactions to the network, default uses Node RPC connection
+	* - `pendingTransactionsService` - needs to implement {@link PendingTransactionsService} for a
+	*   {@link ledger.FinalizedTransaction} to keep track of pending transactions, default uses in-memory implementation
+	* - `provingService` - needs to implement {@link ProvingService} to prove it, default uses proving server
+	* - `clock` - needs to implement {@link Clock.Clock} for getting current time, default uses system clock
+	*/
+	static async init(initParams) {
+		const submissionService = await Promise.resolve(initParams.submissionService ? initParams.submissionService(initParams.configuration) : WalletFacade.makeDefaultSubmissionService(initParams.configuration));
+		const pendingTransactionsService = await Promise.resolve(initParams.pendingTransactionsService ? initParams.pendingTransactionsService(initParams.configuration) : WalletFacade.makeDefaultPendingTransactionsService(initParams.configuration));
+		const provingService = await Promise.resolve(initParams.provingService ? initParams.provingService(initParams.configuration) : WalletFacade.makeDefaultProvingService(initParams.configuration));
+		const shielded = await Promise.resolve(initParams.shielded(initParams.configuration));
+		const unshielded = await Promise.resolve(initParams.unshielded(initParams.configuration));
+		const dust = await Promise.resolve(initParams.dust(initParams.configuration));
+		const clock = await Promise.resolve(initParams.clock ? initParams.clock(initParams.configuration) : require_watch.systemClock);
+		return new WalletFacade(shielded, unshielded, dust, submissionService, pendingTransactionsService, provingService, initParams.configuration.txHistoryStorage, clock);
+	}
+	shielded;
+	unshielded;
+	dust;
+	submissionService;
+	pendingTransactionsService;
+	provingService;
+	#txHistoryStorage;
+	clock;
+	#pendingSubscription;
+	/**
+	* Constructor is private on purpose - much of initialization of the facade is potentially asynchronous, and adding
+	* new parameters is a breaking change to the users Use {@link WalletFacade.init} instead
+	*
+	* @private
+	*/
+	constructor(shieldedWallet, unshieldedWallet, dustWallet, submissionService, pendingTransactionsService, provingService, txHistoryStorage, clock = require_watch.systemClock) {
+		this.shielded = shieldedWallet;
+		this.unshielded = unshieldedWallet;
+		this.dust = dustWallet;
+		this.submissionService = submissionService;
+		this.pendingTransactionsService = pendingTransactionsService;
+		this.provingService = provingService;
+		this.#txHistoryStorage = txHistoryStorage;
+		this.clock = clock;
+		this.#pendingSubscription = this.pendingTransactionsService.state().pipe((0, rxjs.concatMap)((pending) => require_watch.allFailed(pending)), (0, rxjs.concatMap)((item) => this.revert(item.tx))).subscribe();
+	}
+	defaultTtl() {
+		return new Date(this.clock.now().getTime() + DEFAULT_TTL_MS);
+	}
+	mergeUnprovenTransactions(a, b) {
+		if (a && b) return a.merge(b);
+		return a ?? b;
+	}
+	async createDustActionTransaction(action, nightUtxos, nightVerifyingKey, signDustRegistration) {
+		const ttl = this.defaultTtl();
+		const now = this.clock.now();
+		const isRegistration = action.type === "registration";
+		const dustReceiverAddress = isRegistration ? action.dustReceiverAddress : void 0;
+		const split = await this.dust.splitNightUtxosForDustRegistration(now, nightUtxos.map(({ utxo, meta }) => ({
+			...utxo,
+			ctime: meta.ctime,
+			registeredForDustGeneration: meta.registeredForDustGeneration
+		})), isRegistration);
+		const toUnshieldedUtxoWithMeta = (u) => ({
+			utxo: {
+				value: u.utxo.value,
+				type: u.utxo.type,
+				owner: u.utxo.owner,
+				intentHash: u.utxo.intentHash,
+				outputNo: u.utxo.outputNo
+			},
+			meta: {
+				ctime: u.utxo.ctime,
+				registeredForDustGeneration: u.utxo.registeredForDustGeneration
+			}
+		});
+		const guaranteedForUnshielded = split.guaranteedUtxos.map(toUnshieldedUtxoWithMeta);
+		const fallibleForUnshielded = split.fallibleUtxos.map(toUnshieldedUtxoWithMeta);
+		const txWithOffers = await this.unshielded.rotateUtxos(guaranteedForUnshielded, fallibleForUnshielded, nightVerifyingKey, ttl);
+		let txWithDustActions;
+		try {
+			txWithDustActions = await this.dust.attachDustRegistration(txWithOffers, now, nightVerifyingKey, dustReceiverAddress, split.feePayment);
+		} catch (error) {
+			await this.unshielded.revertTransaction(txWithOffers);
+			throw error;
+		}
+		const hasUnregisteredGuaranteed = split.guaranteedUtxos.some((u) => !u.utxo.registeredForDustGeneration);
+		if (isRegistration && hasUnregisteredGuaranteed) {
+			const fee = await this.dust.calculateFee([txWithDustActions]);
+			if (split.feePayment < fee) {
+				await this.unshielded.revertTransaction(txWithOffers);
+				throw Error(`Insufficient generated dust to cover registration fee (have ${split.feePayment}, need ${fee}). Use WalletFacade.waitForGeneratedDust(utxos, ${fee}) before retrying.`);
+			}
+		}
+		try {
+			const signedRecipe = await this.signRecipe({
+				type: "UNPROVEN_TRANSACTION",
+				transaction: txWithDustActions
+			}, signDustRegistration);
+			if (signedRecipe.type !== "UNPROVEN_TRANSACTION") throw Error("signRecipe returned unexpected recipe type for dust action transaction.");
+			return signedRecipe.transaction;
+		} catch (error) {
+			await this.unshielded.revertTransaction(txWithOffers);
+			throw error;
+		}
+	}
+	state() {
+		return (0, rxjs.combineLatest)([
+			this.shielded.state,
+			this.unshielded.state,
+			this.dust.state,
+			this.pendingTransactionsService.state()
+		]).pipe((0, rxjs.map)(([shieldedState, unshieldedState, dustState, pending]) => new FacadeState(shieldedState, unshieldedState, dustState, pending)));
+	}
+	async waitForSyncedState() {
+		const [shieldedState, unshieldedState, dustState, pending] = await Promise.all([
+			this.shielded.waitForSyncedState(),
+			this.unshielded.waitForSyncedState(),
+			this.dust.waitForSyncedState(),
+			(0, rxjs.firstValueFrom)(this.pendingTransactionsService.state())
+		]);
+		return new FacadeState(shieldedState, unshieldedState, dustState, pending);
+	}
+	async submitTransaction(tx) {
+		try {
+			await this.pendingTransactionsService.addPendingTransaction(tx);
+			await this.submissionService.submitTransaction(tx, "Finalized");
+			return tx.identifiers().at(-1);
+		} catch (error) {
+			await this.revert(tx);
+			throw error;
+		}
+	}
+	async balanceFinalizedTransaction(tx, secretKeys, options) {
+		const { shieldedSecretKeys, dustSecretKey } = secretKeys;
+		const { ttl, tokenKindsToBalance = "all" } = options;
+		const { shouldBalanceDust, shouldBalanceShielded, shouldBalanceUnshielded } = TokenKindsToBalance.toFlags(tokenKindsToBalance);
+		const unshieldedBalancingTx = shouldBalanceUnshielded ? await this.unshielded.balanceFinalizedTransaction(tx) : void 0;
+		const shieldedBalancingTx = shouldBalanceShielded ? await this.shielded.balanceTransaction(shieldedSecretKeys, tx) : void 0;
+		const mergedBalancingTx = this.mergeUnprovenTransactions(shieldedBalancingTx, unshieldedBalancingTx);
+		const feeBalancingTx = shouldBalanceDust ? await this.dust.balanceTransactions(dustSecretKey, mergedBalancingTx ? [tx, mergedBalancingTx] : [tx], ttl) : void 0;
+		const balancingTx = this.mergeUnprovenTransactions(mergedBalancingTx, feeBalancingTx);
+		if (!balancingTx) throw new Error("No balancing transaction was created. Please check your transaction.");
+		return {
+			type: "FINALIZED_TRANSACTION",
+			originalTransaction: tx,
+			balancingTransaction: balancingTx
+		};
+	}
+	async balanceUnboundTransaction(tx, secretKeys, options) {
+		const { shieldedSecretKeys, dustSecretKey } = secretKeys;
+		const { ttl, tokenKindsToBalance = "all" } = options;
+		const { shouldBalanceDust, shouldBalanceShielded, shouldBalanceUnshielded } = TokenKindsToBalance.toFlags(tokenKindsToBalance);
+		const shieldedBalancingTx = shouldBalanceShielded ? await this.shielded.balanceTransaction(shieldedSecretKeys, tx) : void 0;
+		const balancedUnshieldedTx = shouldBalanceUnshielded ? await this.unshielded.balanceUnboundTransaction(tx) : void 0;
+		const baseTx = balancedUnshieldedTx ?? tx;
+		const feeBalancingTransaction = shouldBalanceDust ? await this.dust.balanceTransactions(dustSecretKey, shieldedBalancingTx ? [baseTx, shieldedBalancingTx] : [baseTx], ttl) : void 0;
+		const balancingTransaction = this.mergeUnprovenTransactions(shieldedBalancingTx, feeBalancingTransaction);
+		if (!balancingTransaction && !balancedUnshieldedTx) throw new Error("No balancing transaction was created. Please check your transaction.");
+		return {
+			type: "UNBOUND_TRANSACTION",
+			baseTransaction: baseTx,
+			balancingTransaction: balancingTransaction ?? void 0
+		};
+	}
+	async balanceUnprovenTransaction(tx, secretKeys, options) {
+		const { shieldedSecretKeys, dustSecretKey } = secretKeys;
+		const { ttl, tokenKindsToBalance = "all" } = options;
+		const { shouldBalanceDust, shouldBalanceShielded, shouldBalanceUnshielded } = TokenKindsToBalance.toFlags(tokenKindsToBalance);
+		const shieldedBalancingTx = shouldBalanceShielded ? await this.shielded.balanceTransaction(shieldedSecretKeys, tx) : void 0;
+		const baseTx = (shouldBalanceUnshielded ? await this.unshielded.balanceUnprovenTransaction(tx) : void 0) ?? tx;
+		const mergedTx = this.mergeUnprovenTransactions(baseTx, shieldedBalancingTx);
+		const feeBalancingTx = shouldBalanceDust ? await this.dust.balanceTransactions(dustSecretKey, [mergedTx], ttl) : void 0;
+		return {
+			type: "UNPROVEN_TRANSACTION",
+			transaction: this.mergeUnprovenTransactions(mergedTx, feeBalancingTx)
+		};
+	}
+	async finalizeRecipe(recipe) {
+		return Promise.resolve(recipe).then(async (recipe) => {
+			switch (recipe.type) {
+				case "FINALIZED_TRANSACTION": {
+					const finalizedBalancing = await this.finalizeTransaction(recipe.balancingTransaction);
+					return recipe.originalTransaction.merge(finalizedBalancing);
+				}
+				case "UNBOUND_TRANSACTION": {
+					const finalizedBalancingTx = recipe.balancingTransaction ? await this.finalizeTransaction(recipe.balancingTransaction) : void 0;
+					const finalizedTransaction = recipe.baseTransaction.bind();
+					return finalizedBalancingTx ? finalizedTransaction.merge(finalizedBalancingTx) : finalizedTransaction;
+				}
+				case "UNPROVEN_TRANSACTION": return await this.finalizeTransaction(recipe.transaction);
+			}
+		}).then(async (finalizedTx) => {
+			await this.pendingTransactionsService.addPendingTransaction(finalizedTx);
+			return finalizedTx;
+		});
+	}
+	async signRecipe(recipe, signSegment) {
+		switch (recipe.type) {
+			case "FINALIZED_TRANSACTION": {
+				const signedBalancingTx = await this.signUnprovenTransaction(recipe.balancingTransaction, signSegment);
+				const withDustSig = await this.#signDustRegistrationIfPresent(signedBalancingTx, signSegment);
+				return {
+					type: "FINALIZED_TRANSACTION",
+					originalTransaction: recipe.originalTransaction,
+					balancingTransaction: withDustSig
+				};
+			}
+			case "UNBOUND_TRANSACTION": {
+				const signedBalancingTx = recipe.balancingTransaction ? await this.signUnprovenTransaction(recipe.balancingTransaction, signSegment).then((tx) => this.#signDustRegistrationIfPresent(tx, signSegment)) : void 0;
+				return {
+					type: "UNBOUND_TRANSACTION",
+					baseTransaction: await this.signUnboundTransaction(recipe.baseTransaction, signSegment),
+					balancingTransaction: signedBalancingTx
+				};
+			}
+			case "UNPROVEN_TRANSACTION": {
+				const signedTx = await this.signUnprovenTransaction(recipe.transaction, signSegment);
+				return {
+					type: "UNPROVEN_TRANSACTION",
+					transaction: await this.#signDustRegistrationIfPresent(signedTx, signSegment)
+				};
+			}
+		}
+	}
+	async #signDustRegistrationIfPresent(tx, signSegment) {
+		const intent = tx.intents?.get(1);
+		const registrations = intent?.dustActions?.registrations ?? [];
+		if (!intent || registrations.length === 0) return tx;
+		const signature = signSegment(intent.signatureData(1));
+		return await this.dust.addDustRegistrationSignature(tx, signature);
+	}
+	async signUnprovenTransaction(tx, signSegment) {
+		return await this.unshielded.signUnprovenTransaction(tx, signSegment);
+	}
+	async signUnboundTransaction(tx, signSegment) {
+		return await this.unshielded.signUnboundTransaction(tx, signSegment);
+	}
+	async finalizeTransaction(tx) {
+		try {
+			const finalizedTx = (await this.provingService.prove(tx)).bind();
+			await this.pendingTransactionsService.addPendingTransaction(finalizedTx);
+			return finalizedTx;
+		} catch (error) {
+			await Promise.allSettled([
+				this.shielded.revertTransaction(tx),
+				this.unshielded.revertTransaction(tx),
+				this.dust.revertTransaction(tx)
+			]);
+			throw error;
+		}
+	}
+	/** Estimates the fee for the given transaction only. This lacks the fees of the balancing transaction. */
+	async calculateTransactionFee(tx) {
+		return await this.dust.calculateFee([tx]);
+	}
+	/** Calculates the total fee for the given transaction plus the fee of the balancing transaction. */
+	async estimateTransactionFee(tx, secretKey, options) {
+		const ttl = options?.ttl ?? this.defaultTtl();
+		return await this.dust.estimateFee(secretKey, [tx], ttl, options?.currentTime);
+	}
+	async transferTransaction(outputs, secretKeys, options) {
+		const { shieldedSecretKeys, dustSecretKey } = secretKeys;
+		const { ttl, payFees = true } = options;
+		const unshieldedOutputs = outputs.filter((output) => output.type === "unshielded").flatMap((output) => output.outputs);
+		const shieldedOutputs = outputs.filter((output) => output.type === "shielded").flatMap((output) => output.outputs);
+		if (unshieldedOutputs.length === 0 && shieldedOutputs.length === 0) throw Error("At least one shielded or unshielded output is required.");
+		const shieldedTx = shieldedOutputs.length > 0 ? await this.shielded.transferTransaction(shieldedSecretKeys, shieldedOutputs) : void 0;
+		const unshieldedTx = unshieldedOutputs.length > 0 ? await this.unshielded.transferTransaction(unshieldedOutputs, ttl) : void 0;
+		const mergedTxs = this.mergeUnprovenTransactions(shieldedTx, unshieldedTx);
+		const feeBalancingTx = payFees ? await this.dust.balanceTransactions(dustSecretKey, [mergedTxs], ttl) : void 0;
+		return {
+			type: "UNPROVEN_TRANSACTION",
+			transaction: this.mergeUnprovenTransactions(mergedTxs, feeBalancingTx)
+		};
+	}
+	/**
+	* Provides estimate of the fee of issuing registration transaction with provided UTxOs
+	*
+	* @param nightUtxos - Night UTxOs to use for the registration
+	* @returns And object informing about fee at the moment, as well as estimation of dust generation of the UTxO(s),
+	*   that would be used for paying the fee. These include data that allows to compute when the fee could be paid
+	*/
+	async estimateRegistration(nightUtxos) {
+		const now = this.clock.now();
+		const dustState = await this.dust.waitForSyncedState();
+		const dustGenerationEstimations = require_const.pipe(nightUtxos, require_const.map$6(({ utxo, meta }) => ({
+			...utxo,
+			ctime: meta.ctime,
+			registeredForDustGeneration: meta.registeredForDustGeneration
+		})), (utxosWithMeta) => dustState.estimateDustGeneration(utxosWithMeta, now), (estimatedUtxos) => dustState.capabilities.coinsAndBalances.splitNightUtxos(estimatedUtxos), (split) => split.guaranteed);
+		const fakeSigningKey = _midnight_ntwrk_ledger_v8.sampleSigningKey();
+		const fakeVerifyingKey = _midnight_ntwrk_ledger_v8.signatureVerifyingKey(fakeSigningKey);
+		const ttl = this.defaultTtl();
+		const fakeUnsignedTx = await this.dust.createDustGenerationTransaction(void 0, ttl, nightUtxos.map(({ utxo, meta }) => ({
+			...utxo,
+			ctime: meta.ctime,
+			registeredForDustGeneration: meta.registeredForDustGeneration
+		})), fakeVerifyingKey, dustState.address);
+		const intent = fakeUnsignedTx.intents?.get(1);
+		if (!intent) throw Error("Dust generation transaction is missing intent segment 1.");
+		const signatureData = intent.signatureData(1);
+		const signature = _midnight_ntwrk_ledger_v8.signData(fakeSigningKey, signatureData);
+		const finalizedFakeTx = (await this.dust.addDustGenerationSignature(fakeUnsignedTx, signature)).mockProve().bind();
+		return {
+			fee: await this.calculateTransactionFee(finalizedFakeTx),
+			dustGenerationEstimations
+		};
+	}
+	async initSwap(desiredInputs, desiredOutputs, secretKeys, options) {
+		const { shieldedSecretKeys, dustSecretKey } = secretKeys;
+		const { ttl, payFees = false } = options;
+		const { shielded: shieldedInputs, unshielded: unshieldedInputs } = desiredInputs;
+		const shieldedOutputs = desiredOutputs.filter((output) => output.type === "shielded").flatMap((output) => output.outputs);
+		const unshieldedOutputs = desiredOutputs.filter((output) => output.type === "unshielded").flatMap((output) => 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 Error("At least one shielded or unshielded swap is required.");
+		const shieldedTx = hasShieldedPart && shieldedInputs !== void 0 ? await this.shielded.initSwap(shieldedSecretKeys, shieldedInputs, shieldedOutputs) : void 0;
+		const unshieldedTx = hasUnshieldedPart && unshieldedInputs !== void 0 ? await this.unshielded.initSwap(unshieldedInputs, unshieldedOutputs, ttl) : void 0;
+		const combinedTx = this.mergeUnprovenTransactions(shieldedTx, unshieldedTx);
+		if (!combinedTx) throw Error("Unexpected transaction state.");
+		const feeBalancingTx = payFees ? await this.dust.balanceTransactions(dustSecretKey, [combinedTx], ttl) : void 0;
+		return {
+			type: "UNPROVEN_TRANSACTION",
+			transaction: this.mergeUnprovenTransactions(combinedTx, feeBalancingTx)
+		};
+	}
+	async registerNightUtxosForDustGeneration(nightUtxos, nightVerifyingKey, signDustRegistration, dustReceiverAddress) {
+		if (nightUtxos.length === 0) throw Error("At least one Night UTXO is required.");
+		const receiverAddress = dustReceiverAddress ?? await this.dust.getAddress();
+		return {
+			type: "UNPROVEN_TRANSACTION",
+			transaction: await this.createDustActionTransaction({
+				type: "registration",
+				dustReceiverAddress: receiverAddress
+			}, nightUtxos, nightVerifyingKey, signDustRegistration)
+		};
+	}
+	/**
+	* Waits until the dust projected to be generated by the given Night UTxOs reaches `requiredAmount`, re-checking every
+	* second. Pair with {@link estimateRegistration} to pick `requiredAmount`, then call before
+	* {@link registerNightUtxosForDustGeneration} so the registration covers its own fee.
+	*
+	* @param nightUtxos - Night UTxOs to project generation for; the same set passed to the registration.
+	* @param requiredAmount - Dust threshold to wait for. Resolves immediately if `<= 0n`.
+	* @param opts.timeoutMs - Deadline, in ms, for the threshold to be reached. Rejects otherwise. Default `300_000`.
+	* @throws If `nightUtxos` is empty, or if `requiredAmount` is not reached within `opts.timeoutMs`.
+	*/
+	async waitForGeneratedDust(nightUtxos, requiredAmount, opts) {
+		await this.dust.waitForGeneratedDust(nightUtxos.map(({ utxo, meta }) => ({
+			...utxo,
+			ctime: meta.ctime,
+			registeredForDustGeneration: meta.registeredForDustGeneration
+		})), requiredAmount, this.clock, opts);
+	}
+	async deregisterFromDustGeneration(nightUtxos, nightVerifyingKey, signDustRegistration) {
+		return {
+			type: "UNPROVEN_TRANSACTION",
+			transaction: await this.createDustActionTransaction({ type: "deregistration" }, nightUtxos, nightVerifyingKey, signDustRegistration)
+		};
+	}
+	async revert(txOrRecipe) {
+		const transactionsToRevert = BalancingRecipe.isRecipe(txOrRecipe) ? BalancingRecipe.getTransactions(txOrRecipe) : [txOrRecipe];
+		await Promise.all(transactionsToRevert.map((tx) => this.revertTransaction(tx)));
+	}
+	async revertTransaction(tx) {
+		await Promise.all([
+			this.shielded.revertTransaction(tx),
+			this.unshielded.revertTransaction(tx),
+			this.dust.revertTransaction(tx)
+		]).then(() => this.pendingTransactionsService.clear(tx));
+	}
+	async start(shieldedSecretKeys, dustSecretKey) {
+		await Promise.all([
+			this.shielded.start(shieldedSecretKeys),
+			this.unshielded.start(),
+			this.dust.start(dustSecretKey),
+			this.pendingTransactionsService.start()
+		]);
+	}
+	async stop() {
+		await Promise.all([
+			this.shielded.stop(),
+			this.unshielded.stop(),
+			this.dust.stop(),
+			this.submissionService.close(),
+			this.pendingTransactionsService.stop(),
+			Promise.resolve(this.#pendingSubscription?.unsubscribe())
+		]);
+	}
+	async queryTxHistoryByHash(hash) {
+		const raw = await this.#txHistoryStorage.get(hash);
+		return raw && isWalletEntry(raw) ? raw : void 0;
+	}
+	async getAllFromTxHistory() {
+		return [...await this.#txHistoryStorage.getAll()];
+	}
+};
+//#endregion
+//#region ../../packages/module/midnight-sync/src/store/compute-sync-ratio.ts
+const computeConnectedSyncRatio = (applied, highest, isConnected) => isConnected && applied === 0n && highest === 0n ? (0, _laceio_cardano_util.Percent)(1) : computeSyncRatio(applied, highest);
+const computeSyncRatio = (applied, highest) => {
+	if (highest === 0n) {
+		if (applied === 0n) return (0, _laceio_cardano_util.Percent)(0);
+		const ratio = 1 - 1 / (1 + Number(applied) / 1e3);
+		return (0, _laceio_cardano_util.Percent)(Math.min(.99, ratio));
+	}
+	return (0, _laceio_cardano_util.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((0, rxjs.take)(1), (0, rxjs.catchError)((error) => {
+	if (!(error instanceof require_types.AuthenticationCancelledError)) return (0, rxjs.throwError)(() => error);
+	return keyManager.areKeysAvailable$.pipe((0, rxjs.filter)((available) => available), (0, rxjs.take)(1), (0, rxjs.switchMap)(() => keyManager.keys$.pipe((0, rxjs.take)(1))));
+}));
+const STATE_SERIALISATION_THROTTLE_TIME = require_time_vo.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, createLocalProofServerAccess, batchUpdates = DEFAULT_BATCH_UPDATES }) => {
+	const walletState = await (0, rxjs.firstValueFrom)(store.get(String(account.accountId)).pipe((0, rxjs.defaultIfEmpty)(void 0)));
+	const indexerClientConnection = {
+		indexerHttpUrl: config.indexerAddress,
+		indexerWsUrl: require_utils.convertHttpUrlToWebsocket(config.indexerAddress),
+		keepAlive: 15e3
+	};
+	const { networkId } = account.blockchainSpecific;
+	const proofServerUrl = require_const.getProofServerEndpoint(config.proofServer);
+	if (!proofServerUrl && config.proofServer.kind !== "in-process") throw new Error(`Cannot start Midnight wallet: proof server mode "${config.proofServer.kind}" has no HTTP endpoint`);
+	require_const.assertProofServerRouting(config.proofServer, !!createAttestedProver, !!createLocalProofServerAccess);
+	const createAccess = (onProgress) => config.proofServer.kind === "in-process" && createLocalProofServerAccess ? createLocalProofServerAccess(onProgress) : config.proofServer.kind === "tee-delegated" && createAttestedProver ? require_watch.createAttestedProofServerAccess(createAttestedProver({
+		networkId,
+		proofServerApiUrl: config.proofServer.url,
+		getLedgerIndexerUrl: async () => {
+			if (!getTemenosLedgerIndexerUrl) throw new Error("Temenos attestation requires a ledger indexer resolver");
+			return getTemenosLedgerIndexerUrl();
+		}
+	}), onProgress) : require_watch.createProofServerAccess(require_watch.createHttpProofServerTransport(proofServerUrl));
+	const proofServer = require_watch.createScopedProofServerAccess(createAccess);
+	const { finalizeRecipe } = proofServer;
+	const configuration = {
+		costParameters: {
+			additionalFeeOverhead: 300000000000000n,
+			feeBlocksMargin: 5
+		},
+		networkId,
+		batchUpdates,
+		indexerClientConnection,
+		relayURL: new URL(require_utils.convertHttpUrlToWebsocket(config.nodeAddress)),
+		txHistoryStorage: new require_const.InMemoryTransactionHistoryStorage(WalletEntrySchema, mergeWalletEntries)
+	};
+	if (walletState) {
+		const { dust, shielded, unshielded } = walletState.serializedState;
+		let restoredTxHistoryStorage;
+		try {
+			restoredTxHistoryStorage = require_const.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 (0, rxjs.firstValueFrom)(store.removeWhere((state) => state.accountId === account.accountId).pipe((0, rxjs.defaultIfEmpty)(void 0), (0, rxjs.catchError)((wipeError) => {
+				logger.error(`Failed to discard unreadable Midnight wallet state for account ${account.accountId}`, wipeError);
+				return (0, rxjs.of)(void 0);
+			})));
+		}
+		if (restoredTxHistoryStorage) {
+			configuration.txHistoryStorage = restoredTxHistoryStorage;
+			return {
+				walletFacade: await WalletFacade.init({
+					configuration,
+					provingService: () => proofServer.provingService,
+					submissionService: createProgressSubmissionService,
+					shielded: (config) => ShieldedWallet(config).restore(SerialisedWalletState.toJSON(shielded)),
+					unshielded: (config) => require_watch.UnshieldedWallet(config).restore(SerialisedWalletState.toJSON(unshielded)),
+					dust: (config) => DustWallet(config).restore(SerialisedWalletState.toJSON(dust))
+				}),
+				txHistoryStorage: restoredTxHistoryStorage,
+				proofCircuitProvider: proofServer.circuits,
+				finalizeRecipe
+			};
+		}
+	}
+	const { walletKeys: { dustKeyBuffer, zswapKeyBuffer }, unshieldedKeystore } = await (0, rxjs.firstValueFrom)(keysWithAuthCancelledRecovery$(keyManager));
+	const dustParameters = _midnight_ntwrk_ledger_v8.LedgerParameters.initialParameters().dust;
+	const txHistoryStorage = new require_const.InMemoryTransactionHistoryStorage(WalletEntrySchema, mergeWalletEntries);
+	configuration.txHistoryStorage = txHistoryStorage;
+	return {
+		walletFacade: await WalletFacade.init({
+			configuration,
+			provingService: () => proofServer.provingService,
+			submissionService: createProgressSubmissionService,
+			shielded: (config) => ShieldedWallet(config).startWithSeed(zswapKeyBuffer),
+			unshielded: (config) => require_watch.UnshieldedWallet(config).startWithPublicKey(require_watch.PublicKey.fromKeyStore(unshieldedKeystore)),
+			dust: (config) => DustWallet(config).startWithSeed(dustKeyBuffer, dustParameters)
+		}),
+		txHistoryStorage,
+		proofCircuitProvider: proofServer.circuits,
+		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, proofCircuitProvider, finalizeRecipe }) => {
+	const { networkId } = account.blockchainSpecific;
+	const state$ = walletFacade.state().pipe((0, rxjs.shareReplay)({
+		bufferSize: 1,
+		refCount: true
+	}));
+	const releasing = withReservationRelease(walletFacade);
+	return state$.pipe((0, rxjs.take)(1), (0, rxjs.map)((initialState) => {
+		const nightVerifyingKey = initialState.unshielded.capabilities.keys.getPublicKey(initialState.unshielded.state);
+		return {
+			accountId: account.accountId,
+			areKeysAvailable$: keyManager.areKeysAvailable$,
+			networkId,
+			nightVerifyingKey,
+			proofCircuitProvider,
+			walletId: account.walletId,
+			address$: state$.pipe((0, rxjs.map)(({ dust, shielded, unshielded }) => ({
+				dust: MidnightDustAddress(require_dist.DustAddress.codec.encode(networkId, dust.capabilities.keys.getAddress(dust.state)).asString()),
+				shielded: MidnightShieldedAddress(require_dist.ShieldedAddress.codec.encode(networkId, shielded.address).asString()),
+				unshielded: MidnightUnshieldedAddress(require_dist.UnshieldedAddress.codec.encode(networkId, unshielded.address).asString())
+			})), (0, rxjs.distinctUntilChanged)(_laceio_cardano_util.deepEquals)),
+			coinsByTokenType$: state$.pipe((0, rxjs.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: require_bignum_vo.BigNumber(coin.value)
+					});
+				}
+				const parseUnshieldedCoins = (status, coins) => {
+					for (const { meta, utxo } of coins) {
+						const tokenType = require_utils.toUnshieldedTokenType(utxo.type, networkId);
+						unshieldedCoins[tokenType] = (unshieldedCoins[tokenType] || []).concat({
+							status,
+							value: require_bignum_vo.BigNumber(utxo.value),
+							registeredForDustGeneration: meta.registeredForDustGeneration,
+							ownerAddress: utxo.owner
+						});
+					}
+				};
+				parseUnshieldedCoins("pending", unshielded.pendingCoins);
+				parseUnshieldedCoins("available", unshielded.availableCoins);
+				return {
+					shielded: shieldedCoins,
+					unshielded: unshieldedCoins
+				};
+			}), (0, rxjs.distinctUntilChanged)(_laceio_cardano_util.deepEquals)),
+			syncProgress$: state$.pipe((0, rxjs.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()
+				}
+			})), (0, rxjs.distinctUntilChanged)(_laceio_cardano_util.deepEquals)),
+			transactionHistory$: state$.pipe((0, rxjs.throttleTime)(500, void 0, {
+				leading: true,
+				trailing: true
+			}), (0, rxjs.switchMap)(() => (0, rxjs.from)(walletFacade.getAllFromTxHistory())), (0, rxjs.distinctUntilChanged)(_laceio_cardano_util.deepEquals)),
+			balanceFinalizedTransaction: (tx, { ttl, tokenKindsToBalance }) => keyManager.keys$.pipe((0, rxjs.take)(1), (0, rxjs.switchMap)(({ walletKeys: { dustSecretKey, zswapSecretKeys } }) => (0, rxjs.from)(releasing.balanceFinalizedTransaction(tx, {
+				shieldedSecretKeys: zswapSecretKeys,
+				dustSecretKey
+			}, {
+				ttl,
+				tokenKindsToBalance
+			})))),
+			balanceUnboundTransaction: (tx, { ttl, tokenKindsToBalance }) => keyManager.keys$.pipe((0, rxjs.take)(1), (0, rxjs.switchMap)(({ walletKeys: { dustSecretKey, zswapSecretKeys } }) => (0, rxjs.from)(releasing.balanceUnboundTransaction(tx, {
+				shieldedSecretKeys: zswapSecretKeys,
+				dustSecretKey
+			}, {
+				ttl,
+				tokenKindsToBalance
+			})))),
+			balanceUnprovenTransaction: (tx, { ttl, tokenKindsToBalance }) => keyManager.keys$.pipe((0, rxjs.take)(1), (0, rxjs.switchMap)(({ walletKeys: { dustSecretKey, zswapSecretKeys } }) => (0, rxjs.from)(walletFacade.balanceUnprovenTransaction(tx, {
+				shieldedSecretKeys: zswapSecretKeys,
+				dustSecretKey
+			}, {
+				ttl,
+				tokenKindsToBalance
+			})))),
+			calculateTransactionFee: (tx) => (0, rxjs.from)(walletFacade.calculateTransactionFee(tx)),
+			estimateTransactionFee: (tx, options) => keyManager.keys$.pipe((0, rxjs.take)(1), (0, rxjs.switchMap)(({ walletKeys: { dustSecretKey } }) => (0, rxjs.from)(walletFacade.estimateTransactionFee(tx, dustSecretKey, options)))),
+			deregisterFromDustGeneration: (nightUtxos) => keyManager.keys$.pipe((0, rxjs.take)(1), (0, rxjs.switchMap)(({ unshieldedKeystore }) => (0, rxjs.from)(walletFacade.deregisterFromDustGeneration(nightUtxos, unshieldedKeystore.getPublicKey(), (data) => unshieldedKeystore.signData(data))))),
+			getTransactionHistoryEntryByHash: (hash) => (0, rxjs.from)(walletFacade.queryTxHistoryByHash(hash)),
+			finalizeRecipe: (recipe, onProgress) => (0, rxjs.defer)(async () => finalizeRecipe(walletFacade, recipe, onProgress)),
+			finalizeTransaction: (recipe) => (0, rxjs.from)(walletFacade.finalizeTransaction(recipe)),
+			registerNightUtxosForDustGeneration: (nightUtxos, dustAddress) => keyManager.keys$.pipe((0, rxjs.take)(1), (0, rxjs.switchMap)(({ unshieldedKeystore }) => (0, rxjs.from)(walletFacade.registerNightUtxosForDustGeneration(nightUtxos, unshieldedKeystore.getPublicKey(), (data) => unshieldedKeystore.signData(data), dustAddress)))),
+			revert: (recipe) => (0, rxjs.from)(walletFacade.revert(recipe)),
+			state: () => state$,
+			stop: () => {
+				haltPersistence();
+				return (0, rxjs.from)(walletFacade.stop());
+			},
+			signUnprovenTransaction: (tx) => keyManager.keys$.pipe((0, rxjs.take)(1), (0, rxjs.switchMap)(({ unshieldedKeystore }) => (0, rxjs.from)(walletFacade.signUnprovenTransaction(tx, (data) => unshieldedKeystore.signData(data))))),
+			signRecipe: (recipe) => keyManager.keys$.pipe((0, rxjs.take)(1), (0, rxjs.switchMap)(({ unshieldedKeystore }) => (0, rxjs.from)(walletFacade.signRecipe(recipe, (data) => unshieldedKeystore.signData(data))))),
+			signData: (data) => keyManager.keys$.pipe((0, rxjs.take)(1), (0, rxjs.map)(({ unshieldedKeystore }) => ({
+				signature: unshieldedKeystore.signData(data),
+				verifyingKey: unshieldedKeystore.getPublicKey()
+			}))),
+			submitTransaction: (tx) => (0, rxjs.from)(walletFacade.submitTransaction(tx)),
+			transferTransaction: (outputs, { ttl, payFees }) => keyManager.keys$.pipe((0, rxjs.take)(1), (0, rxjs.switchMap)(({ walletKeys: { dustSecretKey, zswapSecretKeys } }) => (0, rxjs.from)(releasing.transferTransaction(outputs, {
+				shieldedSecretKeys: zswapSecretKeys,
+				dustSecretKey
+			}, {
+				ttl,
+				payFees
+			})))),
+			initSwap: (desiredInputs, desiredOutputs, { ttl, payFees }) => keyManager.keys$.pipe((0, rxjs.take)(1), (0, rxjs.switchMap)(({ walletKeys: { dustSecretKey, zswapSecretKeys } }) => (0, rxjs.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 rxjs.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, proofCircuitProvider, finalizeRecipe } = await getAccountWalletInstance(props, logger, options);
+			if (isDestroyed) {
+				facade.stop();
+				return;
+			}
+			walletFacade = facade;
+			await walletFacade.unshielded.start();
+			syncStartSubscription = keysWithAuthCancelledRecovery$(keyManager).pipe((0, rxjs.switchMap)((keys) => {
+				if (!walletFacade) return (0, rxjs.from)(Promise.resolve());
+				syncSecretKeys = _midnight_ntwrk_ledger_v8.ZswapSecretKeys.fromSeed(keys.walletKeys.zswapKeyBuffer);
+				syncDustSecretKey = _midnight_ntwrk_ledger_v8.DustSecretKey.fromSeed(keys.walletKeys.dustKeyBuffer);
+				const facade = walletFacade;
+				const syncKeys = syncSecretKeys;
+				const dustSyncKey = syncDustSecretKey;
+				return (0, rxjs.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 (0, rxjs.firstValueFrom)((0, rxjs.zip)((0, rxjs.from)(walletFacade.dust.serializeState()), (0, rxjs.from)(walletFacade.shielded.serializeState()), (0, rxjs.from)(walletFacade.unshielded.serializeState()), (0, rxjs.from)(txHistoryStorage.serialize())))).map(SerialisedWalletState);
+				const fingerprint = fingerprintOf([
+					dust,
+					shielded,
+					unshielded,
+					txHistory
+				]);
+				if (fingerprint === lastPersistedFingerprint) return;
+				if (isPersistenceHalted || isDestroyed) return;
+				await (0, rxjs.firstValueFrom)(store.upsert({
+					serializedState: {
+						dust,
+						shielded,
+						unshielded,
+						txHistory
+					},
+					accountId: account.accountId,
+					walletId: account.walletId,
+					networkId: account.blockchainSpecific.networkId
+				}).pipe((0, rxjs.defaultIfEmpty)(void 0)));
+				lastPersistedFingerprint = fingerprint;
+			};
+			persistSubscription = walletFacade.state().pipe((0, rxjs.throttleTime)(STATE_SERIALISATION_THROTTLE_TIME, void 0, {
+				leading: true,
+				trailing: true
+			}), (0, rxjs.exhaustMap)(() => (0, rxjs.from)(persistOnce()).pipe((0, rxjs.catchError)((error) => {
+				logger.error(`Failed to persist wallet state for account ${account.accountId}:`, error);
+				return (0, rxjs.of)(void 0);
+			})))).subscribe();
+			subscriber.next({
+				walletFacade,
+				haltPersistence: () => {
+					isPersistenceHalted = true;
+				},
+				proofCircuitProvider,
+				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((0, rxjs.switchMap)(({ walletFacade, haltPersistence, proofCircuitProvider, finalizeRecipe }) => createAccountObservableMidnightWallet({
+	account: props.account,
+	keyManager: props.keyManager,
+	walletFacade,
+	haltPersistence,
+	proofCircuitProvider,
+	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$ = require_midnight_wallet.midnightWalletsForRuntime(runtime);
+	return {
+		midnightWallets$,
+		wasmProofActivities$: rxjs.EMPTY,
+		dismissWasmProofActivity: () => void 0,
+		teeAttestationProgress$: require_send_proof_progress.teeAttestationProgress$,
+		getMidnightWalletByAccountId: (accountId) => midnightWallets$.pipe((0, rxjs.take)(1), (0, rxjs.map)((wallets) => wallets[accountId]), (0, rxjs.switchMap)((wallet) => wallet ? (0, rxjs.of)(wallet) : (0, rxjs.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 (0, rxjs.of)(void 0);
+			return (0, rxjs.forkJoin)(walletsArray.map((wallet) => wallet.stop())).pipe((0, rxjs.map)(() => void 0));
+		},
+		stopMidnightWallet: (accountId) => {
+			const wallet = midnightWallets$.value[accountId];
+			if (!wallet) return (0, rxjs.of)(void 0);
+			const { [accountId]: _, ...remaining } = midnightWallets$.value;
+			midnightWallets$.next(remaining);
+			return wallet.stop().pipe((0, rxjs.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 = require_token_id_vo.TokenId(require_utils.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 = require_token_id_vo.TokenId(require_utils.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: require_bignum_vo.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) ? require_activity_type.ActivityType.Receive : require_activity_type.ActivityType.Send;
+		case "FAILURE": return require_activity_type.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: require_activity_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: require_time_vo.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((0, rxjs.map)((loaded) => loaded.featureFlags.some((flag) => flag.key === require_watch.FEATURE_FLAG_MIDNIGHT_SHIELDED_ACTIVITY_ROWS)), (0, rxjs.distinctUntilChanged)());
+const updateActivities = (_, stateObservables, { actions, midnightWallets$ }) => midnightWallets$.pipe((0, rxjs.scan)((accumulator, wallets) => ({
+	current: wallets,
+	added: Object.values(wallets).filter((w) => !(w.accountId in accumulator.current))
+}), {
+	current: {},
+	added: []
+}), (0, rxjs.mergeMap)(({ added }) => added), (0, rxjs.mergeMap)((wallet) => (0, rxjs.combineLatest)([wallet.transactionHistory$, showShieldedOnlyRows$(stateObservables)]).pipe((0, rxjs.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)
+})), (0, rxjs.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
+	})
+]), (0, rxjs.takeUntil)(midnightWallets$.pipe((0, rxjs.filter)((wallets) => !(wallet.accountId in wallets)))))));
+const loadActivityDetails = ({ activities: { loadActivityDetails$ } }, _, { actions, getMidnightWalletByAccountId, logger }) => loadActivityDetails$.pipe((0, rxjs.filter)(({ payload: { blockchainName } }) => blockchainName === "Midnight"), (0, rxjs.map)((action) => action.payload.activity), (0, rxjs.switchMap)(({ activityId, accountId }) => getMidnightWalletByAccountId(accountId).pipe((0, rxjs.switchMap)((wallet) => wallet.getTransactionHistoryEntryByHash(activityId).pipe((0, rxjs.map)((txHistoryEntry) => {
+	if (!txHistoryEntry) return actions.activities.setActivityDetails({ activityDetails: void 0 });
+	return actions.activities.setActivityDetails({ activityDetails: mapTxHistoryEntryToActivityDetail({
+		accountId: wallet.accountId,
+		txHistoryEntry,
+		networkId: wallet.networkId
+	}) });
+}), (0, rxjs.catchError)((error) => {
+	logger.error("Failed to load Midnight activity details", error);
+	return rxjs.EMPTY;
+}))), (0, rxjs.catchError)(() => rxjs.EMPTY))));
+//#endregion
+//#region ../../packages/module/midnight-sync/src/store/side-effects/proof-activities.ts
+const watchProofActivities = (_actions, _state, { actions, wasmProofActivities$ }) => wasmProofActivities$.pipe((0, rxjs.map)((activities) => actions.midnightContext.proofActivitiesUpdated(activities)));
+const dismissProofActivity = ({ midnightContext: { proofActivityDismissRequested$ } }, _state, { dismissWasmProofActivity }) => proofActivityDismissRequested$.pipe((0, rxjs.tap)(({ payload }) => {
+	dismissWasmProofActivity(payload);
+}), (0, rxjs.ignoreElements)());
+//#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((0, rxjs.distinctUntilChanged)(lodash_isEqual.default), (0, rxjs.filter)((networkIds) => networkIds.length > 0), (0, rxjs.withLatestFrom)(selectNetworksConfig$, selectNetworksConfigFeatureFlagsOverrides$), (0, rxjs.mergeMap)(([networkIds, networksConfig, featureFlagsOverrides]) => (0, rxjs.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 }) => (0, rxjs.merge)(requestResync$.pipe((0, rxjs.withLatestFrom)(midnightAccount$), (0, rxjs.switchMap)(([_, accounts]) => {
+	return (0, rxjs.from)([...accounts.map(({ accountId }) => actions.sync.addSyncOperation({
+		accountId,
+		operation: {
+			operationId: `${accountId}-midnight-sync`,
+			status: "Pending",
+			description: "sync.operation.midnight-resync",
+			startedAt: require_time_vo.Timestamp(Date.now())
+		}
+	})), actions.midnightSync.resync()]);
+}))));
+const createClearWalletStateOnResync = (store) => withMidnightAccounts((midnightAccounts$) => ({ midnightSync: { resync$ } }, _, { actions, stopAllMidnightWallets, logger }) => resync$.pipe((0, rxjs.withLatestFrom)(midnightAccounts$), (0, rxjs.switchMap)(([_, midnightAccounts]) => stopAllMidnightWallets().pipe((0, rxjs.catchError)((error) => {
+	logger.error("Midnight resync: stop failed", error);
+	return (0, rxjs.of)(void 0);
+}), (0, rxjs.switchMap)(() => store.clear().pipe((0, rxjs.defaultIfEmpty)(void 0), (0, rxjs.catchError)((error) => {
+	logger.error("Midnight resync: state wipe failed", error);
+	return (0, rxjs.of)(void 0);
+}))), (0, rxjs.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((0, rxjs.withLatestFrom)(isUnlocked$), (0, rxjs.filter)(([_, isUnlocked]) => isUnlocked), (0, rxjs.switchMap)(() => selectCurrentNetwork$.pipe((0, rxjs.take)(1))), (0, rxjs.map)(({ config }) => config), (0, rxjs.distinctUntilChanged)(_laceio_cardano_util.deepEquals)).pipe((0, rxjs.withLatestFrom)(midnightAccounts$), (0, rxjs.switchMap)(([_, midnightAccounts]) => (0, rxjs.from)([...midnightAccounts.map(({ accountId }) => actions.sync.addSyncOperation({
+		accountId,
+		operation: {
+			operationId: `${accountId}-midnight-sync`,
+			status: "Pending",
+			description: "sync.operation.midnight-resync",
+			startedAt: require_time_vo.Timestamp(Date.now())
+		}
+	})), actions.midnightSync.resync()])));
+});
+const createDeleteWalletSideEffect = (storage) => ({ wallets: { removeWallet$ } }, { wallets: { selectAll$ } }, { stopMidnightWallet, actions, logger }) => removeWallet$.pipe((0, rxjs.withLatestFrom)(selectAll$.pipe((0, rxjs.map)((wallets) => wallets.filter(require_utils.hasMidnightAccount)))), (0, rxjs.switchMap)(([{ payload }, midnightWallets]) => {
+	const walletId = typeof payload === "string" ? payload : payload.walletId;
+	const targetWallet = midnightWallets.find((w) => w.walletId === walletId);
+	if (!targetWallet) return rxjs.EMPTY;
+	const allMidnightAccounts = targetWallet.accounts.filter(require_utils.isInMemoryMidnightAccount);
+	return (allMidnightAccounts.length > 0 ? (0, rxjs.forkJoin)(allMidnightAccounts.map(({ accountId }) => stopMidnightWallet(accountId))) : (0, rxjs.of)([])).pipe((0, rxjs.switchMap)(() => storage.removeWhere((wallet) => wallet.walletId === walletId).pipe((0, rxjs.defaultIfEmpty)(void 0), (0, rxjs.catchError)((error) => {
+		logger.error("Midnight delete wallet: state wipe failed", error);
+		return (0, rxjs.of)(void 0);
+	}))), (0, rxjs.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((0, rxjs.take)(1), (0, rxjs.throwIfEmpty)(() => /* @__PURE__ */ new Error("Midnight account stop did not acknowledge completion")), (0, rxjs.catchError)((error) => onStepFailure("stop", error)), (0, rxjs.switchMap)(() => store.removeWhere((wallet) => wallet?.accountId === accountId).pipe((0, rxjs.throwIfEmpty)(() => /* @__PURE__ */ new Error("Midnight account storage wipe did not acknowledge completion")), (0, rxjs.catchError)((error) => onStepFailure("wipe", error)))), (0, rxjs.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((0, rxjs.withLatestFrom)(midnightAccounts$), (0, rxjs.switchMap)(([{ payload }, midnightAccounts]) => {
+	const account = midnightAccounts.find(({ accountId }) => accountId === payload.accountId);
+	if (!account) return rxjs.EMPTY;
+	const { accountId } = account;
+	return (0, rxjs.concat)(stopAndWipeAccountState$({
+		accountId,
+		actions,
+		store,
+		stop$: stopMidnightWallet(accountId),
+		onStepFailure: (step, error) => {
+			logger.error(`Midnight reset sync state: ${step} failed`, error);
+			return (0, rxjs.of)(void 0);
+		}
+	}), (0, rxjs.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((0, rxjs.withLatestFrom)(midnightAccounts$), (0, rxjs.groupBy)(([{ payload }]) => payload.accountId), (0, rxjs.mergeMap)((requests$) => requests$.pipe((0, rxjs.exhaustMap)(([{ payload }, midnightAccounts]) => {
+	const account = midnightAccounts.find(({ accountId }) => accountId === payload.accountId);
+	if (!account) return rxjs.EMPTY;
+	const { accountId } = account;
+	const pendingOperation = () => actions.sync.addSyncOperation({
+		accountId,
+		operation: {
+			operationId: `${accountId}-midnight-sync`,
+			status: "Pending",
+			description: "sync.operation.midnight-resync",
+			startedAt: require_time_vo.Timestamp(Date.now())
+		}
+	});
+	const stop$ = (0, rxjs.merge)((0, rxjs.of)(void 0), requests$).pipe((0, rxjs.switchMap)(() => (0, rxjs.defer)(() => stopMidnightWallet(accountId)).pipe((0, rxjs.throwIfEmpty)(() => /* @__PURE__ */ new Error("Midnight account stop did not acknowledge completion")))));
+	return (0, rxjs.concat)((0, rxjs.of)(pendingOperation()), stopAndWipeAccountState$({
+		accountId,
+		actions,
+		store,
+		stop$,
+		onStepFailure: (step, error) => {
+			logger.error(`Midnight reset sync state: ${step} failed`, error);
+			return (0, rxjs.throwError)(() => error);
+		}
+	}), (0, rxjs.defer)(() => (0, rxjs.of)(pendingOperation(), actions.midnightSync.restartAccountWatch({ accountId })))).pipe((0, rxjs.catchError)((error) => {
+		logger.error("Midnight account resync failed", error);
+		const failedAt = require_time_vo.Timestamp(Date.now());
+		return (0, rxjs.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((0, rxjs.map)(({ payload }) => require_watch.MidnightSyncFailureId(payload.accountId)), require_auto_dismiss_failure_on_success.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((0, rxjs.withLatestFrom)(selectAll$), (0, rxjs.mergeMap)(([, wallets]) => (0, rxjs.from)(wallets.flatMap((wallet) => wallet.accounts).filter(require_utils.isInMemoryMidnightAccount).map((account) => require_watch.MidnightSyncFailureId(account.accountId)))), require_auto_dismiss_failure_on_success.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((0, rxjs.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((0, rxjs.filter)(({ payload: { config } }) => config.params.blockchainName === "Midnight" && config.type === "buildTx"), (0, rxjs.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 (0, rxjs.merge)(...[
+		updateActivities,
+		loadActivityDetails,
+		createDeleteWalletSideEffect(midnightStateStorage),
+		createClearWalletStateOnResync(midnightStateStorage),
+		requestResyncWallet,
+		autoDismissMidnightSyncFailureOnResume,
+		autoDismissMidnightSyncFailureOnSyncSuccess,
+		require_watch.watchMidnightAccounts(midnightStateStorage, require_watch.watchMidnightAccount),
+		...loadoutSideEffects(midnightStateStorage)
+	].map((sideEffect) => sideEffect(actionObservables, stateObservables, dependencies)));
+}];
+createInitializeSideEffects((storage) => [
+	createResetSyncStateSideEffect(storage),
+	resyncWalletOnConfigChangeFromFeatureFlags,
+	migrateUnavailableProofServerSelection,
+	watchProofActivities,
+	dismissProofActivity,
+	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 } = require_slice.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 }) => (0, rxjs.zip)(selectNetworksConfig$.pipe((0, rxjs.take)(1)), selectNetworksConfigFeatureFlagsOverrides$.pipe((0, rxjs.take)(1))).pipe((0, rxjs.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 || !require_const.MidnightSDKTestNetworkId.includes(networkId)) throw new Error(`createLaceWallet needs config.defaultMidnightTestnetNetworkId, the Midnight testnet a wallet starts on: one of ${require_const.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
+exports.createSdkStoreInit = createSdkStoreInit;