@laceio/sdk 0.1.1-canary.2 → 0.1.1

package/dist/sdk-init-BKkqFtWZ.cjs

@@ -1,3791 +0,0 @@
-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-DLrX5SD9.cjs");
-const require_watch = require("./watch-Cz1J42um.cjs");
-const require_slice = require("./slice-BOyAAaj0.cjs");
-const require_utils = require("./utils-BfMdr_1w.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-dDoqIohG.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 ../../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, 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) throw new Error(`Cannot start Midnight wallet: proof server mode "${config.proofServer.kind}" has no HTTP endpoint`);
-	require_const.assertProofServerRouting(config.proofServer, !!createAttestedProver);
-	const createAccess = (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,
-					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,
-				proofServerTransport: proofServer.transport,
-				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,
-			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,
-		proofServerTransport: proofServer.transport,
-		finalizeRecipe
-	};
-};
-/**
-* Creates an observable MidnightWallet from wallet instances.
-*
-* The nightVerifyingKey is obtained from the wallet state, which works
-* for both restored and new wallets.
-*/
-const createAccountObservableMidnightWallet = ({ account, keyManager, walletFacade, haltPersistence, proofServerTransport, finalizeRecipe }) => {
-	const { networkId } = account.blockchainSpecific;
-	const state$ = walletFacade.state().pipe((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,
-			proofServerTransport,
-			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, proofServerTransport, 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;
-				},
-				proofServerTransport,
-				finalizeRecipe
-			});
-		};
-		init().catch((error) => {
-			subscriber.error(error);
-		});
-		return () => {
-			isDestroyed = true;
-			syncStartSubscription?.unsubscribe();
-			persistSubscription?.unsubscribe();
-			if (walletFacade) walletFacade.stop().catch(() => void 0).finally(() => {
-				syncSecretKeys?.clear();
-				syncDustSecretKey?.clear();
-			});
-		};
-	});
-};
-/**
-* Starts a Midnight account wallet with full lifecycle management.
-*
-* Creates SDK wallets, manages their start/stop lifecycle, and converts
-* to the MidnightWallet interface used by the rest of the application.
-*/
-const createStartMidnightAccountWallet = (dependencies, options) => (props) => createAndManageWallets(props, dependencies, options).pipe((0, rxjs.switchMap)(({ walletFacade, haltPersistence, proofServerTransport, finalizeRecipe }) => createAccountObservableMidnightWallet({
-	account: props.account,
-	keyManager: props.keyManager,
-	walletFacade,
-	haltPersistence,
-	proofServerTransport,
-	finalizeRecipe
-})));
-/**
-* The engine's side-effect dependencies. The attested prover is the
-* loadout's: the app proves through the bundled Temenos deployment, which a
-* headless loadout does not ship.
-*/
-const createMidnightSideEffectDependencies = (options = {}) => ({ runtime }, dependencies) => {
-	const midnightWallets$ = require_midnight_wallet.midnightWalletsForRuntime(runtime);
-	return {
-		midnightWallets$,
-		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-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,
-	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;