@laceio/sdk 0.1.1 → 0.1.2-canary.1

package/dist/dist-Dcsxh3be.cjs

@@ -0,0 +1,3452 @@
+const require_rolldown_runtime = require("./rolldown-runtime-Br2OG8yv.cjs");
+const require__polyfill_buffer_patch = require("./_polyfill-buffer-patch-CM8X7JiY.cjs");
+require("./bn-d3nSOIf7.cjs");
+require("./client-DXBLHk7K.cjs");
+const require_dist = require("./dist-BMi5ZjEq.cjs");
+let rxjs = require("rxjs");
+rxjs = require_rolldown_runtime.__toESM(rxjs);
+let _midnight_ntwrk_ledger_v8 = require("@midnight-ntwrk/ledger-v8");
+_midnight_ntwrk_ledger_v8 = require_rolldown_runtime.__toESM(_midnight_ntwrk_ledger_v8);
+let _midnightntwrk_ledger_v9 = require("@midnightntwrk/ledger-v9");
+_midnightntwrk_ledger_v9 = require_rolldown_runtime.__toESM(_midnightntwrk_ledger_v9);
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-shielded/dist/ShieldedWalletAPI.js
+var ShieldedWalletState = class ShieldedWalletState {
+	/**
+	* Wraps a state emission with the capabilities of the variant that produced it.
+	*
+	* @remarks
+	*   Call this inside a branch that has narrowed on the emission's `variantTag`, so `variant` and `state` are known to
+	*   belong together. It is generic over the state type precisely so that pairing is checked.
+	*/
+	static fromVariant = (variant, state) => new ShieldedWalletState(state.version, state.state, {
+		balances: () => variant.coinsAndBalances.getAvailableBalances(state.state),
+		totalCoins: () => variant.coinsAndBalances.getTotalCoins(state.state),
+		availableCoins: () => variant.coinsAndBalances.getAvailableCoins(state.state),
+		pendingCoins: () => variant.coinsAndBalances.getPendingCoins(state.state),
+		coinPublicKey: () => variant.keys.getCoinPublicKey(state.state),
+		encryptionPublicKey: () => variant.keys.getEncryptionPublicKey(state.state),
+		address: () => variant.keys.getAddress(state.state),
+		serialize: () => variant.serialization.serialize(state.state)
+	});
+	protocolVersion;
+	state;
+	#projections;
+	get balances() {
+		return this.#projections.balances();
+	}
+	get totalCoins() {
+		return this.#projections.totalCoins();
+	}
+	get availableCoins() {
+		return this.#projections.availableCoins();
+	}
+	get pendingCoins() {
+		return this.#projections.pendingCoins();
+	}
+	get coinPublicKey() {
+		return this.#projections.coinPublicKey();
+	}
+	get encryptionPublicKey() {
+		return this.#projections.encryptionPublicKey();
+	}
+	get address() {
+		return this.#projections.address();
+	}
+	get progress() {
+		return this.state.progress;
+	}
+	constructor(protocolVersion, state, projections) {
+		this.protocolVersion = protocolVersion;
+		this.state = state;
+		this.#projections = projections;
+	}
+	serialize() {
+		return this.#projections.serialize();
+	}
+};
+/**
+* The protocol version a ledger-v9-native chain hands over at.
+*
+* @deprecated Use {@link ProtocolVersion.V9NativeForkVersion} from `@midnightntwrk/wallet-sdk-abstractions` (or the
+*   umbrella package) — the value is a property of the chain, not of the shielded wallet, and lives with the version
+*   type now. This alias is the same value and will be removed in a later release.
+*/
+const V9_NATIVE_FORK_VERSION = require_dist.V9NativeForkVersion;
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-shielded/dist/Restore.js
+var Restore_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	UnsupportedSnapshotVersionError: () => UnsupportedSnapshotVersionError,
+	peekProtocolVersion: () => peekProtocolVersion,
+	variantForSnapshot: () => variantForSnapshot
+});
+/**
+* Raised when a snapshot declares a protocol version that no registered variant is able to read.
+*
+* @remarks
+*   A wallet built for one range of protocol versions cannot invent a reader for a snapshot written outside it, and
+*   guessing — handing the bytes to whichever variant happens to be registered — would decode them with the wrong
+*   ledger. The version is carried on the error so an application can say which one it was.
+*/
+var UnsupportedSnapshotVersionError = class extends require_dist.TaggedError("@midnightntwrk/wallet-sdk-shielded/Restore/UnsupportedSnapshotVersionError") {};
+/**
+* The envelope the peek reads.
+*
+* @remarks
+*   Deliberately the smallest possible description of a snapshot: one optional field, every other ignored. It has to read
+*   snapshots written by _any_ variant, including ones whose full schema this build does not have, so it must not
+*   assert anything it does not need. Everything it cannot make sense of is reported as "no version declared", leaving
+*   the real diagnosis to the deserializer that eventually reads the whole thing.
+*/
+const EnvelopeSchema = require_dist.Struct({ protocolVersion: require_dist.optional(require_dist.ProtocolVersionSchema) });
+/**
+* Reads the protocol version a serialized wallet snapshot declares.
+*
+* @param serialized The serialized wallet state.
+* @returns The declared version, or `Option.none()` when the snapshot declares none or cannot be read at all.
+*/
+const peekProtocolVersion = (serialized) => require_dist.decodeUnknownOption(require_dist.parseJson(EnvelopeSchema))(serialized).pipe(require_dist.flatMap$3((envelope) => require_dist.fromNullable(envelope.protocolVersion)));
+/**
+* Chooses the variant that should read a serialized wallet snapshot.
+*
+* @remarks
+*   A snapshot that declares no version predates snapshots declaring one, and can only have been written by the variant
+*   that shipped before the question arose — the head variant. The same fallback covers an envelope this function
+*   cannot read at all: refusing it here would replace the deserializer's precise error with a vaguer one.
+* @param serialized The serialized wallet state.
+* @param variantFor Resolves the variant registered for a protocol version.
+* @param headVariant The variant a snapshot with no declared version is restored into.
+* @returns The variant to restore with, or {@link UnsupportedSnapshotVersionError} when the declared version is one no
+*   registered variant owns.
+*/
+const variantForSnapshot = (serialized, variantFor, headVariant) => require_dist.match$1(peekProtocolVersion(serialized), {
+	onNone: () => require_dist.right(headVariant),
+	onSome: (protocolVersion) => require_dist.fromOption(variantFor(protocolVersion), () => new UnsupportedSnapshotVersionError({
+		message: `No registered variant reads shielded wallet snapshots of protocol version ${protocolVersion}.`,
+		protocolVersion
+	}))
+});
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v2/WalletError.js
+const WalletError$1 = {
+	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$1({
+			message: `Other wallet error: ${message}`,
+			cause: err
+		});
+	},
+	submission(err) {
+		return new SubmissionError$1({
+			message: `Transaction submission error: ${err && typeof err == "object" && "message" in err ? String(err.message) : ""}`,
+			cause: err
+		});
+	}
+};
+var OtherWalletError$1 = class extends require_dist.TaggedError("Wallet.Other") {};
+var SyncWalletError$1 = class extends require_dist.TaggedError("Wallet.Sync") {};
+var SubmissionError$1 = class extends require_dist.TaggedError("Wallet.SubmissionWalletError") {};
+var InsufficientFundsError$1 = class extends require_dist.TaggedError("Wallet.InsufficientFunds") {};
+var InvalidCoinHashesError$1 = class extends require_dist.TaggedError("Wallet.InvalidCoinHashes") {};
+var TransactionHistoryError$1 = class extends require_dist.TaggedError("Wallet.TransactionHistory") {};
+/**
+* A batch of zswap ledger events was not in ascending id order: an event arrived at or below the one before it, or at
+* or below the applied cursor.
+*
+* @remarks
+*   Order is all the wallet can check: zswap events share one id sequence with dust and contract events in the indexer,
+*   so gaps in the stream are normal and a skipped event is only ever caught by the ledger's own insertion check. The
+*   whole batch is refused, nothing is applied and the cursor stays, so the running variant retries from the same
+*   place.
+* @example
+*   ```ts
+*   if (error._tag === 'Wallet.OutOfOrderSyncUpdate') console.warn(`expected above ${error.expected}, got ${error.received}`);
+*   ```
+*/
+var OutOfOrderSyncUpdateError$1 = class extends require_dist.TaggedError("Wallet.OutOfOrderSyncUpdate") {};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v2/CoreWallet.js
+const PublicKeys$1 = { fromSecretKeys: (secretKeys) => {
+	return {
+		coinPublicKey: secretKeys.coinPublicKey,
+		encryptionPublicKey: secretKeys.encryptionPublicKey
+	};
+} };
+const CoinHashesMap$1 = {
+	empty: {},
+	pickAllCoins(state) {
+		return [...state.coins, ...state.pendingOutputs.values().map(([coin]) => coin)];
+	},
+	assertValid(map$8, state) {
+		const coins = CoinHashesMap$1.pickAllCoins(state);
+		const coinNonces = new Set(require_dist.map$4(coins, (coin) => coin.nonce));
+		const definedNonces = new Set(Object.keys(map$8));
+		const missingNonces = coinNonces.difference(definedNonces);
+		return missingNonces.size === 0 ? require_dist.void_ : require_dist.left(missingNonces);
+	},
+	updateWithCoins(secretKeys, existing, coins) {
+		return require_dist.fromIterableWith(coins, (coin) => [coin.nonce, existing[coin.nonce] ?? {
+			commitment: _midnightntwrk_ledger_v9.coinCommitment(coin, secretKeys.coinPublicKey),
+			nullifier: _midnightntwrk_ledger_v9.coinNullifier(coin, secretKeys.coinSecretKey)
+		}]);
+	},
+	updateWithNewCoins(secretKeys, existing, coins) {
+		const newMap = CoinHashesMap$1.updateWithCoins(secretKeys, CoinHashesMap$1.empty, coins);
+		return require_dist.union$2(existing, newMap, (a) => a);
+	},
+	init(secretKeys, coins) {
+		return CoinHashesMap$1.updateWithCoins(secretKeys, {}, coins);
+	}
+};
+/**
+* Releases every coin reservation a wallet carried across the ledger-version boundary.
+*
+* @remarks
+*   `pendingSpends` crosses with the rest of the local state, and on the far side its entries name transactions of a
+*   ledger version the chain has left behind: none of them can be included, so no inclusion will ever clear them, and a
+*   coin held for one would sit outside the available set for the rest of the wallet's life. Re-deriving each spend and
+*   reporting it failed is the ledger's own way of un-booking one: the reservation goes, and the coin stays at the
+*   Merkle index the chain gave it, in a tree of unchanged height and root.
+* @param state The local state as it crossed.
+* @param secretKeys The keys the first sync update arrived with.
+* @returns The same state with nothing reserved.
+*/
+const releaseStrandedSpends = (state, secretKeys) => require_dist.pipe([...state.pendingSpends.values()], require_dist.reduce(state, (released, [coin]) => require_dist.pipe(require_dist.ledgerTry(() => {
+	const [reserved, input] = released.spend(secretKeys, coin, 0);
+	return reserved.applyFailed(_midnightntwrk_ledger_v9.ZswapOffer.fromInput(input, coin.type, coin.value));
+}), require_dist.getOrElse$1(() => released))));
+const CoreWallet$1 = {
+	init(localState, secretKeys, networkId) {
+		return {
+			state: localState,
+			publicKeys: PublicKeys$1.fromSecretKeys(secretKeys),
+			networkId,
+			coinHashes: CoinHashesMap$1.init(secretKeys, CoinHashesMap$1.pickAllCoins(localState)),
+			progress: require_dist.createSyncProgress(),
+			protocolVersion: require_dist.MinSupportedVersion
+		};
+	},
+	empty(publicKeys, networkId) {
+		return {
+			state: new _midnightntwrk_ledger_v9.ZswapLocalState(),
+			publicKeys,
+			networkId,
+			coinHashes: CoinHashesMap$1.empty,
+			progress: require_dist.createSyncProgress(),
+			protocolVersion: require_dist.MinSupportedVersion
+		};
+	},
+	restore(localState, secretKeys, syncProgress, protocolVersion, networkId) {
+		return {
+			state: localState,
+			publicKeys: PublicKeys$1.fromSecretKeys(secretKeys),
+			networkId,
+			coinHashes: CoinHashesMap$1.init(secretKeys, CoinHashesMap$1.pickAllCoins(localState)),
+			progress: require_dist.createSyncProgress(syncProgress),
+			protocolVersion: require_dist.ProtocolVersion(protocolVersion)
+		};
+	},
+	restoreWithCoinHashes(publicKeys, localState, coinHashes, syncProgress, protocolVersion, networkId) {
+		return CoinHashesMap$1.assertValid(coinHashes, localState).pipe(require_dist.mapBoth({
+			onLeft: (missingNonces) => new InvalidCoinHashesError$1({
+				message: "Missing coin hashes for coins present in the state",
+				missingNonces
+			}),
+			onRight: () => ({
+				state: localState,
+				publicKeys,
+				networkId,
+				coinHashes,
+				progress: require_dist.createSyncProgress(syncProgress),
+				protocolVersion: require_dist.ProtocolVersion(protocolVersion)
+			})
+		}));
+	},
+	restoreWithPendingCoinHashes(publicKeys, localState, syncProgress, protocolVersion, networkId) {
+		return {
+			state: localState,
+			publicKeys,
+			networkId,
+			coinHashes: CoinHashesMap$1.empty,
+			coinHashesPending: true,
+			progress: require_dist.createSyncProgress(syncProgress),
+			protocolVersion: require_dist.ProtocolVersion(protocolVersion)
+		};
+	},
+	initEmpty(keys, networkId) {
+		return this.empty(PublicKeys$1.fromSecretKeys(keys), networkId);
+	},
+	withProtocolVersion(wallet, version) {
+		return version > wallet.protocolVersion ? {
+			...wallet,
+			protocolVersion: version
+		} : wallet;
+	},
+	fromPreviousVersion(previous) {
+		return {
+			state: previous.state,
+			publicKeys: previous.publicKeys,
+			networkId: previous.networkId,
+			coinHashes: CoinHashesMap$1.empty,
+			coinHashesPending: true,
+			progress: require_dist.createSyncProgress({
+				...previous.progress,
+				isConnected: false
+			}),
+			protocolVersion: require_dist.ProtocolVersion(previous.protocolVersion)
+		};
+	},
+	completeCrossing(wallet, secretKeys) {
+		return wallet.coinHashesPending === void 0 ? wallet : CoreWallet$1.resolveCoinHashes({
+			...wallet,
+			state: releaseStrandedSpends(wallet.state, secretKeys)
+		}, secretKeys);
+	},
+	resolveCoinHashes(wallet, secretKeys) {
+		return wallet.coinHashesPending === void 0 ? wallet : {
+			state: wallet.state,
+			publicKeys: wallet.publicKeys,
+			networkId: wallet.networkId,
+			coinHashes: CoinHashesMap$1.init(secretKeys, CoinHashesMap$1.pickAllCoins(wallet.state)),
+			progress: wallet.progress,
+			protocolVersion: wallet.protocolVersion
+		};
+	},
+	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$1.updateWithCoins(secretKeys, wallet.coinHashes, CoinHashesMap$1.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$1.updateWithCoins(secretKeys, wallet.coinHashes, CoinHashesMap$1.pickAllCoins(newState));
+		return [{
+			...wallet,
+			state: newState,
+			coinHashes: newCoinHashes
+		}, stateWithChanges.changes];
+	},
+	updateProgress(wallet, { appliedIndex, highestRelevantWalletIndex, highestIndex, highestRelevantIndex, isConnected }) {
+		const updatedProgress = require_dist.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_dist.pipe(coins, require_dist.reduce([[], wallet.state], ([accOffers, localState], coinToSpend) => {
+			const [nextState, newInput] = localState.spend(secretKeys, coinToSpend, segment);
+			const inputOffer = _midnightntwrk_ledger_v9.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$1.updateWithNewCoins(secretKeys, wallet.coinHashes, coins);
+		return {
+			...wallet,
+			state: newLocalState,
+			coinHashes: newCoinHashes
+		};
+	}
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v2/Migration.js
+/**
+* The migration used when there is no previous wallet at all.
+*
+* @remarks
+*   It backs `WalletLike.startEmpty`, which builds a wallet before any key material exists. The resulting state has no
+*   coins and public keys derived from a fixed placeholder seed; it is a scaffold to be replaced by a real start, not a
+*   wallet anybody can transact with. Preserved verbatim from the ledger-v8 implementation so that `startEmpty` behaves
+*   exactly as it did.
+* @example
+*   ```typescript
+*   const builder = new V2Builder().withDefaults().withMigration(makeEmptyWalletMigration({ networkId }));
+*   ```;
+*
+* @param configuration Supplies the network the scaffold state claims to be on.
+* @returns A migration from `null`.
+*/
+const makeEmptyWalletMigration$1 = (configuration) => ({ migrate: () => {
+	const seed = require_dist.fromString("0000000000000000000000000000000000000000000000000000000000000001");
+	return require_dist.succeed(CoreWallet$1.empty(PublicKeys$1.fromSecretKeys(_midnightntwrk_ledger_v9.ZswapSecretKeys.fromSeed(seed)), configuration.networkId));
+} });
+/**
+* The migration across a ledger-version boundary: the local state crosses as bytes, identity and position beside it.
+*
+* @remarks
+*   The chain's state translation carries every commitment across the fork in place — the ledger-v9 tree continues at the
+*   index the ledger-v8 tree reached, and the indexer does **not** replay the ledger-v8 timeline as new-version events.
+*   So the wallet's own state must cross with it, or the coins are gone.
+*
+*   It crosses as bytes. The two ledger majors either side of this boundary serialize `ZswapLocalState` under the same
+*   `zswap-local-state` codec — the transaction codec moved at the fork, this one did not — so the previous version's
+*   serialization is something this version can simply read. The crossing is therefore a round-trip and not a
+*   reconstruction, and everything survives it: the coins at the Merkle indices the chain gave them, the height the
+*   tree had reached, and the outputs the wallet was still expecting, which no reconstruction from spendable coins
+*   could have recovered. `src/v2/test/byteCrossing.test.ts` pins that codec against both real ledgers, and states what
+*   to do if it ever goes red.
+*
+*   **The coins booked for transactions still in flight cross too, and are released at the first sync update.** Those
+*   transactions belong to the ledger version the chain has left behind, so none of them can ever be included and no
+*   inclusion will ever clear the reservations they left in `pendingSpends` — the coins would simply stop being
+*   spendable. The release cannot happen here, because un-booking a spend needs the secret keys a migration is by
+*   design handed none of; it happens at the first sync update instead, which is where keys and carried state meet
+*   (`CoreWallet.completeCrossing`). The change outputs those same transactions would have paid back are left as they
+*   are, and nothing ever removes them: these entries carry no TTL and `ZswapLocalState.clearPending` does nothing in
+*   either ledger, so they sit in `pendingOutputs` for the life of the wallet. A known limitation, and a mild one —
+*   they overstate the pending balance, but they reserve no coin and block no spending.
+*
+*   Read through `LedgerOps.ledgerTry`, so a codec that has moved is a `WalletError` at the boundary and never a throw:
+*   the failure mode of a future major moving `zswap-local-state` is loud, and lands here, where the
+*   {@link StateMigration} seam can be given the ledger team's own translation instead.
+*
+*   Sync progress is **parked at the fork** rather than rewound: the indexer numbers ledger-v9 events onwards from
+*   whatever id it had reached when the fork happened, never from zero, so the inherited cursor is exactly where this
+*   wallet's reading resumes. A wallet that rewound to zero would wait on a stretch of the timeline this ledger
+*   version's events do not occupy.
+* @returns A migration from a previous-ledger-version wallet.
+*/
+const makeCrossLedgerMigration = () => ({ migrate: (previousState) => require_dist.pipe(require_dist.ledgerTry(() => _midnightntwrk_ledger_v9.ZswapLocalState.deserialize(previousState.state.serialize())), require_dist.map$6((state) => CoreWallet$1.fromPreviousVersion({
+	state,
+	publicKeys: previousState.publicKeys,
+	networkId: previousState.networkId,
+	protocolVersion: previousState.protocolVersion,
+	progress: previousState.progress
+})), require_dist.toEffect) });
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v2/RunningV2Variant.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_dist.ProgressUpdate({
+		sourceGap,
+		applyGap
+	})];
+};
+/**
+* Reports the protocol version a state observation implies, if any.
+*
+* @remarks
+*   Two situations call for a signal. The ordinary one is a transition: sync annotated the state with a version it did
+*   not have before, and the runtime decides whether that is a re-annotation inside this variant's range or a hand-over
+*   to the next one.
+*
+*   The other is a state that arrives already outside this variant's range — a snapshot serialized in the window between
+*   the annotation and the migration it should have caused, or one written by an older protocol version entirely.
+*   Nothing further will change that value, so waiting for a transition would strand the wallet on a version it does
+*   not own. Emitting on sight heals it.
+*/
+const protocolVersionChange$1 = (previous, current, isInitial, activationRange) => {
+	const transitioned = previous.protocolVersion != current.protocolVersion;
+	const strandedOutsideRange = isInitial && !require_dist.withinRange(current.protocolVersion, activationRange);
+	return transitioned || strandedOutsideRange ? [require_dist.VersionChange({ change: require_dist.Version({ version: require_dist.ProtocolVersion(current.protocolVersion) }) })] : [];
+};
+const V2Tag = Symbol("V2");
+var RunningV2Variant = class {
+	__polyTag__ = V2Tag;
+	#scope;
+	#context;
+	#v2Context;
+	#txHistoryPermits = require_dist.makeSemaphore(8).pipe(require_dist.runSync);
+	state;
+	constructor(scope, context, v2Context) {
+		this.#scope = scope;
+		this.#context = context;
+		this.#v2Context = v2Context;
+		this.state = require_dist.fromEffect(context.stateRef.get).pipe(require_dist.flatMap((initialState) => context.stateRef.changes.pipe(require_dist.mapAccum({
+			previous: initialState,
+			isInitial: true
+		}, (seen, current) => [{
+			previous: current,
+			isInitial: false
+		}, [
+			seen.previous,
+			current,
+			seen.isInitial
+		]]))), require_dist.mapConcat(([previous, current, isInitial]) => {
+			return [
+				require_dist.State({ state: current }),
+				...progress$1(current),
+				...protocolVersionChange$1(previous, current, isInitial, context.activationRange)
+			];
+		}));
+	}
+	startSyncInBackground(startAux) {
+		return this.startSync(startAux).pipe(require_dist.runScoped(require_dist.drain), require_dist.forkScoped, require_dist.provideService(require_dist.Scope, this.#scope));
+	}
+	startSync(startAux) {
+		return require_dist.pipe(require_dist.get(this.#context.stateRef), require_dist.fromEffect, require_dist.flatMap((state) => this.#v2Context.syncService.updates(state, startAux)), require_dist.mapEffect((update) => require_dist.modifyEffect(this.#context.stateRef, (state) => require_dist.try_({
+			try: () => {
+				const [newState, changesResult] = this.#v2Context.syncCapability.applyUpdate(state, update, this.#context.activationRange);
+				return [changesResult, newState];
+			},
+			catch: (err) => new OtherWalletError$1({
+				message: "Error while applying sync update",
+				cause: err
+			})
+		})).pipe(require_dist.flatMap$1(({ changes, protocolVersion }) => changes.length === 0 ? require_dist._void : require_dist.pipe(require_dist.forEach(changes, (change) => require_dist.pipe(this.#txHistoryPermits.withPermits(1)(require_dist.pipe(this.#v2Context.transactionHistoryService.getTransactionDetails(change.source), require_dist.flatMap$1((metadata) => this.#v2Context.transactionHistoryService.put(change, metadata, protocolVersion)))), require_dist.catchAllCause((cause) => require_dist.logError(cause, `Failed to record shielded tx-history section for ${change.source}`))), {
+			discard: true,
+			concurrency: 8
+		}), require_dist.forkScoped)), require_dist.provideService(require_dist.Scope, this.#scope))), require_dist.tapError((error$2) => require_dist.error(error$2)), require_dist.retry(require_dist.pipe(require_dist.exponential(require_dist.seconds(1), 2), require_dist.map$1((delay) => {
+			const maxDelay = require_dist.minutes(2);
+			const jitter = require_dist.millis(Math.floor(Math.random() * 1e3));
+			const delayWithJitter = require_dist.toMillis(delay) + require_dist.toMillis(jitter);
+			return require_dist.millis(Math.min(delayWithJitter, require_dist.toMillis(maxDelay)));
+		}))));
+	}
+	balanceTransaction(secretKeys, tx) {
+		return require_dist.modifyEffect(this.#context.stateRef, (state) => {
+			return require_dist.pipe(this.#v2Context.transactingCapability.balanceTransaction(secretKeys, state, tx), require_dist.toEffect);
+		});
+	}
+	transferTransaction(secretKeys, outputs) {
+		return require_dist.modifyEffect(this.#context.stateRef, (state) => {
+			return require_dist.pipe(this.#v2Context.transactingCapability.makeTransfer(secretKeys, state, outputs), require_dist.toEffect);
+		});
+	}
+	initSwap(secretKeys, desiredInputs, desiredOutputs) {
+		return require_dist.modifyEffect(this.#context.stateRef, (state) => {
+			return require_dist.pipe(this.#v2Context.transactingCapability.initSwap(secretKeys, state, desiredInputs, desiredOutputs), require_dist.toEffect);
+		});
+	}
+	revertTransaction(transaction) {
+		return require_dist.updateEffect(this.#context.stateRef, (state) => {
+			return require_dist.pipe(this.#v2Context.transactingCapability.revertTransaction(state, transaction), require_dist.toEffect);
+		});
+	}
+	serializeState(state) {
+		return this.#v2Context.serializationCapability.serialize(state);
+	}
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v2/Serialization.js
+const StateSchema$1 = require_dist.declare((input) => input instanceof _midnightntwrk_ledger_v9.ZswapLocalState).annotations({ identifier: "ledger.ZswapLocalState" });
+const Uint8ArraySchema$3 = require_dist.declare((input) => input instanceof Uint8Array).annotations({ identifier: "Uint8Array" });
+const StateFromUInt8Array$1 = () => require_dist.asSchema(require_dist.transformOrFail(Uint8ArraySchema$3, StateSchema$1, {
+	encode: (state) => {
+		return require_dist.try_({
+			try: () => {
+				return state.serialize();
+			},
+			catch: (err) => {
+				return new require_dist.Unexpected(err, "Could not serialize local state");
+			}
+		});
+	},
+	decode: (bytes) => require_dist.try_({
+		try: () => _midnightntwrk_ledger_v9.ZswapLocalState.deserialize(bytes),
+		catch: (err) => {
+			return new require_dist.Unexpected(err, "Could not deserialize local state");
+		}
+	})
+}));
+const HexedState$1 = () => require_dist.pipe(require_dist.Uint8ArrayFromHex, require_dist.compose(StateFromUInt8Array$1()));
+const makeDefaultV2SerializationCapability = () => {
+	const SnapshotSchema = require_dist.Struct({
+		publicKeys: require_dist.Struct({
+			coinPublicKey: require_dist.String$,
+			encryptionPublicKey: require_dist.String$
+		}),
+		state: HexedState$1(),
+		protocolVersion: require_dist.BigInt$,
+		offset: require_dist.optional(require_dist.BigInt$),
+		networkId: require_dist.String$,
+		coinHashes: require_dist.Record({
+			key: require_dist.String$,
+			value: require_dist.Struct({
+				nullifier: require_dist.String$,
+				commitment: require_dist.String$
+			})
+		}),
+		coinHashesPending: require_dist.optional(require_dist.Literal(true))
+	});
+	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,
+				...w.coinHashesPending !== void 0 ? { coinHashesPending: w.coinHashesPending } : {}
+			});
+			return require_dist.pipe(wallet, buildSnapshot, require_dist.encodeSync(SnapshotSchema), JSON.stringify);
+		},
+		deserialize: (aux, serialized) => {
+			return require_dist.pipe(serialized, require_dist.decodeUnknownEither(require_dist.parseJson(SnapshotSchema)), require_dist.mapLeft((err) => WalletError$1.other(err)), require_dist.flatMap$4((snapshot) => {
+				const progress = {
+					appliedIndex: snapshot.offset ?? 0n,
+					highestRelevantWalletIndex: 0n,
+					highestIndex: 0n,
+					highestRelevantIndex: 0n,
+					isConnected: false
+				};
+				return snapshot.coinHashesPending === true ? require_dist.right(CoreWallet$1.restoreWithPendingCoinHashes(snapshot.publicKeys, snapshot.state, progress, snapshot.protocolVersion, snapshot.networkId)) : CoreWallet$1.restoreWithCoinHashes(snapshot.publicKeys, snapshot.state, snapshot.coinHashes, progress, snapshot.protocolVersion, snapshot.networkId);
+			}));
+		}
+	};
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v2/Sync.js
+/**
+* Splits a batch of version-tagged items at the end of a variant's activation range.
+*
+* @remarks
+*   The split is positional, not a filter: everything from the first out-of-range item onwards is deferred, even if a
+*   later item reports an in-range version again. A batch is a contiguous slice of one timeline, so applying past a
+*   boundary and then resuming behind it would leave a hole no cursor can describe.
+*
+*   This is the one place the boundary rule lives; both the indexer capability (per event) and the simulator capability
+*   (per block) go through it, so they cannot drift apart.
+* @param items The batch, in source order.
+* @param versionOf Reads the protocol version an item was reported at.
+* @param activeRange The variant's half-open activation range.
+* @returns The applied/deferred split and the version to record.
+*/
+const splitAtVersionBoundary$1 = (items, versionOf, activeRange) => {
+	const [, end] = activeRange;
+	const boundary = items.findIndex((item) => BigInt(versionOf(item)) >= end);
+	const [applied, deferred] = boundary < 0 ? [items, []] : [items.slice(0, boundary), items.slice(boundary)];
+	const signalling = deferred.at(0) ?? applied.at(-1);
+	return {
+		applied,
+		deferred,
+		observedVersion: signalling === void 0 ? require_dist.none() : require_dist.some(require_dist.ProtocolVersion(BigInt(versionOf(signalling))))
+	};
+};
+/**
+* Checks that freshly delivered events arrive in strictly ascending id order.
+*
+* @remarks
+*   Order is all that can be checked, never contiguity: zswap events share one id sequence with dust and contract events
+*   in the indexer, so gaps in a zswap stream are normal. A skipped commitment-inserting event is caught by the
+*   ledger's own insertion check instead. An empty batch is trivially ordered.
+* @param fresh The events left after the cursor filter, in source order.
+* @param appliedIndex The highest event id already applied; the first fresh id must exceed it.
+* @returns The batch unchanged, or the first id that fails to exceed its predecessor as an
+*   {@link OutOfOrderSyncUpdateError}.
+*/
+const expectAscending$1 = (fresh, appliedIndex) => require_dist.pipe(require_dist.zipWith(fresh, require_dist.prepend(require_dist.map$3(fresh, (item) => BigInt(item.id)), appliedIndex), (item, previous) => ({
+	item,
+	previous
+})), require_dist.findFirst(({ item, previous }) => BigInt(item.id) <= previous), require_dist.match$1({
+	onNone: () => require_dist.right(fresh),
+	onSome: ({ item, previous }) => require_dist.left(new OutOfOrderSyncUpdateError$1({
+		message: `Zswap event ${item.id} delivered at or below its predecessor ${previous}; batch refused, applied index stays at ${appliedIndex}`,
+		expected: previous,
+		received: BigInt(item.id)
+	}))
+}));
+/** Records a batch's observed protocol version on the state, monotonically. A batch that observed none is a no-op. */
+const annotateVersion$1 = (state, observedVersion) => require_dist.match$1(observedVersion, {
+	onNone: () => state,
+	onSome: (version) => CoreWallet$1.withProtocolVersion(state, version)
+});
+const Uint8ArraySchema$2 = require_dist.declare((input) => input instanceof Uint8Array).annotations({ identifier: "Uint8Array" });
+const VersionSignalSyncUpdate$1 = { create: (version, highestEventId) => {
+	return {
+		_tag: "VersionSignal",
+		version,
+		highestEventId
+	};
+} };
+const WalletSyncUpdate$1 = { create: (updates, secretKeys) => {
+	return {
+		_tag: "Events",
+		updates,
+		secretKeys
+	};
+} };
+const LedgerEventSchema$1 = require_dist.declare((input) => input instanceof _midnightntwrk_ledger_v9.Event).annotations({ identifier: "ledger.Event" });
+const LedgerEventFromUint8Array$1 = require_dist.transformOrFail(Uint8ArraySchema$2, LedgerEventSchema$1, {
+	encode: (event) => require_dist.try_({
+		try: () => event.serialize(),
+		catch: (error) => new require_dist.Unexpected(error, "Could not serialize ledger event")
+	}),
+	decode: (bytes) => require_dist.try_({
+		try: () => _midnightntwrk_ledger_v9.Event.deserialize(bytes),
+		catch: (error) => new require_dist.Unexpected(error, "Could not deserialize ledger event")
+	})
+});
+const HexedLedgerEvent$1 = require_dist.pipe(require_dist.Uint8ArrayFromHex, require_dist.compose(LedgerEventFromUint8Array$1));
+const EventsSyncUpdatePayload$1 = require_dist.Struct({
+	id: require_dist.Number$,
+	raw: require_dist.String$,
+	protocolVersion: require_dist.Number$,
+	maxId: require_dist.Number$
+});
+/**
+* One event of the source's timeline, still encoded.
+*
+* @remarks
+*   The event is carried as the source served it rather than as a `ledger.Event`, because whether this ledger version may
+*   read it at all is not the source's question to answer. A batch spanning a protocol boundary carries events of the
+*   version that follows this one, which this ledger version cannot deserialize — the serialization header names a
+*   different version — and after a hand-over the inclusive cursor re-delivers an event of the version that preceded
+*   it, which it equally cannot. Both are ordinary, and neither is an error: they belong to the variant either side.
+*
+*   So the bytes travel undecoded and only the capability, which knows the activation range, reads the ones it is about
+*   to apply — see {@link readEvent}. Decoding here would fail the whole batch on an event nobody intended to apply.
+*/
+const EventsSyncUpdate$1 = require_dist.TaggedStruct("EventsSyncUpdate", {
+	id: require_dist.Number$,
+	protocolVersion: require_dist.Number$,
+	maxId: require_dist.Number$,
+	raw: require_dist.String$
+});
+const EventsSyncUpdateFromPayload$1 = require_dist.transform(EventsSyncUpdatePayload$1, EventsSyncUpdate$1, {
+	strict: true,
+	decode: (input) => ({
+		_tag: "EventsSyncUpdate",
+		id: input.id,
+		protocolVersion: input.protocolVersion,
+		maxId: input.maxId,
+		raw: input.raw
+	}),
+	encode: (update) => ({
+		id: update.id,
+		raw: update.raw,
+		protocolVersion: update.protocolVersion,
+		maxId: update.maxId
+	})
+});
+/**
+* Reads an event this variant is going to apply.
+*
+* @remarks
+*   The counterpart of {@link EventsSyncUpdate} carrying its event encoded: a capability calls this on the batch prefix it
+*   owns, and never on what it defers. Failure here is a genuine one — an event this variant claimed and cannot read —
+*   and is raised rather than returned, because `SyncCapability.applyUpdate` is total in its own domain and the variant
+*   already turns a throw from it into a typed synchronization error.
+* @param update The update to read.
+* @returns The event it carries.
+* @throws ParseError if the bytes are not an event this ledger version can deserialize.
+*/
+const readEvent$1 = (update) => require_dist.decodeSync(HexedLedgerEvent$1)(update.raw);
+/** How often the chain is asked its version when the configuration does not say. */
+const DEFAULT_VERSION_WATCH_INTERVAL_MS$1 = 3e4;
+/**
+* How long one event-id probe is given to produce its single answer.
+*
+* @remarks
+*   Only a stall guard. The probe subscribes at a cursor whose event provably exists, so the answer arrives at once or
+*   the transport is broken; without a bound, a half-open socket would leave the poll loop parked on a tick that never
+*   completes and the wallet would stop asking altogether. A bound turns that into a skipped tick.
+*/
+const EVENT_TIP_PROBE_TIMEOUT$1 = require_dist.seconds(10);
+/**
+* Asks the source how far its zswap event timeline goes.
+*
+* @remarks
+*   Over the event subscription rather than a query, because the schema has no query that reaches a zswap ledger event:
+*   `block`/`transactions` reach one only through a block that happens to contain zswap events, which on a quiet chain
+*   is precisely the block that does not. `maxId` is a property of the whole timeline, so any single event answers it —
+*   the first one delivered is taken and the subscription closed.
+*
+*   The cursor is the wallet's own. The event it last applied provably exists, so the source answers immediately and has
+*   the least backfill to abandon; a wallet that has applied nothing asks from the start, where the first event is.
+* @param config The sync configuration, for the keep-alive the source's subscriptions use.
+* @param url Where to subscribe.
+* @param resumeFrom The wallet's cursor; below zero means "from the very start".
+* @returns The highest event id, or nothing if the source did not answer.
+*/
+const highestEventId$1 = (config, url, resumeFrom) => require_dist.pipe(require_dist.ZswapEventTip.run({ id: resumeFrom < 0n ? null : Number(resumeFrom) }), require_dist.runHead, require_dist.map$2(require_dist.map$5((answer) => answer.zswapLedgerEvents.maxId)), require_dist.provide(require_dist.layer({
+	url,
+	keepAlive: config.indexerClientConnection.keepAlive
+})), require_dist.scoped, require_dist.timeout(EVENT_TIP_PROBE_TIMEOUT$1));
+/**
+* One check of the chain's protocol version, gated on the wallet being caught up on the source's event ids.
+*
+* @remarks
+*   The order of the two questions is load-bearing. The tip is read **first**: a tip reported at a version means the
+*   source has indexed through the block that carries it, so every event below it is already counted in the `maxId`
+*   read afterwards. Asked the other way round, an event indexed between the two answers could be one of the version
+*   that preceded the tip — unread, uncounted, and exactly what the gate exists to catch.
+*
+*   Two short-circuits, both of them answers rather than shortcuts. A tip at or below the version the wallet already held
+*   is a signal that could only be a no-op, so no probe is opened and nothing is emitted — which is what keeps a
+*   settled wallet from polling a subscription for the rest of its life. And a tip whose commitment tree has never
+*   grown cannot have had a nullifier spent against it either, so such a chain provably holds no zswap event: nothing
+*   can be unread, and the signal goes out with `null`.
+*
+*   Everything else is swallowed. A tick that fails says nothing about the chain, so it must neither reach the state nor
+*   take the sync stream down with it; the next tick is the retry, and costs nothing to wait for.
+* @param config The sync configuration, for the indexer to ask.
+* @param url Where to run the event-id probe.
+* @param resumeFrom The wallet's cursor, for the probe.
+* @param knownVersion The version the wallet already held when this stream opened — a lower bound on what it holds now.
+* @returns The signal, or nothing when there is nothing to say or nobody said it.
+*/
+const readVersionSignal$1 = (config, url, resumeFrom, knownVersion) => require_dist.pipe(require_dist.BlockHash.run({ offset: null }), require_dist.provide(require_dist.layer$1({ url: config.indexerClientConnection.indexerHttpUrl })), require_dist.scoped, require_dist.flatMap$1((answer) => require_dist.match$1(require_dist.fromNullable(answer.block), {
+	onNone: () => require_dist.succeedNone,
+	onSome: (tip) => BigInt(tip.protocolVersion) <= knownVersion ? require_dist.succeedNone : tip.zswapEndIndex === 0 ? require_dist.succeedSome(VersionSignalSyncUpdate$1.create(tip.protocolVersion, null)) : require_dist.pipe(highestEventId$1(config, url, resumeFrom), require_dist.map$2(require_dist.map$5((maxId) => VersionSignalSyncUpdate$1.create(tip.protocolVersion, maxId))))
+})), require_dist.catchAll(() => require_dist.succeedNone));
+/**
+* The chain's version, re-asked on a timer for as long as sync runs.
+*
+* @remarks
+*   Deliberately silent about ticks that say nothing: a tick that finds the chain where the wallet left it, or that
+*   cannot reach the chain at all, emits no element rather than an empty one, so nothing downstream has to know that
+*   polling is how the answer was arrived at.
+* @param config The sync configuration, carrying the interval.
+* @param url Where to run the event-id probe.
+* @param resumeFrom The wallet's cursor, for the probe.
+* @param knownVersion The version the wallet held when this stream opened.
+* @returns The signals, or an empty stream when watching is turned off.
+*/
+const versionWatch$1 = (config, url, resumeFrom, knownVersion) => {
+	const intervalMs = config.versionWatch?.intervalMs ?? DEFAULT_VERSION_WATCH_INTERVAL_MS$1;
+	return intervalMs <= 0 ? require_dist.empty : require_dist.pipe(require_dist.fromSchedule(require_dist.spaced(require_dist.millis(intervalMs))), require_dist.mapEffect(() => readVersionSignal$1(config, url, resumeFrom, knownVersion)), require_dist.filterMap(require_dist.identity));
+};
+const makeEventsSyncService$1 = (config) => {
+	return { updates: (state, secretKeys) => {
+		const { indexerClientConnection } = config;
+		const webSocketUrlResult = require_dist.createWebSocketUrl(indexerClientConnection.indexerHttpUrl, indexerClientConnection.indexerWsUrl);
+		if (require_dist.isLeft(webSocketUrlResult)) return require_dist.fail(new SyncWalletError$1(/* @__PURE__ */ new Error(`Could not derive WebSocket URL from indexer HTTP URL: ${webSocketUrlResult.left.message}`)));
+		const indexerWsUrlResult = require_dist.make(webSocketUrlResult.right);
+		if (require_dist.isLeft(indexerWsUrlResult)) return require_dist.fail(new SyncWalletError$1(/* @__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_dist.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_dist.pipe(require_dist.ZswapEvents.runWithBackpressure({
+			bufferSize,
+			resumeThreshold,
+			from: resumeFrom,
+			variables: (cursor) => ({ id: cursor < 0n ? null : Number(cursor) }),
+			key: (r) => BigInt(r.zswapLedgerEvents.id)
+		}), require_dist.provideLayer(require_dist.layer({
+			url: indexerWsUrl,
+			keepAlive: config.indexerClientConnection.keepAlive
+		})), require_dist.mapError((error) => new SyncWalletError$1(error)), require_dist.mapEffect((subscription) => require_dist.pipe(subscription.zswapLedgerEvents, require_dist.decodeUnknownEither(EventsSyncUpdateFromPayload$1), require_dist.mapLeft((err) => new SyncWalletError$1(err)), require_dist.toEffect)), require_dist.groupedWithin(batchSize, batchTimeout), require_dist.map(require_dist.toArray), require_dist.map((data) => WalletSyncUpdate$1.create(data, secretKeys)));
+		const timeline = batchSpacing > 0 ? require_dist.schedule(eventsStream, require_dist.spaced(require_dist.millis(batchSpacing))) : eventsStream;
+		return require_dist.merge(timeline, versionWatch$1(config, indexerWsUrl, resumeFrom, state.protocolVersion), { haltStrategy: "left" });
+	} };
+};
+/** The result of an update that observed nothing of the chain. */
+const noChanges$1 = (state) => ({
+	changes: [],
+	protocolVersion: Number(state.protocolVersion)
+});
+/**
+* Folds what the chain said about its own version into the wallet state.
+*
+* @remarks
+*   The same recording the event path makes through {@link annotateVersion}, and nothing else: no cursor moves, no coin
+*   changes hands, no tree grows. A signal is an observation about the chain, not a piece of it — which is also why it
+*   does not resolve pending coin hashes: it carries no keys, and the first batch of the timeline does.
+*
+*   One situation makes the observation unsafe to record, and it leaves the state exactly as it was: unread events below
+*   the source's tip mean the hand-over would park the cursor in front of history the next variant cannot read — and
+*   those events carry the version themselves, so nothing is lost by waiting for them. Not an error: the next tick asks
+*   again.
+*
+*   A version at or below the one already recorded needs no guard of its own — {@link annotateVersion} never goes
+*   backwards — so a source briefly answering from a lagging replica cannot drag a wallet back over a boundary.
+* @param wallet The wallet to record on.
+* @param update What the chain said, and how far its event timeline goes.
+* @returns The wallet, annotated or untouched, and an empty result.
+*/
+const applyVersionSignal$1 = (wallet, update) => {
+	const appliedIndex = wallet.progress?.appliedIndex ?? 0n;
+	return [update.highestEventId !== null && BigInt(update.highestEventId) > appliedIndex ? wallet : annotateVersion$1(wallet, require_dist.some(require_dist.ProtocolVersion(BigInt(update.version)))), noChanges$1(wallet)];
+};
+const makeEventsSyncCapability$1 = () => {
+	return { applyUpdate: (wallet, wrappedUpdate, activeRange) => {
+		if (wrappedUpdate._tag === "VersionSignal") return applyVersionSignal$1(wallet, wrappedUpdate);
+		const state = CoreWallet$1.completeCrossing(wallet, wrappedUpdate.secretKeys);
+		if (wrappedUpdate.updates.length === 0) return [state, noChanges$1(state)];
+		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 { applied, observedVersion } = splitAtVersionBoundary$1(require_dist.getOrThrowWith(expectAscending$1(freshUpdates, appliedIndex), require_dist.identity), (update) => update.protocolVersion, activeRange);
+		const [newState, newChanges] = applied.length === 0 ? [state, []] : CoreWallet$1.replayEventsWithChanges(state, wrappedUpdate.secretKeys, applied.map(readEvent$1));
+		return [CoreWallet$1.updateProgress(annotateVersion$1(newState, observedVersion), {
+			highestRelevantWalletIndex,
+			appliedIndex: applied.length === 0 ? appliedIndex : BigInt(applied.at(-1).id),
+			isConnected: true
+		}), {
+			changes: newChanges,
+			protocolVersion: applied.at(-1)?.protocolVersion ?? Number(state.protocolVersion)
+		}];
+	} };
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v2/TransactionImbalances.js
+const ShieldedCostModel$1 = {
+	inputFeeOverhead: 0n,
+	outputFeeOverhead: 0n
+};
+const TransactionImbalances$1 = new class {
+	empty = () => {
+		return {
+			guaranteed: require_dist.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 ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v2/TransactionOps.js
+const TransactionOps$1 = new class {
+	default = {
+		getImbalances(tx) {
+			return TransactionOps$1.shared.getImbalances(tx);
+		},
+		id(tx) {
+			return tx.identifiers().at(0);
+		}
+	};
+	proofErased = {
+		getImbalances(tx) {
+			return TransactionOps$1.shared.getImbalances(tx);
+		},
+		id(tx) {
+			return tx.identifiers().at(0);
+		}
+	};
+	unproven = {
+		getImbalances(tx) {
+			return TransactionOps$1.shared.getImbalances(tx);
+		},
+		id(tx) {
+			return tx.identifiers().at(0);
+		}
+	};
+	shared = {
+		getImbalances(tx) {
+			return {
+				guaranteed: TransactionOps$1.shared.getGuaranteedImbalances(tx),
+				fallible: TransactionOps$1.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_dist.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_dist.Imbalances.fromEntries(rawImbalances)]];
+			});
+			return new Map(fallibleImbalances);
+		}
+	};
+}();
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v2/Transacting.js
+const makeDefaultTransactingCapability$1 = (config, getContext) => {
+	return new TransactingCapabilityImplementation$1(config.networkId, () => getContext().coinSelection, () => getContext().coinsAndBalancesCapability, () => getContext().keysCapability, TransactionOps$1.default);
+};
+var TransactingCapabilityImplementation$1 = 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_dist.gen$1(this, function* () {
+			const coinSelection = this.getCoinSelection();
+			const initialImbalances = this.txOps.getImbalances(tx);
+			if (TransactionImbalances$1.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_dist.Imbalances.empty());
+			return [Array.from(fallibleOffers.entries()).reduce((tx, [segment, offer]) => tx.addZswapOffer({
+				tag: "specific",
+				value: segment
+			}, offer), _midnightntwrk_ledger_v9.Transaction.fromParts(this.networkId, guaranteed)), afterGuaranteed];
+		});
+	}
+	makeTransfer(secretKeys, state, transfers) {
+		return require_dist.gen$1(this, function* () {
+			const positiveTransfers = yield* require_dist.pipe(transfers, require_dist.filter$1((t) => t.amount > 0n), require_dist.match({
+				onEmpty: () => require_dist.left(new OtherWalletError$1({ message: "The amount needs to be positive" })),
+				onNonEmpty: (nonEmpty) => require_dist.right(nonEmpty)
+			}));
+			const networkId = this.networkId;
+			const { initialOffersAndCoins, selfCoins } = yield* this.#processDesiredOutputs(state, positiveTransfers);
+			const offerToBalance = require_dist.pipe(initialOffersAndCoins, require_dist.map$3((o) => o.outputOffer), require_dist.fold((a, b) => a.merge(b)));
+			const unprovenTxToBalance = _midnightntwrk_ledger_v9.Transaction.fromParts(networkId, offerToBalance);
+			const imbalances = TransactionOps$1.unproven.getImbalances(unprovenTxToBalance);
+			const { offer, newState } = yield* this.#balanceGuaranteedSection(secretKeys, state, imbalances, this.getCoinSelection(), require_dist.Imbalances.empty());
+			const finalState = CoreWallet$1.watchCoins(newState, secretKeys, selfCoins);
+			return [unprovenTxToBalance.merge(_midnightntwrk_ledger_v9.Transaction.fromParts(networkId, offer)), finalState];
+		});
+	}
+	initSwap(secretKeys, state, desiredInputs, desiredOutputs) {
+		return require_dist.gen$1(this, function* () {
+			if (!desiredOutputs.every((output) => output.amount > 0n)) return yield* require_dist.left(new OtherWalletError$1({ message: "The amount needs to be positive" }));
+			if (!Object.entries(desiredInputs).every(([, amount]) => amount > 0n)) return yield* require_dist.left(new OtherWalletError$1({ message: "The input amounts need to be positive" }));
+			const outputsParseResult = yield* this.#processDesiredOutputsPossiblyEmpty(state, desiredOutputs);
+			const inputsParseResult = require_dist.Imbalances.fromEntries(require_dist.toEntries(desiredInputs));
+			const networkId = this.networkId;
+			const { offer, newState } = yield* this.#balanceGuaranteedSection(secretKeys, state, TransactionImbalances$1.empty(), this.getCoinSelection(), inputsParseResult);
+			const finalState = CoreWallet$1.watchCoins(newState, secretKeys, outputsParseResult.selfCoins);
+			const balancingTx = _midnightntwrk_ledger_v9.Transaction.fromParts(networkId, offer);
+			return [outputsParseResult.unprovenTxToBalance ? outputsParseResult.unprovenTxToBalance.merge(balancingTx) : balancingTx, finalState];
+		});
+	}
+	revertTransaction(state, transaction) {
+		return require_dist.try_$1({
+			try: () => {
+				return CoreWallet$1.revertTransaction(state, transaction);
+			},
+			catch: (err) => {
+				return new OtherWalletError$1({
+					message: `Error while reverting transaction ${transaction.identifiers().at(0)}`,
+					cause: err
+				});
+			}
+		});
+	}
+	#prepareOffer(secretKeys, state, recipe, segment) {
+		const [inputOffers, stateAfterSpends] = CoreWallet$1.spendCoins(state, secretKeys, recipe.inputs, segment);
+		const stateAfterWatches = CoreWallet$1.watchCoins(stateAfterSpends, secretKeys, recipe.outputs);
+		const outputOffers = recipe.outputs.map((coin) => {
+			const output = _midnightntwrk_ledger_v9.ZswapOutput.new(coin, segment, this.getKeys().getCoinPublicKey(state).toHexString(), this.getKeys().getEncryptionPublicKey(state).toHexString());
+			return _midnightntwrk_ledger_v9.ZswapOffer.fromOutput(output, coin.type, coin.value);
+		});
+		return require_dist.pipe(require_dist.appendAll(inputOffers, outputOffers), require_dist.match({
+			onEmpty: () => require_dist.none(),
+			onNonEmpty: (nonEmpty) => require_dist.pipe(nonEmpty, require_dist.fold((a, b) => a.merge(b)), require_dist.some)
+		}), require_dist.map$5((offer) => ({
+			offer,
+			newState: stateAfterWatches
+		})));
+	}
+	balanceFallibleSection(secretKeys, state, imbalances, coinSelection) {
+		return Array.from(imbalances.fallible.entries()).reduce((acc, [segment, segmentImbalances]) => require_dist.flatMap$4(acc, ({ fallibleOffers, newState }) => require_dist.pipe(require_dist.try_$1({
+			try: () => {
+				const fallibleBalanceRecipe = require_dist.getBalanceRecipe({
+					coins: this.getCoins().getAvailableCoins(newState).map((c) => c.coin),
+					initialImbalances: segmentImbalances,
+					transactionCostModel: ShieldedCostModel$1,
+					feeTokenType: "",
+					coinSelection,
+					createOutput: (coin) => _midnightntwrk_ledger_v9.createShieldedCoinInfo(coin.type, coin.value),
+					isCoinEqual: (a, b) => a.nonce === b.nonce
+				});
+				return this.#prepareOffer(secretKeys, newState, fallibleBalanceRecipe, segment);
+			},
+			catch: (err) => {
+				if (err instanceof require_dist.InsufficientFundsError) return new InsufficientFundsError$1({
+					message: `Insufficient funds for fallible segment ${segment}`,
+					tokenType: err.tokenType,
+					amount: segmentImbalances.get(err.tokenType) ?? 0n
+				});
+				return new OtherWalletError$1({
+					message: `Balancing fallible segment ${segment} failed`,
+					cause: err
+				});
+			}
+		}), require_dist.map$6(require_dist.match$1({
+			onNone: () => ({
+				fallibleOffers,
+				newState
+			}),
+			onSome: (res) => ({
+				fallibleOffers: new Map([...fallibleOffers, [segment, res.offer]]),
+				newState: res.newState
+			})
+		})))), require_dist.right({
+			fallibleOffers: /* @__PURE__ */ new Map(),
+			newState: state
+		}));
+	}
+	#balanceGuaranteedSection(secretKeys, state, imbalances, coinSelection, targetImbalances) {
+		return require_dist.gen$1(this, function* () {
+			const balanceRecipe = yield* require_dist.try_$1({
+				try: () => require_dist.getBalanceRecipe({
+					coins: this.getCoins().getAvailableCoins(state).map((c) => c.coin),
+					initialImbalances: imbalances.guaranteed,
+					transactionCostModel: ShieldedCostModel$1,
+					feeTokenType: "",
+					coinSelection,
+					createOutput: (coin) => _midnightntwrk_ledger_v9.createShieldedCoinInfo(coin.type, coin.value),
+					isCoinEqual: (a, b) => a.nonce === b.nonce,
+					targetImbalances
+				}),
+				catch: (err) => {
+					if (err instanceof require_dist.InsufficientFundsError) return new InsufficientFundsError$1({
+						message: "Insufficient funds",
+						tokenType: err.tokenType,
+						amount: imbalances.guaranteed.get(err.tokenType) ?? 0n
+					});
+					else return new OtherWalletError$1({
+						message: "Balancing guaranteed section failed",
+						cause: err
+					});
+				}
+			});
+			return require_dist.pipe(this.#prepareOffer(secretKeys, state, balanceRecipe, 0), require_dist.match$1({
+				onNone: () => ({
+					offer: void 0,
+					newState: state
+				}),
+				onSome: (result) => result
+			}));
+		});
+	}
+	#processDesiredOutputs(state, transfers) {
+		return require_dist.try_$1({
+			try: () => {
+				const initialOffersAndCoins = require_dist.pipe(transfers, require_dist.map$3((transfer) => {
+					const { receiverAddress, type, amount } = transfer;
+					const coin = _midnightntwrk_ledger_v9.createShieldedCoinInfo(type, amount);
+					const output = _midnightntwrk_ledger_v9.ZswapOutput.new(coin, 0, receiverAddress.coinPublicKey.toHexString(), receiverAddress.encryptionPublicKey.toHexString());
+					return {
+						coin,
+						outputOffer: _midnightntwrk_ledger_v9.ZswapOffer.fromOutput(output, type, amount),
+						isForSelf: receiverAddress.coinPublicKey.equals(this.getKeys().getCoinPublicKey(state))
+					};
+				}));
+				return {
+					initialOffersAndCoins,
+					selfCoins: require_dist.flatMap$2(initialOffersAndCoins, ({ coin, isForSelf }) => {
+						if (isForSelf) return [coin];
+						else return [];
+					})
+				};
+			},
+			catch: (err) => {
+				return new OtherWalletError$1({
+					message: "Failed to process desired outputs",
+					cause: err
+				});
+			}
+		});
+	}
+	#processDesiredOutputsPossiblyEmpty(state, desiredOutputs) {
+		return require_dist.pipe(desiredOutputs, require_dist.match({
+			onEmpty: () => {
+				return require_dist.right({
+					imbalances: TransactionImbalances$1.empty(),
+					selfCoins: [],
+					unprovenTxToBalance: null
+				});
+			},
+			onNonEmpty: (desiredOutputs) => {
+				return require_dist.pipe(this.#processDesiredOutputs(state, desiredOutputs), require_dist.map$6(({ initialOffersAndCoins, selfCoins }) => {
+					const networkId = this.networkId;
+					const offerToBalance = require_dist.pipe(initialOffersAndCoins, require_dist.map$3((o) => o.outputOffer), require_dist.fold((a, b) => a.merge(b)));
+					const unprovenTxToBalance = _midnightntwrk_ledger_v9.Transaction.fromParts(networkId, offerToBalance);
+					return {
+						imbalances: TransactionOps$1.unproven.getImbalances(unprovenTxToBalance),
+						selfCoins,
+						unprovenTxToBalance
+					};
+				}));
+			}
+		}));
+	}
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v2/CoinsAndBalances.js
+const calculateBalances$1 = (coins) => coins.reduce((acc, { coin }) => ({
+	...acc,
+	[coin.type]: acc[coin.type] === void 0 ? coin.value : acc[coin.type] + coin.value
+}), {});
+const makeDefaultCoinsAndBalancesCapability$1 = () => {
+	const getAvailableBalances = (state) => {
+		return calculateBalances$1(getAvailableCoins(state));
+	};
+	const getPendingBalances = (state) => {
+		return calculateBalances$1(getPendingCoins(state));
+	};
+	const getTotalBalances = (state) => {
+		return require_dist.pipe([getAvailableBalances(state), getPendingBalances(state)], require_dist.mergeWithAccumulator(0n, (a, b) => a + b));
+	};
+	const getAvailableCoins = (state) => {
+		const pendingSpends = new Set([...state.state.pendingSpends.values()].map(([coin]) => coin.nonce));
+		return require_dist.pipe([...state.state.coins], require_dist.filter$1((coin) => !pendingSpends.has(coin.nonce)), require_dist.filterMap$1((coin) => require_dist.pipe(require_dist.fromNullable(state.coinHashes[coin.nonce]), require_dist.map$5(({ commitment, nullifier }) => ({
+			coin,
+			commitment,
+			nullifier
+		})))));
+	};
+	const getPendingCoins = (state) => require_dist.pipe([...state.state.pendingOutputs.values()], require_dist.filterMap$1(([coin, ttl]) => require_dist.pipe(require_dist.fromNullable(state.coinHashes[coin.nonce]), require_dist.map$5(({ commitment, nullifier }) => ({
+		coin,
+		ttl,
+		commitment,
+		nullifier
+	})))));
+	const getTotalCoins = (state) => [...getAvailableCoins(state), ...getPendingCoins(state)];
+	return {
+		getAvailableBalances,
+		getPendingBalances,
+		getTotalBalances,
+		getAvailableCoins,
+		getPendingCoins,
+		getTotalCoins
+	};
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v2/Keys.js
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+const makeDefaultKeysCapability$1 = () => {
+	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 ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v2/TransactionHistory.js
+const QualifiedShieldedCoinInfoSchema$1 = require_dist.Struct({
+	type: require_dist.String$,
+	nonce: require_dist.String$,
+	value: require_dist.BigInt$,
+	mtIndex: require_dist.BigInt$
+});
+const ShieldedSectionSchema = require_dist.Struct({
+	receivedCoins: require_dist.Array$(QualifiedShieldedCoinInfoSchema$1),
+	spentCoins: require_dist.Array$(QualifiedShieldedCoinInfoSchema$1)
+});
+require_dist.extendEntrySchema({ shielded: require_dist.optional(ShieldedSectionSchema) });
+const coinEquals$1 = require_dist.equivalence(QualifiedShieldedCoinInfoSchema$1);
+const mergeShieldedSections = (existing, incoming) => ({
+	receivedCoins: require_dist.unionWith(existing.receivedCoins, incoming.receivedCoins, coinEquals$1),
+	spentCoins: require_dist.unionWith(existing.spentCoins, incoming.spentCoins, coinEquals$1)
+});
+const convertUpdateToFinalizedInput$1 = (changes, metadata, protocolVersion) => ({
+	hash: changes.source,
+	protocolVersion,
+	status: metadata.status,
+	identifiers: metadata.identifiers,
+	finalizedBlock: {
+		hash: metadata.block.hash,
+		height: metadata.block.height,
+		timestamp: new Date(metadata.block.timestamp)
+	},
+	shielded: {
+		receivedCoins: changes.receivedCoins.map(({ mt_index, ...rest }) => ({
+			...rest,
+			mtIndex: mt_index
+		})),
+		spentCoins: changes.spentCoins.map(({ mt_index, ...rest }) => ({
+			...rest,
+			mtIndex: mt_index
+		}))
+	}
+});
+const gotFinalizedShielded$1 = (txHistoryStorage, input) => require_dist.tryPromise({
+	try: () => txHistoryStorage.gotFinalized(input),
+	catch: (e) => new TransactionHistoryError$1({
+		message: `Failed to record finalized history entry for ${input.hash}`,
+		cause: e
+	})
+});
+const makeDefaultTransactionHistoryService$1 = (config, _getContext) => {
+	const txHistoryStorage = config.txHistoryStorage;
+	const queryClientLayer = require_dist.layer$1({ url: config.indexerClientConnection.indexerHttpUrl });
+	const retryWindow = config.transactionDetailsRetryWindow ?? require_dist.minutes(2);
+	return {
+		put: (changes, metadata, protocolVersion) => gotFinalizedShielded$1(txHistoryStorage, convertUpdateToFinalizedInput$1(changes, metadata, protocolVersion)),
+		getTransactionDetails: (hash) => require_dist.gen(function* () {
+			const result = yield* (yield* require_dist.TransactionHistoryDetail)({ transactionHash: hash });
+			const tx = yield* require_dist.head$1(result.transactions).pipe(require_dist.orElseFail(() => new TransactionHistoryError$1({ message: `Indexer has not yet indexed transaction ${hash}` })));
+			const rawStatus = tx.__typename === "RegularTransaction" ? tx.transactionResult.status : void 0;
+			const status = rawStatus === "FAILURE" || rawStatus === "PARTIAL_SUCCESS" ? rawStatus : "SUCCESS";
+			const identifiers = tx.__typename === "RegularTransaction" ? tx.identifiers : [];
+			return {
+				hash: tx.hash,
+				block: {
+					hash: tx.block.hash,
+					height: tx.block.height,
+					timestamp: tx.block.timestamp
+				},
+				status,
+				identifiers
+			};
+		}).pipe(require_dist.provide(queryClientLayer), require_dist.scoped, require_dist.retry$1({
+			schedule: require_dist.exponential(require_dist.seconds(1)).pipe(require_dist.either(require_dist.spaced(require_dist.seconds(10))), require_dist.jittered, require_dist.upTo(retryWindow)),
+			while: (error) => error instanceof TransactionHistoryError$1
+		}), require_dist.mapError$2((error) => error instanceof TransactionHistoryError$1 ? error : new TransactionHistoryError$1({
+			message: `Failed to fetch transaction metadata for ${hash}`,
+			cause: error
+		})))
+	};
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v2/V2Builder.js
+var V2Builder = class V2Builder {
+	#buildState;
+	constructor(buildState = {}) {
+		this.#buildState = buildState;
+	}
+	withDefaults() {
+		return this.withDefaultTransactionType().withSyncDefaults().withSerializationDefaults().withTransactingDefaults().withCoinsAndBalancesDefaults().withTransactionHistoryDefaults().withKeysDefaults().withStartAuxDefaults().withCoinSelectionDefaults();
+	}
+	withTransactionType() {
+		return new V2Builder({
+			...this.#buildState,
+			transactingCapability: void 0,
+			transactionHistoryService: void 0
+		});
+	}
+	withDefaultTransactionType() {
+		return this.withTransactionType();
+	}
+	withSyncDefaults() {
+		return this.withSync(makeEventsSyncService$1, makeEventsSyncCapability$1);
+	}
+	withSync(syncService, syncCapability) {
+		return new V2Builder({
+			...this.#buildState,
+			syncService,
+			syncCapability,
+			startAux: void 0
+		});
+	}
+	withSerializationDefaults() {
+		return this.withSerialization(makeDefaultV2SerializationCapability);
+	}
+	withSerialization(serializationCapability) {
+		return new V2Builder({
+			...this.#buildState,
+			serializationCapability
+		});
+	}
+	withTransactingDefaults() {
+		return this.withTransacting(makeDefaultTransactingCapability$1);
+	}
+	withTransacting(transactingCapability) {
+		return new V2Builder({
+			...this.#buildState,
+			transactingCapability
+		});
+	}
+	withCoinSelection(coinSelection) {
+		return new V2Builder({
+			...this.#buildState,
+			coinSelection
+		});
+	}
+	withCoinSelectionDefaults() {
+		return this.withCoinSelection(() => require_dist.chooseCoin);
+	}
+	withCoinsAndBalancesDefaults() {
+		return this.withCoinsAndBalances(makeDefaultCoinsAndBalancesCapability$1);
+	}
+	withCoinsAndBalances(coinsAndBalancesCapability) {
+		return new V2Builder({
+			...this.#buildState,
+			coinsAndBalancesCapability
+		});
+	}
+	withTransactionHistoryDefaults() {
+		return this.withTransactionHistory(makeDefaultTransactionHistoryService$1);
+	}
+	withTransactionHistory(transactionHistoryService) {
+		return new V2Builder({
+			...this.#buildState,
+			transactionHistoryService
+		});
+	}
+	withKeysDefaults() {
+		return this.withKeys(makeDefaultKeysCapability$1);
+	}
+	/**
+	* Uses the default start-aux derivation: this ledger version's Zswap secret keys, derived from the seed.
+	*
+	* @remarks
+	*   The seed is the only key material that crosses a protocol boundary, so every variant must be able to produce its
+	*   own from one. This is that derivation for this ledger version; a builder whose sync service expects something
+	*   else supplies its own with {@link V2Builder.withStartAux}.
+	*/
+	withStartAuxDefaults() {
+		return this.withStartAux({ fromSeed: (seed) => _midnightntwrk_ledger_v9.ZswapSecretKeys.fromSeed(seed) });
+	}
+	/**
+	* Chooses how this variant derives the key material its synchronization is started with from a seed.
+	*
+	* @param startAux The derivation.
+	* @returns A builder that produces a variant able to start sync from a seed alone.
+	*/
+	withStartAux(startAux) {
+		return new V2Builder({
+			...this.#buildState,
+			startAux
+		});
+	}
+	/**
+	* Uses the default migration: an empty wallet built from nothing.
+	*
+	* @remarks
+	*   This is what an unconfigured builder already does, so calling it changes no behaviour — it states the choice rather
+	*   than inheriting it. Registering this variant as the target of a real fork means calling
+	*   {@link V2Builder.withMigration} with {@link makeCrossLedgerMigration} instead.
+	*/
+	withMigrationDefaults() {
+		return this.withMigration((configuration) => makeEmptyWalletMigration$1(configuration));
+	}
+	/**
+	* Chooses how this variant produces its first state from the state that preceded it.
+	*
+	* @remarks
+	*   The strategy's input type becomes the variant's `TPreviousState`, which is what the runtime type-checks a
+	*   registration against: a variant declaring it migrates from a ledger-v8 wallet cannot be registered after one that
+	*   produces something else.
+	* @example
+	*   ```typescript
+	*   const forkTarget = new V2Builder().withDefaults().withMigration(makeCrossLedgerMigration);
+	*   ```;
+	*
+	* @param migration Builds the migration from the configuration and the sibling capabilities.
+	*/
+	withMigration(migration) {
+		const capabilities = this.#buildState;
+		return new V2Builder({
+			...capabilities,
+			migration
+		});
+	}
+	withKeys(keysCapability) {
+		return new V2Builder({
+			...this.#buildState,
+			keysCapability
+		});
+	}
+	build(configuration) {
+		const v2Context = this.#buildContextFromBuildState(configuration);
+		const migration = this.#resolveMigration(configuration, () => v2Context);
+		return {
+			__polyTag__: V2Tag,
+			coinsAndBalances: v2Context.coinsAndBalancesCapability,
+			keys: v2Context.keysCapability,
+			serialization: v2Context.serializationCapability,
+			transactionHistory: v2Context.transactionHistoryService,
+			startAux: this.#resolveStartAux(),
+			start(context) {
+				return require_dist.gen(function* () {
+					return new RunningV2Variant(yield* require_dist.Scope, context, v2Context);
+				});
+			},
+			migrateState: (previousState) => migration.migrate(previousState).pipe(require_dist.mapError$2((error) => new require_dist.WalletRuntimeError({
+				message: "Failed to migrate shielded wallet state into this variant",
+				cause: error
+			}))),
+			deserializeState: (serialized) => {
+				return v2Context.serializationCapability.deserialize(null, serialized);
+			}
+		};
+	}
+	/**
+	* Resolves the configured migration, or the empty-wallet fallback when none was configured.
+	*
+	* @remarks
+	*   The fallback is written as a nullary function on purpose. It ignores whatever preceded it — it builds an empty
+	*   wallet from nothing — which makes it a valid migration from _any_ previous state, but a `StateMigration<null>`
+	*   value could only be widened to `StateMigration<TPreviousState>` through a cast. Declaring no parameter says the
+	*   same thing to the type system without one.
+	*/
+	/**
+	* Resolves the configured start-aux derivation.
+	*
+	* @remarks
+	*   Unlike the migration there is no sensible fallback: the default derivation produces this ledger version's secret
+	*   keys, which is only correct for a builder that kept a sync service expecting them. A builder that replaced sync
+	*   and did not say how to derive its own key material is misconfigured, and is told so at build time rather than
+	*   silently handed key objects of the wrong shape at the first migration.
+	*/
+	#resolveStartAux() {
+		const configured = this.#buildState.startAux;
+		if (configured === void 0) throw new Error("Not all components are configured in V2 Builder: startAux");
+		return configured;
+	}
+	#resolveMigration(configuration, getContext) {
+		const configured = this.#buildState.migration;
+		return configured === void 0 ? { migrate: () => makeEmptyWalletMigration$1(configuration).migrate(null) } : configured(configuration, getContext);
+	}
+	#buildContextFromBuildState(configuration) {
+		if (!isBuildStateFull$1(this.#buildState)) throw new Error("Not all components are configured in V2 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 ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-shielded/dist/SingleVariantShieldedWallet.js
+/**
+* A shielded wallet composed from a single variant, which answers for the whole protocol timeline.
+*
+* @remarks
+*   The composition for a wallet that is not expected to meet a protocol boundary — a test harness, a simulator-driven
+*   wallet, an application pinned to one protocol version. Its one variant is registered from the minimum supported
+*   version, so it stamps every transaction at that floor and accepts one of any version; the price is that it cannot
+*   cross a protocol boundary. The wallet that can is `ShieldedWallet`, in `ShieldedWallet.ts`.
+*/
+/**
+* Builds a shielded wallet class over a single variant.
+*
+* @remarks
+*   One variant, and therefore one ledger version: this is the composition for a wallet that is not expected to meet a
+*   protocol boundary — a test harness, a simulator-driven wallet, an application pinned to one protocol version. The
+*   wallet this package ships is `ShieldedWallet`, which registers a variant either side of the boundary.
+* @param configuration What the variant is built from.
+* @param builder The variant builder.
+* @returns The wallet class.
+*/
+function CustomShieldedWallet(configuration, builder) {
+	const buildArgs = [configuration];
+	const BaseWallet = require_dist.WalletBuilder.init().withVariant(require_dist.MinSupportedVersion, builder).build(...buildArgs);
+	return class CustomShieldedWalletImplementation extends BaseWallet {
+		static startWithSecretKeys(secretKeys) {
+			return CustomShieldedWalletImplementation.startFirst(CustomShieldedWalletImplementation, CoreWallet$1.initEmpty(secretKeys, CustomShieldedWalletImplementation.configuration.networkId));
+		}
+		/**
+		* Builds a wallet from a seed, and remembers the seed.
+		*
+		* @remarks
+		*   The seed is the only key material that crosses a protocol boundary, so a wallet built this way can start
+		*   synchronization on any variant it is ever migrated to — each derives its own from the seed. A wallet built from
+		*   key objects instead can only start the variants it was given objects for.
+		*/
+		static startWithSeed(seed) {
+			const walletSeed = require_dist.WalletSeed(seed);
+			const secretKeys = _midnightntwrk_ledger_v9.ZswapSecretKeys.fromSeed(walletSeed);
+			const wallet = CustomShieldedWalletImplementation.startWithSecretKeys(secretKeys);
+			wallet.#retainSeed(walletSeed);
+			return wallet;
+		}
+		/**
+		* Restores a wallet from a snapshot, into whichever registered variant wrote it.
+		*
+		* @remarks
+		*   The snapshot declares the protocol version it was written at, so the variant that can read it is a lookup rather
+		*   than an assumption. A snapshot written before snapshots declared a version, or a serialization format this
+		*   wallet does not recognise as an envelope at all, restores into the head variant — which is what every restore
+		*   did before there was more than one variant to choose between.
+		* @param serializedState The serialized wallet state.
+		* @returns A wallet started from that state, on the variant that owns its protocol version.
+		* @throws UnsupportedSnapshotVersionError if the snapshot declares a version no registered variant reads.
+		*/
+		static restore(serializedState) {
+			const headVariant = require_dist.head(CustomShieldedWalletImplementation.allVariants());
+			const variant = (typeof serializedState === "string" ? variantForSnapshot(serializedState, (version) => CustomShieldedWalletImplementation.variantFor(version), headVariant) : require_dist.right(headVariant)).pipe(require_dist.getOrThrow$1);
+			const deserialized = variant.variant.deserializeState(serializedState).pipe(require_dist.getOrThrow$1);
+			return CustomShieldedWalletImplementation.startAtVariant(CustomShieldedWalletImplementation, variant, deserialized);
+		}
+		state;
+		/**
+		* What the application started this wallet with, kept so synchronization can be started again.
+		*
+		* @remarks
+		*   A migration starts a fresh variant whose sync has never run, and sync needs key material. That material cannot
+		*   come from the state — it is deliberately absent from anything serialized — and does not exist when the wallet
+		*   is first constructed, so it is held here, in memory, for the lifetime of the wallet. Cleared by {@link stop} so
+		*   a stopped wallet cannot be silently resurrected by a late activation.
+		*
+		*   A retained seed answers for every variant. Retained key objects answer only for the variants they were supplied
+		*   for, and accumulate per variant tag as `start` is called, which is the same product a caller holding key
+		*   objects for both protocol versions would hand over at once.
+		*/
+		#retainedStartMaterial = require_dist.unsafeMake(require_dist.none());
+		/** Remembers a seed, which supersedes any key objects retained for individual variants. */
+		#retainSeed(seed) {
+			require_dist.set(this.#retainedStartMaterial, require_dist.some(require_dist.fromSeed(seed))).pipe(require_dist.runSync);
+		}
+		/**
+		* Starts synchronization on a variant that has just become current, with key material it can use.
+		*
+		* @remarks
+		*   The derivation is the activating variant's own, so a wallet retaining a seed hands each variant key material
+		*   built by its own ledger version. A wallet retaining key objects for other variants only cannot answer, and says
+		*   so rather than handing over keys the variant would silently misuse.
+		*/
+		#resumeSyncOn(variantTag, running) {
+			return require_dist.get$1(this.#retainedStartMaterial).pipe(require_dist.flatMap$1(require_dist.match$1({
+				onNone: () => require_dist._void,
+				onSome: (retained) => require_dist.toEffect(require_dist.requireAuxFor(retained, variantTag, (seed) => CustomShieldedWalletImplementation.allVariantsRecord()[variantTag].variant.startAux.fromSeed(seed))).pipe(require_dist.flatMap$1((aux) => running.startSyncInBackground(aux)))
+			})));
+		}
+		/**
+		* Whether the activation watcher has been registered.
+		*
+		* @remarks
+		*   Registration is per wallet, not per `start`: watchers accumulate, so registering on every call would restart sync
+		*   once per historical `start` on the next activation. Flipped with `getAndSet` so concurrent `start` calls cannot
+		*   both observe it unset.
+		*/
+		#watcherRegistered = require_dist.unsafeMake(false);
+		constructor(runtime, scope) {
+			super(runtime, scope);
+			this.state = this.rawState.pipe(rxjs.map((emission) => ShieldedWalletState.fromVariant(CustomShieldedWalletImplementation.allVariantsRecord()[V2Tag].variant, emission)), rxjs.shareReplay({
+				refCount: true,
+				bufferSize: 1
+			}));
+		}
+		start(secretKeys) {
+			return require_dist.gen(this, function* () {
+				const current = yield* this.runtime.currentVariant;
+				yield* require_dist.update(this.#retainedStartMaterial, (retained) => require_dist.some(require_dist.match$1(retained, {
+					onNone: () => require_dist.forVariant(require_dist.getTag(current), secretKeys),
+					onSome: (existing) => existing._tag === "FromSeed" ? existing : require_dist.forVariants([...existing.byTag, [require_dist.getTag(current), secretKeys]])
+				})));
+				if (!(yield* require_dist.getAndSet(this.#watcherRegistered, true))) yield* this.runtime.onVariantActivation({ [V2Tag]: (v2) => this.#resumeSyncOn(V2Tag, v2) });
+				yield* this.runtime.dispatch({ [V2Tag]: (v2) => v2.startSyncInBackground(secretKeys) });
+			}).pipe(require_dist.runPromise$1);
+		}
+		async stop() {
+			require_dist.set(this.#retainedStartMaterial, require_dist.none()).pipe(require_dist.runSync);
+			await super.stop();
+		}
+		/**
+		* The key material this wallet's one variant uses, from what it was started with.
+		*
+		* @remarks
+		*   Typed as the variant's own start-aux, which for a single-variant wallet is whatever the application handed to
+		*   `start` — there is no other variant to derive for, so a retained seed is only ever used through the variant's
+		*   own derivation.
+		*/
+		#requireAux() {
+			return require_dist.gen(this, function* () {
+				const current = yield* this.runtime.currentVariant;
+				const variantTag = require_dist.getTag(current);
+				const retained = yield* require_dist.get$1(this.#retainedStartMaterial);
+				return yield* require_dist.match$1(retained, {
+					onNone: () => require_dist.fail$2(new require_dist.MissingStartAuxError({
+						message: "This wallet holds no key material: it has not been started, or it has been stopped. Start it before asking it to build a transaction.",
+						variantTag
+					})),
+					onSome: (material) => require_dist.toEffect(require_dist.requireAuxFor(material, variantTag, (seed) => CustomShieldedWalletImplementation.allVariantsRecord()[V2Tag].variant.startAux.fromSeed(seed)))
+				});
+			});
+		}
+		/** The whole of the protocol timeline: one variant answers for every version this wallet will ever see. */
+		static #epoch = require_dist.epochOf(require_dist.MinSupportedVersion, require_dist.MinSupportedVersion);
+		balanceTransaction(tx) {
+			return this.runtime.dispatch({ [V2Tag]: (v2) => require_dist.all([this.#requireAux(), require_dist.toEffect(require_dist.WalletTransaction.unwrapWithin(tx, CustomShieldedWalletImplementation.#epoch))]).pipe(require_dist.flatMap$1(([keys, unwrapped]) => v2.balanceTransaction(keys, unwrapped)), require_dist.map$2((result) => result === void 0 ? void 0 : require_dist.WalletTransaction.adopt("Unproven", result, require_dist.MinSupportedVersion))) }).pipe(require_dist.runPromise$1);
+		}
+		transferTransaction(outputs) {
+			return this.runtime.dispatch({ [V2Tag]: (v2) => this.#requireAux().pipe(require_dist.flatMap$1((keys) => v2.transferTransaction(keys, outputs)), require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unproven", tx, require_dist.MinSupportedVersion))) }).pipe(require_dist.runPromise$1);
+		}
+		initSwap(desiredInputs, desiredOutputs) {
+			return this.runtime.dispatch({ [V2Tag]: (v2) => this.#requireAux().pipe(require_dist.flatMap$1((keys) => v2.initSwap(keys, desiredInputs, desiredOutputs)), require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unproven", tx, require_dist.MinSupportedVersion))) }).pipe(require_dist.runPromise$1);
+		}
+		revertTransaction(transaction) {
+			return this.runtime.dispatch({ [V2Tag]: (v2) => require_dist.match$2(require_dist.WalletTransaction.unwrapWithin(transaction, CustomShieldedWalletImplementation.#epoch), {
+				onLeft: () => require_dist._void,
+				onRight: (unwrapped) => v2.revertTransaction(unwrapped)
+			}) }).pipe(require_dist.runPromise$1);
+		}
+		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 ../../packages/module/passport-account/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_dist.TaggedError("Wallet.Other") {};
+var SyncWalletError = class extends require_dist.TaggedError("Wallet.Sync") {};
+var SubmissionError = class extends require_dist.TaggedError("Wallet.SubmissionWalletError") {};
+var InsufficientFundsError = class extends require_dist.TaggedError("Wallet.InsufficientFunds") {};
+var InvalidCoinHashesError = class extends require_dist.TaggedError("Wallet.InvalidCoinHashes") {};
+var TransactionHistoryError = class extends require_dist.TaggedError("Wallet.TransactionHistory") {};
+/**
+* A batch of zswap ledger events was not in ascending id order: an event arrived at or below the one before it, or at
+* or below the applied cursor.
+*
+* @remarks
+*   Order is all the wallet can check: zswap events share one id sequence with dust and contract events in the indexer,
+*   so gaps in the stream are normal and a skipped event is only ever caught by the ledger's own insertion check. The
+*   whole batch is refused, nothing is applied and the cursor stays, so the running variant retries from the same
+*   place.
+* @example
+*   ```ts
+*   if (error._tag === 'Wallet.OutOfOrderSyncUpdate') console.warn(`expected above ${error.expected}, got ${error.received}`);
+*   ```
+*/
+var OutOfOrderSyncUpdateError = class extends require_dist.TaggedError("Wallet.OutOfOrderSyncUpdate") {};
+//#endregion
+//#region ../../packages/module/passport-account/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$7, state) {
+		const coins = CoinHashesMap.pickAllCoins(state);
+		const coinNonces = new Set(require_dist.map$4(coins, (coin) => coin.nonce));
+		const definedNonces = new Set(Object.keys(map$7));
+		const missingNonces = coinNonces.difference(definedNonces);
+		return missingNonces.size === 0 ? require_dist.void_ : require_dist.left(missingNonces);
+	},
+	updateWithCoins(secretKeys, existing, coins) {
+		return require_dist.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_dist.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_dist.createSyncProgress(),
+			protocolVersion: require_dist.MinSupportedVersion
+		};
+	},
+	empty(publicKeys, networkId) {
+		return {
+			state: new _midnight_ntwrk_ledger_v8.ZswapLocalState(),
+			publicKeys,
+			networkId,
+			coinHashes: CoinHashesMap.empty,
+			progress: require_dist.createSyncProgress(),
+			protocolVersion: require_dist.MinSupportedVersion
+		};
+	},
+	restore(localState, secretKeys, syncProgress, protocolVersion, networkId) {
+		return {
+			state: localState,
+			publicKeys: PublicKeys.fromSecretKeys(secretKeys),
+			networkId,
+			coinHashes: CoinHashesMap.init(secretKeys, CoinHashesMap.pickAllCoins(localState)),
+			progress: require_dist.createSyncProgress(syncProgress),
+			protocolVersion: require_dist.ProtocolVersion(protocolVersion)
+		};
+	},
+	restoreWithCoinHashes(publicKeys, localState, coinHashes, syncProgress, protocolVersion, networkId) {
+		return CoinHashesMap.assertValid(coinHashes, localState).pipe(require_dist.mapBoth({
+			onLeft: (missingNonces) => new InvalidCoinHashesError({
+				message: "Missing coin hashes for coins present in the state",
+				missingNonces
+			}),
+			onRight: () => ({
+				state: localState,
+				publicKeys,
+				networkId,
+				coinHashes,
+				progress: require_dist.createSyncProgress(syncProgress),
+				protocolVersion: require_dist.ProtocolVersion(protocolVersion)
+			})
+		}));
+	},
+	initEmpty(keys, networkId) {
+		return this.empty(PublicKeys.fromSecretKeys(keys), networkId);
+	},
+	withProtocolVersion(wallet, version) {
+		return version > wallet.protocolVersion ? {
+			...wallet,
+			protocolVersion: version
+		} : wallet;
+	},
+	fromPreviousVersion(previous) {
+		return {
+			state: new _midnight_ntwrk_ledger_v8.ZswapLocalState(),
+			publicKeys: previous.publicKeys,
+			networkId: previous.networkId,
+			coinHashes: CoinHashesMap.empty,
+			progress: require_dist.createSyncProgress({
+				...previous.progress,
+				isConnected: false
+			}),
+			protocolVersion: require_dist.ProtocolVersion(previous.protocolVersion)
+		};
+	},
+	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_dist.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_dist.pipe(coins, require_dist.reduce([[], 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 ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v1/Migration.js
+/**
+* The migration used when there is no previous wallet at all.
+*
+* @remarks
+*   It backs `WalletLike.startEmpty`, which builds a wallet before any key material exists. The resulting state has no
+*   coins and public keys derived from a fixed placeholder seed; it is a scaffold to be replaced by a real start, not a
+*   wallet anybody can transact with. Preserved verbatim from the ledger-v8 implementation so that `startEmpty` behaves
+*   exactly as it did.
+* @example
+*   ```typescript
+*   const builder = new V2Builder().withDefaults().withMigration(makeEmptyWalletMigration({ networkId }));
+*   ```;
+*
+* @param configuration Supplies the network the scaffold state claims to be on.
+* @returns A migration from `null`.
+*/
+const makeEmptyWalletMigration = (configuration) => ({ migrate: () => {
+	const seed = require_dist.fromString("0000000000000000000000000000000000000000000000000000000000000001");
+	return require_dist.succeed(CoreWallet.empty(PublicKeys.fromSecretKeys(_midnight_ntwrk_ledger_v8.ZswapSecretKeys.fromSeed(seed)), configuration.networkId));
+} });
+//#endregion
+//#region ../../packages/module/passport-account/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_dist.ProgressUpdate({
+		sourceGap,
+		applyGap
+	})];
+};
+/**
+* Reports the protocol version a state observation implies, if any.
+*
+* @remarks
+*   Two situations call for a signal. The ordinary one is a transition: sync annotated the state with a version it did
+*   not have before, and the runtime decides whether that is a re-annotation inside this variant's range or a hand-over
+*   to the next one.
+*
+*   The other is a state that arrives already outside this variant's range — a snapshot serialized in the window between
+*   the annotation and the migration it should have caused, or one written by an older protocol version entirely.
+*   Nothing further will change that value, so waiting for a transition would strand the wallet on a version it does
+*   not own. Emitting on sight heals it.
+*/
+const protocolVersionChange = (previous, current, isInitial, activationRange) => {
+	const transitioned = previous.protocolVersion != current.protocolVersion;
+	const strandedOutsideRange = isInitial && !require_dist.withinRange(current.protocolVersion, activationRange);
+	return transitioned || strandedOutsideRange ? [require_dist.VersionChange({ change: require_dist.Version({ version: require_dist.ProtocolVersion(current.protocolVersion) }) })] : [];
+};
+const V1Tag = Symbol("V1");
+var RunningV1Variant = class {
+	__polyTag__ = V1Tag;
+	#scope;
+	#context;
+	#v1Context;
+	#txHistoryPermits = require_dist.makeSemaphore(8).pipe(require_dist.runSync);
+	state;
+	constructor(scope, context, v1Context) {
+		this.#scope = scope;
+		this.#context = context;
+		this.#v1Context = v1Context;
+		this.state = require_dist.fromEffect(context.stateRef.get).pipe(require_dist.flatMap((initialState) => context.stateRef.changes.pipe(require_dist.mapAccum({
+			previous: initialState,
+			isInitial: true
+		}, (seen, current) => [{
+			previous: current,
+			isInitial: false
+		}, [
+			seen.previous,
+			current,
+			seen.isInitial
+		]]))), require_dist.mapConcat(([previous, current, isInitial]) => {
+			return [
+				require_dist.State({ state: current }),
+				...progress(current),
+				...protocolVersionChange(previous, current, isInitial, context.activationRange)
+			];
+		}));
+	}
+	startSyncInBackground(startAux) {
+		return this.startSync(startAux).pipe(require_dist.runScoped(require_dist.drain), require_dist.forkScoped, require_dist.provideService(require_dist.Scope, this.#scope));
+	}
+	startSync(startAux) {
+		return require_dist.pipe(require_dist.get(this.#context.stateRef), require_dist.fromEffect, require_dist.flatMap((state) => this.#v1Context.syncService.updates(state, startAux)), require_dist.mapEffect((update) => require_dist.modifyEffect(this.#context.stateRef, (state) => require_dist.try_({
+			try: () => {
+				const [newState, changesResult] = this.#v1Context.syncCapability.applyUpdate(state, update, this.#context.activationRange);
+				return [changesResult, newState];
+			},
+			catch: (err) => new OtherWalletError({
+				message: "Error while applying sync update",
+				cause: err
+			})
+		})).pipe(require_dist.flatMap$1(({ changes, protocolVersion }) => changes.length === 0 ? require_dist._void : require_dist.pipe(require_dist.forEach(changes, (change) => require_dist.pipe(this.#txHistoryPermits.withPermits(1)(require_dist.pipe(this.#v1Context.transactionHistoryService.getTransactionDetails(change.source), require_dist.flatMap$1((metadata) => this.#v1Context.transactionHistoryService.put(change, metadata, protocolVersion)))), require_dist.catchAllCause((cause) => require_dist.logError(cause, `Failed to record shielded tx-history section for ${change.source}`))), {
+			discard: true,
+			concurrency: 8
+		}), require_dist.forkScoped)), require_dist.provideService(require_dist.Scope, this.#scope))), require_dist.tapError((error$1) => require_dist.error(error$1)), require_dist.retry(require_dist.pipe(require_dist.exponential(require_dist.seconds(1), 2), require_dist.map$1((delay) => {
+			const maxDelay = require_dist.minutes(2);
+			const jitter = require_dist.millis(Math.floor(Math.random() * 1e3));
+			const delayWithJitter = require_dist.toMillis(delay) + require_dist.toMillis(jitter);
+			return require_dist.millis(Math.min(delayWithJitter, require_dist.toMillis(maxDelay)));
+		}))));
+	}
+	balanceTransaction(secretKeys, tx) {
+		return require_dist.modifyEffect(this.#context.stateRef, (state) => {
+			return require_dist.pipe(this.#v1Context.transactingCapability.balanceTransaction(secretKeys, state, tx), require_dist.toEffect);
+		});
+	}
+	transferTransaction(secretKeys, outputs) {
+		return require_dist.modifyEffect(this.#context.stateRef, (state) => {
+			return require_dist.pipe(this.#v1Context.transactingCapability.makeTransfer(secretKeys, state, outputs), require_dist.toEffect);
+		});
+	}
+	initSwap(secretKeys, desiredInputs, desiredOutputs) {
+		return require_dist.modifyEffect(this.#context.stateRef, (state) => {
+			return require_dist.pipe(this.#v1Context.transactingCapability.initSwap(secretKeys, state, desiredInputs, desiredOutputs), require_dist.toEffect);
+		});
+	}
+	revertTransaction(transaction) {
+		return require_dist.updateEffect(this.#context.stateRef, (state) => {
+			return require_dist.pipe(this.#v1Context.transactingCapability.revertTransaction(state, transaction), require_dist.toEffect);
+		});
+	}
+	serializeState(state) {
+		return this.#v1Context.serializationCapability.serialize(state);
+	}
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v1/Serialization.js
+const StateSchema = require_dist.declare((input) => input instanceof _midnight_ntwrk_ledger_v8.ZswapLocalState).annotations({ identifier: "ledger.ZswapLocalState" });
+const Uint8ArraySchema$1 = require_dist.declare((input) => input instanceof Uint8Array).annotations({ identifier: "Uint8Array" });
+const StateFromUInt8Array = () => require_dist.asSchema(require_dist.transformOrFail(Uint8ArraySchema$1, StateSchema, {
+	encode: (state) => {
+		return require_dist.try_({
+			try: () => {
+				return state.serialize();
+			},
+			catch: (err) => {
+				return new require_dist.Unexpected(err, "Could not serialize local state");
+			}
+		});
+	},
+	decode: (bytes) => require_dist.try_({
+		try: () => _midnight_ntwrk_ledger_v8.ZswapLocalState.deserialize(bytes),
+		catch: (err) => {
+			return new require_dist.Unexpected(err, "Could not deserialize local state");
+		}
+	})
+}));
+const HexedState = () => require_dist.pipe(require_dist.Uint8ArrayFromHex, require_dist.compose(StateFromUInt8Array()));
+const makeDefaultV1SerializationCapability = () => {
+	const SnapshotSchema = require_dist.Struct({
+		publicKeys: require_dist.Struct({
+			coinPublicKey: require_dist.String$,
+			encryptionPublicKey: require_dist.String$
+		}),
+		state: HexedState(),
+		protocolVersion: require_dist.BigInt$,
+		offset: require_dist.optional(require_dist.BigInt$),
+		networkId: require_dist.String$,
+		coinHashes: require_dist.Record({
+			key: require_dist.String$,
+			value: require_dist.Struct({
+				nullifier: require_dist.String$,
+				commitment: require_dist.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_dist.pipe(wallet, buildSnapshot, require_dist.encodeSync(SnapshotSchema), JSON.stringify);
+		},
+		deserialize: (aux, serialized) => {
+			return require_dist.pipe(serialized, require_dist.decodeUnknownEither(require_dist.parseJson(SnapshotSchema)), require_dist.mapLeft((err) => WalletError.other(err)), require_dist.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 ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v1/Sync.js
+/**
+* Splits a batch of version-tagged items at the end of a variant's activation range.
+*
+* @remarks
+*   The split is positional, not a filter: everything from the first out-of-range item onwards is deferred, even if a
+*   later item reports an in-range version again. A batch is a contiguous slice of one timeline, so applying past a
+*   boundary and then resuming behind it would leave a hole no cursor can describe.
+*
+*   This is the one place the boundary rule lives; both the indexer capability (per event) and the simulator capability
+*   (per block) go through it, so they cannot drift apart.
+* @param items The batch, in source order.
+* @param versionOf Reads the protocol version an item was reported at.
+* @param activeRange The variant's half-open activation range.
+* @returns The applied/deferred split and the version to record.
+*/
+const splitAtVersionBoundary = (items, versionOf, activeRange) => {
+	const [, end] = activeRange;
+	const boundary = items.findIndex((item) => BigInt(versionOf(item)) >= end);
+	const [applied, deferred] = boundary < 0 ? [items, []] : [items.slice(0, boundary), items.slice(boundary)];
+	const signalling = deferred.at(0) ?? applied.at(-1);
+	return {
+		applied,
+		deferred,
+		observedVersion: signalling === void 0 ? require_dist.none() : require_dist.some(require_dist.ProtocolVersion(BigInt(versionOf(signalling))))
+	};
+};
+/**
+* Checks that freshly delivered events arrive in strictly ascending id order.
+*
+* @remarks
+*   Order is all that can be checked, never contiguity: zswap events share one id sequence with dust and contract events
+*   in the indexer, so gaps in a zswap stream are normal. A skipped commitment-inserting event is caught by the
+*   ledger's own insertion check instead. An empty batch is trivially ordered.
+* @param fresh The events left after the cursor filter, in source order.
+* @param appliedIndex The highest event id already applied; the first fresh id must exceed it.
+* @returns The batch unchanged, or the first id that fails to exceed its predecessor as an
+*   {@link OutOfOrderSyncUpdateError}.
+*/
+const expectAscending = (fresh, appliedIndex) => require_dist.pipe(require_dist.zipWith(fresh, require_dist.prepend(require_dist.map$3(fresh, (item) => BigInt(item.id)), appliedIndex), (item, previous) => ({
+	item,
+	previous
+})), require_dist.findFirst(({ item, previous }) => BigInt(item.id) <= previous), require_dist.match$1({
+	onNone: () => require_dist.right(fresh),
+	onSome: ({ item, previous }) => require_dist.left(new OutOfOrderSyncUpdateError({
+		message: `Zswap event ${item.id} delivered at or below its predecessor ${previous}; batch refused, applied index stays at ${appliedIndex}`,
+		expected: previous,
+		received: BigInt(item.id)
+	}))
+}));
+/** Records a batch's observed protocol version on the state, monotonically. A batch that observed none is a no-op. */
+const annotateVersion = (state, observedVersion) => require_dist.match$1(observedVersion, {
+	onNone: () => state,
+	onSome: (version) => CoreWallet.withProtocolVersion(state, version)
+});
+const Uint8ArraySchema = require_dist.declare((input) => input instanceof Uint8Array).annotations({ identifier: "Uint8Array" });
+const VersionSignalSyncUpdate = { create: (version, highestEventId) => {
+	return {
+		_tag: "VersionSignal",
+		version,
+		highestEventId
+	};
+} };
+const WalletSyncUpdate = { create: (updates, secretKeys) => {
+	return {
+		_tag: "Events",
+		updates,
+		secretKeys
+	};
+} };
+const LedgerEventSchema = require_dist.declare((input) => input instanceof _midnight_ntwrk_ledger_v8.Event).annotations({ identifier: "ledger.Event" });
+const LedgerEventFromUint8Array = require_dist.transformOrFail(Uint8ArraySchema, LedgerEventSchema, {
+	encode: (event) => require_dist.try_({
+		try: () => event.serialize(),
+		catch: (error) => new require_dist.Unexpected(error, "Could not serialize ledger event")
+	}),
+	decode: (bytes) => require_dist.try_({
+		try: () => _midnight_ntwrk_ledger_v8.Event.deserialize(bytes),
+		catch: (error) => new require_dist.Unexpected(error, "Could not deserialize ledger event")
+	})
+});
+const HexedLedgerEvent = require_dist.pipe(require_dist.Uint8ArrayFromHex, require_dist.compose(LedgerEventFromUint8Array));
+const EventsSyncUpdatePayload = require_dist.Struct({
+	id: require_dist.Number$,
+	raw: require_dist.String$,
+	protocolVersion: require_dist.Number$,
+	maxId: require_dist.Number$
+});
+/**
+* One event of the source's timeline, still encoded.
+*
+* @remarks
+*   The event is carried as the source served it rather than as a `ledger.Event`, because whether this ledger version may
+*   read it at all is not the source's question to answer. A batch spanning a protocol boundary carries events of the
+*   version that follows this one, which this ledger version cannot deserialize — the serialization header names a
+*   different version — and after a hand-over the inclusive cursor re-delivers an event of the version that preceded
+*   it, which it equally cannot. Both are ordinary, and neither is an error: they belong to the variant either side.
+*
+*   So the bytes travel undecoded and only the capability, which knows the activation range, reads the ones it is about
+*   to apply — see {@link readEvent}. Decoding here would fail the whole batch on an event nobody intended to apply.
+*/
+const EventsSyncUpdate = require_dist.TaggedStruct("EventsSyncUpdate", {
+	id: require_dist.Number$,
+	protocolVersion: require_dist.Number$,
+	maxId: require_dist.Number$,
+	raw: require_dist.String$
+});
+const EventsSyncUpdateFromPayload = require_dist.transform(EventsSyncUpdatePayload, EventsSyncUpdate, {
+	strict: true,
+	decode: (input) => ({
+		_tag: "EventsSyncUpdate",
+		id: input.id,
+		protocolVersion: input.protocolVersion,
+		maxId: input.maxId,
+		raw: input.raw
+	}),
+	encode: (update) => ({
+		id: update.id,
+		raw: update.raw,
+		protocolVersion: update.protocolVersion,
+		maxId: update.maxId
+	})
+});
+/**
+* Reads an event this variant is going to apply.
+*
+* @remarks
+*   The counterpart of {@link EventsSyncUpdate} carrying its event encoded: a capability calls this on the batch prefix it
+*   owns, and never on what it defers. Failure here is a genuine one — an event this variant claimed and cannot read —
+*   and is raised rather than returned, because `SyncCapability.applyUpdate` is total in its own domain and the variant
+*   already turns a throw from it into a typed synchronization error.
+* @param update The update to read.
+* @returns The event it carries.
+* @throws ParseError if the bytes are not an event this ledger version can deserialize.
+*/
+const readEvent = (update) => require_dist.decodeSync(HexedLedgerEvent)(update.raw);
+/** How often the chain is asked its version when the configuration does not say. */
+const DEFAULT_VERSION_WATCH_INTERVAL_MS = 3e4;
+/**
+* How long one event-id probe is given to produce its single answer.
+*
+* @remarks
+*   Only a stall guard. The probe subscribes at a cursor whose event provably exists, so the answer arrives at once or
+*   the transport is broken; without a bound, a half-open socket would leave the poll loop parked on a tick that never
+*   completes and the wallet would stop asking altogether. A bound turns that into a skipped tick.
+*/
+const EVENT_TIP_PROBE_TIMEOUT = require_dist.seconds(10);
+/**
+* Asks the source how far its zswap event timeline goes.
+*
+* @remarks
+*   Over the event subscription rather than a query, because the schema has no query that reaches a zswap ledger event:
+*   `block`/`transactions` reach one only through a block that happens to contain zswap events, which on a quiet chain
+*   is precisely the block that does not. `maxId` is a property of the whole timeline, so any single event answers it —
+*   the first one delivered is taken and the subscription closed.
+*
+*   The cursor is the wallet's own. The event it last applied provably exists, so the source answers immediately and has
+*   the least backfill to abandon; a wallet that has applied nothing asks from the start, where the first event is.
+* @param config The sync configuration, for the keep-alive the source's subscriptions use.
+* @param url Where to subscribe.
+* @param resumeFrom The wallet's cursor; below zero means "from the very start".
+* @returns The highest event id, or nothing if the source did not answer.
+*/
+const highestEventId = (config, url, resumeFrom) => require_dist.pipe(require_dist.ZswapEventTip.run({ id: resumeFrom < 0n ? null : Number(resumeFrom) }), require_dist.runHead, require_dist.map$2(require_dist.map$5((answer) => answer.zswapLedgerEvents.maxId)), require_dist.provide(require_dist.layer({
+	url,
+	keepAlive: config.indexerClientConnection.keepAlive
+})), require_dist.scoped, require_dist.timeout(EVENT_TIP_PROBE_TIMEOUT));
+/**
+* One check of the chain's protocol version, gated on the wallet being caught up on the source's event ids.
+*
+* @remarks
+*   The order of the two questions is load-bearing. The tip is read **first**: a tip reported at a version means the
+*   source has indexed through the block that carries it, so every event below it is already counted in the `maxId`
+*   read afterwards. Asked the other way round, an event indexed between the two answers could be one of the version
+*   that preceded the tip — unread, uncounted, and exactly what the gate exists to catch.
+*
+*   Two short-circuits, both of them answers rather than shortcuts. A tip at or below the version the wallet already held
+*   is a signal that could only be a no-op, so no probe is opened and nothing is emitted — which is what keeps a
+*   settled wallet from polling a subscription for the rest of its life. And a tip whose commitment tree has never
+*   grown cannot have had a nullifier spent against it either, so such a chain provably holds no zswap event: nothing
+*   can be unread, and the signal goes out with `null`.
+*
+*   Everything else is swallowed. A tick that fails says nothing about the chain, so it must neither reach the state nor
+*   take the sync stream down with it; the next tick is the retry, and costs nothing to wait for.
+* @param config The sync configuration, for the indexer to ask.
+* @param url Where to run the event-id probe.
+* @param resumeFrom The wallet's cursor, for the probe.
+* @param knownVersion The version the wallet already held when this stream opened — a lower bound on what it holds now.
+* @returns The signal, or nothing when there is nothing to say or nobody said it.
+*/
+const readVersionSignal = (config, url, resumeFrom, knownVersion) => require_dist.pipe(require_dist.BlockHash.run({ offset: null }), require_dist.provide(require_dist.layer$1({ url: config.indexerClientConnection.indexerHttpUrl })), require_dist.scoped, require_dist.flatMap$1((answer) => require_dist.match$1(require_dist.fromNullable(answer.block), {
+	onNone: () => require_dist.succeedNone,
+	onSome: (tip) => BigInt(tip.protocolVersion) <= knownVersion ? require_dist.succeedNone : tip.zswapEndIndex === 0 ? require_dist.succeedSome(VersionSignalSyncUpdate.create(tip.protocolVersion, null)) : require_dist.pipe(highestEventId(config, url, resumeFrom), require_dist.map$2(require_dist.map$5((maxId) => VersionSignalSyncUpdate.create(tip.protocolVersion, maxId))))
+})), require_dist.catchAll(() => require_dist.succeedNone));
+/**
+* The chain's version, re-asked on a timer for as long as sync runs.
+*
+* @remarks
+*   Deliberately silent about ticks that say nothing: a tick that finds the chain where the wallet left it, or that
+*   cannot reach the chain at all, emits no element rather than an empty one, so nothing downstream has to know that
+*   polling is how the answer was arrived at.
+* @param config The sync configuration, carrying the interval.
+* @param url Where to run the event-id probe.
+* @param resumeFrom The wallet's cursor, for the probe.
+* @param knownVersion The version the wallet held when this stream opened.
+* @returns The signals, or an empty stream when watching is turned off.
+*/
+const versionWatch = (config, url, resumeFrom, knownVersion) => {
+	const intervalMs = config.versionWatch?.intervalMs ?? DEFAULT_VERSION_WATCH_INTERVAL_MS;
+	return intervalMs <= 0 ? require_dist.empty : require_dist.pipe(require_dist.fromSchedule(require_dist.spaced(require_dist.millis(intervalMs))), require_dist.mapEffect(() => readVersionSignal(config, url, resumeFrom, knownVersion)), require_dist.filterMap(require_dist.identity));
+};
+const makeEventsSyncService = (config) => {
+	return { updates: (state, secretKeys) => {
+		const { indexerClientConnection } = config;
+		const webSocketUrlResult = require_dist.createWebSocketUrl(indexerClientConnection.indexerHttpUrl, indexerClientConnection.indexerWsUrl);
+		if (require_dist.isLeft(webSocketUrlResult)) return require_dist.fail(new SyncWalletError(/* @__PURE__ */ new Error(`Could not derive WebSocket URL from indexer HTTP URL: ${webSocketUrlResult.left.message}`)));
+		const indexerWsUrlResult = require_dist.make(webSocketUrlResult.right);
+		if (require_dist.isLeft(indexerWsUrlResult)) return require_dist.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_dist.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_dist.pipe(require_dist.ZswapEvents.runWithBackpressure({
+			bufferSize,
+			resumeThreshold,
+			from: resumeFrom,
+			variables: (cursor) => ({ id: cursor < 0n ? null : Number(cursor) }),
+			key: (r) => BigInt(r.zswapLedgerEvents.id)
+		}), require_dist.provideLayer(require_dist.layer({
+			url: indexerWsUrl,
+			keepAlive: config.indexerClientConnection.keepAlive
+		})), require_dist.mapError((error) => new SyncWalletError(error)), require_dist.mapEffect((subscription) => require_dist.pipe(subscription.zswapLedgerEvents, require_dist.decodeUnknownEither(EventsSyncUpdateFromPayload), require_dist.mapLeft((err) => new SyncWalletError(err)), require_dist.toEffect)), require_dist.groupedWithin(batchSize, batchTimeout), require_dist.map(require_dist.toArray), require_dist.map((data) => WalletSyncUpdate.create(data, secretKeys)));
+		const timeline = batchSpacing > 0 ? require_dist.schedule(eventsStream, require_dist.spaced(require_dist.millis(batchSpacing))) : eventsStream;
+		return require_dist.merge(timeline, versionWatch(config, indexerWsUrl, resumeFrom, state.protocolVersion), { haltStrategy: "left" });
+	} };
+};
+/** The result of an update that observed nothing of the chain. */
+const noChanges = (state) => ({
+	changes: [],
+	protocolVersion: Number(state.protocolVersion)
+});
+/**
+* Folds what the chain said about its own version into the wallet state.
+*
+* @remarks
+*   The same recording the event path makes through {@link annotateVersion}, and nothing else: no cursor moves, no coin
+*   changes hands, no tree grows. A signal is an observation about the chain, not a piece of it.
+*
+*   Unread events below the source's tip make the observation unsafe to record, and leave the state exactly as it was:
+*   the hand-over would park the cursor in front of history the next variant cannot read — and those events carry the
+*   version themselves, so nothing is lost by waiting for them. That is not an error; the next tick asks again.
+*
+*   A version at or below the one already recorded needs no guard of its own — {@link annotateVersion} never goes
+*   backwards — so a source briefly answering from a lagging replica cannot drag a wallet back over a boundary.
+* @param state The wallet to record on.
+* @param update What the chain said, and how far its event timeline goes.
+* @returns The wallet, annotated or untouched, and an empty result.
+*/
+const applyVersionSignal = (state, update) => {
+	const appliedIndex = state.progress?.appliedIndex ?? 0n;
+	return [update.highestEventId !== null && BigInt(update.highestEventId) > appliedIndex ? state : annotateVersion(state, require_dist.some(require_dist.ProtocolVersion(BigInt(update.version)))), noChanges(state)];
+};
+const makeEventsSyncCapability = () => {
+	return { applyUpdate: (state, wrappedUpdate, activeRange) => {
+		if (wrappedUpdate._tag === "VersionSignal") return applyVersionSignal(state, wrappedUpdate);
+		if (wrappedUpdate.updates.length === 0) return [state, noChanges(state)];
+		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 { applied, observedVersion } = splitAtVersionBoundary(require_dist.getOrThrowWith(expectAscending(freshUpdates, appliedIndex), require_dist.identity), (update) => update.protocolVersion, activeRange);
+		const [newState, newChanges] = applied.length === 0 ? [state, []] : CoreWallet.replayEventsWithChanges(state, wrappedUpdate.secretKeys, applied.map(readEvent));
+		return [CoreWallet.updateProgress(annotateVersion(newState, observedVersion), {
+			highestRelevantWalletIndex,
+			appliedIndex: applied.length === 0 ? appliedIndex : BigInt(applied.at(-1).id),
+			isConnected: true
+		}), {
+			changes: newChanges,
+			protocolVersion: applied.at(-1)?.protocolVersion ?? Number(state.protocolVersion)
+		}];
+	} };
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v1/TransactionImbalances.js
+const ShieldedCostModel = {
+	inputFeeOverhead: 0n,
+	outputFeeOverhead: 0n
+};
+const TransactionImbalances = new class {
+	empty = () => {
+		return {
+			guaranteed: require_dist.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 ../../packages/module/passport-account/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_dist.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_dist.Imbalances.fromEntries(rawImbalances)]];
+			});
+			return new Map(fallibleImbalances);
+		}
+	};
+}();
+//#endregion
+//#region ../../packages/module/passport-account/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_dist.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_dist.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_dist.gen$1(this, function* () {
+			const positiveTransfers = yield* require_dist.pipe(transfers, require_dist.filter$1((t) => t.amount > 0n), require_dist.match({
+				onEmpty: () => require_dist.left(new OtherWalletError({ message: "The amount needs to be positive" })),
+				onNonEmpty: (nonEmpty) => require_dist.right(nonEmpty)
+			}));
+			const networkId = this.networkId;
+			const { initialOffersAndCoins, selfCoins } = yield* this.#processDesiredOutputs(state, positiveTransfers);
+			const offerToBalance = require_dist.pipe(initialOffersAndCoins, require_dist.map$3((o) => o.outputOffer), require_dist.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_dist.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_dist.gen$1(this, function* () {
+			if (!desiredOutputs.every((output) => output.amount > 0n)) return yield* require_dist.left(new OtherWalletError({ message: "The amount needs to be positive" }));
+			if (!Object.entries(desiredInputs).every(([, amount]) => amount > 0n)) return yield* require_dist.left(new OtherWalletError({ message: "The input amounts need to be positive" }));
+			const outputsParseResult = yield* this.#processDesiredOutputsPossiblyEmpty(state, desiredOutputs);
+			const inputsParseResult = require_dist.Imbalances.fromEntries(require_dist.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_dist.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_dist.pipe(require_dist.appendAll(inputOffers, outputOffers), require_dist.match({
+			onEmpty: () => require_dist.none(),
+			onNonEmpty: (nonEmpty) => require_dist.pipe(nonEmpty, require_dist.fold((a, b) => a.merge(b)), require_dist.some)
+		}), require_dist.map$5((offer) => ({
+			offer,
+			newState: stateAfterWatches
+		})));
+	}
+	balanceFallibleSection(secretKeys, state, imbalances, coinSelection) {
+		return Array.from(imbalances.fallible.entries()).reduce((acc, [segment, segmentImbalances]) => require_dist.flatMap$4(acc, ({ fallibleOffers, newState }) => require_dist.pipe(require_dist.try_$1({
+			try: () => {
+				const fallibleBalanceRecipe = require_dist.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.nonce === b.nonce
+				});
+				return this.#prepareOffer(secretKeys, newState, fallibleBalanceRecipe, segment);
+			},
+			catch: (err) => {
+				if (err instanceof require_dist.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_dist.map$6(require_dist.match$1({
+			onNone: () => ({
+				fallibleOffers,
+				newState
+			}),
+			onSome: (res) => ({
+				fallibleOffers: new Map([...fallibleOffers, [segment, res.offer]]),
+				newState: res.newState
+			})
+		})))), require_dist.right({
+			fallibleOffers: /* @__PURE__ */ new Map(),
+			newState: state
+		}));
+	}
+	#balanceGuaranteedSection(secretKeys, state, imbalances, coinSelection, targetImbalances) {
+		return require_dist.gen$1(this, function* () {
+			const balanceRecipe = yield* require_dist.try_$1({
+				try: () => require_dist.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_dist.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_dist.pipe(this.#prepareOffer(secretKeys, state, balanceRecipe, 0), require_dist.match$1({
+				onNone: () => ({
+					offer: void 0,
+					newState: state
+				}),
+				onSome: (result) => result
+			}));
+		});
+	}
+	#processDesiredOutputs(state, transfers) {
+		return require_dist.try_$1({
+			try: () => {
+				const initialOffersAndCoins = require_dist.pipe(transfers, require_dist.map$3((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_dist.flatMap$2(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_dist.pipe(desiredOutputs, require_dist.match({
+			onEmpty: () => {
+				return require_dist.right({
+					imbalances: TransactionImbalances.empty(),
+					selfCoins: [],
+					unprovenTxToBalance: null
+				});
+			},
+			onNonEmpty: (desiredOutputs) => {
+				return require_dist.pipe(this.#processDesiredOutputs(state, desiredOutputs), require_dist.map$6(({ initialOffersAndCoins, selfCoins }) => {
+					const networkId = this.networkId;
+					const offerToBalance = require_dist.pipe(initialOffersAndCoins, require_dist.map$3((o) => o.outputOffer), require_dist.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 ../../packages/module/passport-account/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_dist.pipe([getAvailableBalances(state), getPendingBalances(state)], require_dist.mergeWithAccumulator(0n, (a, b) => a + b));
+	};
+	const getAvailableCoins = (state) => {
+		const pendingSpends = new Set([...state.state.pendingSpends.values()].map(([coin]) => coin.nonce));
+		return require_dist.pipe([...state.state.coins], require_dist.filter$1((coin) => !pendingSpends.has(coin.nonce)), require_dist.map$3((coin) => {
+			return {
+				coin,
+				commitment: state.coinHashes[coin.nonce].commitment,
+				nullifier: state.coinHashes[coin.nonce].nullifier
+			};
+		}));
+	};
+	const getPendingCoins = (state) => require_dist.pipe([...state.state.pendingOutputs.values()], require_dist.map$3(([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 ../../packages/module/passport-account/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 ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-shielded/dist/v1/TransactionHistory.js
+const QualifiedShieldedCoinInfoSchema = require_dist.Struct({
+	type: require_dist.String$,
+	nonce: require_dist.String$,
+	value: require_dist.BigInt$,
+	mtIndex: require_dist.BigInt$
+});
+const ShieldedSectionSchema$1 = require_dist.Struct({
+	receivedCoins: require_dist.Array$(QualifiedShieldedCoinInfoSchema),
+	spentCoins: require_dist.Array$(QualifiedShieldedCoinInfoSchema)
+});
+require_dist.extendEntrySchema({ shielded: require_dist.optional(ShieldedSectionSchema$1) });
+require_dist.equivalence(QualifiedShieldedCoinInfoSchema);
+const convertUpdateToFinalizedInput = (changes, metadata, protocolVersion) => ({
+	hash: changes.source,
+	protocolVersion,
+	status: metadata.status,
+	identifiers: metadata.identifiers,
+	finalizedBlock: {
+		hash: metadata.block.hash,
+		height: metadata.block.height,
+		timestamp: new Date(metadata.block.timestamp)
+	},
+	shielded: {
+		receivedCoins: changes.receivedCoins.map(({ mt_index, ...rest }) => ({
+			...rest,
+			mtIndex: mt_index
+		})),
+		spentCoins: changes.spentCoins.map(({ mt_index, ...rest }) => ({
+			...rest,
+			mtIndex: mt_index
+		}))
+	}
+});
+const gotFinalizedShielded = (txHistoryStorage, input) => require_dist.tryPromise({
+	try: () => txHistoryStorage.gotFinalized(input),
+	catch: (e) => new TransactionHistoryError({
+		message: `Failed to record finalized history entry for ${input.hash}`,
+		cause: e
+	})
+});
+const makeDefaultTransactionHistoryService = (config, _getContext) => {
+	const txHistoryStorage = config.txHistoryStorage;
+	const queryClientLayer = require_dist.layer$1({ url: config.indexerClientConnection.indexerHttpUrl });
+	const retryWindow = config.transactionDetailsRetryWindow ?? require_dist.minutes(2);
+	return {
+		put: (changes, metadata, protocolVersion) => gotFinalizedShielded(txHistoryStorage, convertUpdateToFinalizedInput(changes, metadata, protocolVersion)),
+		getTransactionDetails: (hash) => require_dist.gen(function* () {
+			const result = yield* (yield* require_dist.TransactionHistoryDetail)({ transactionHash: hash });
+			const tx = yield* require_dist.head$1(result.transactions).pipe(require_dist.orElseFail(() => new TransactionHistoryError({ message: `Indexer has not yet indexed transaction ${hash}` })));
+			const rawStatus = tx.__typename === "RegularTransaction" ? tx.transactionResult.status : void 0;
+			const status = rawStatus === "FAILURE" || rawStatus === "PARTIAL_SUCCESS" ? rawStatus : "SUCCESS";
+			const identifiers = tx.__typename === "RegularTransaction" ? tx.identifiers : [];
+			return {
+				hash: tx.hash,
+				block: {
+					hash: tx.block.hash,
+					height: tx.block.height,
+					timestamp: tx.block.timestamp
+				},
+				status,
+				identifiers
+			};
+		}).pipe(require_dist.provide(queryClientLayer), require_dist.scoped, require_dist.retry$1({
+			schedule: require_dist.exponential(require_dist.seconds(1)).pipe(require_dist.either(require_dist.spaced(require_dist.seconds(10))), require_dist.jittered, require_dist.upTo(retryWindow)),
+			while: (error) => error instanceof TransactionHistoryError
+		}), require_dist.mapError$2((error) => error instanceof TransactionHistoryError ? error : new TransactionHistoryError({
+			message: `Failed to fetch transaction metadata for ${hash}`,
+			cause: error
+		})))
+	};
+};
+//#endregion
+//#region ../../packages/module/passport-account/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().withStartAuxDefaults().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,
+			startAux: void 0
+		});
+	}
+	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_dist.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);
+	}
+	/**
+	* Uses the default start-aux derivation: this ledger version's Zswap secret keys, derived from the seed.
+	*
+	* @remarks
+	*   The seed is the only key material that crosses a protocol boundary, so every variant must be able to produce its
+	*   own from one. This is that derivation for this ledger version; a builder whose sync service expects something
+	*   else supplies its own with {@link V1Builder.withStartAux}.
+	*/
+	withStartAuxDefaults() {
+		return this.withStartAux({ fromSeed: (seed) => _midnight_ntwrk_ledger_v8.ZswapSecretKeys.fromSeed(seed) });
+	}
+	/**
+	* Chooses how this variant derives the key material its synchronization is started with from a seed.
+	*
+	* @param startAux The derivation.
+	* @returns A builder that produces a variant able to start sync from a seed alone.
+	*/
+	withStartAux(startAux) {
+		return new V1Builder({
+			...this.#buildState,
+			startAux
+		});
+	}
+	/**
+	* Uses the default migration: an empty wallet built from nothing.
+	*
+	* @remarks
+	*   This is what an unconfigured builder already does, so calling it changes no behaviour — it states the choice rather
+	*   than inheriting it. Registering this variant as the target of a real fork means calling
+	*   {@link V1Builder.withMigration} with {@link makeCrossLedgerMigration} instead.
+	*/
+	withMigrationDefaults() {
+		return this.withMigration((configuration) => makeEmptyWalletMigration(configuration));
+	}
+	/**
+	* Chooses how this variant produces its first state from the state that preceded it.
+	*
+	* @remarks
+	*   The strategy's input type becomes the variant's `TPreviousState`, which is what the runtime type-checks a
+	*   registration against: a variant declaring it migrates from a ledger-v8 wallet cannot be registered after one that
+	*   produces something else.
+	* @example
+	*   ```typescript
+	*   const forkTarget = new V1Builder().withDefaults().withMigration(makeCrossLedgerMigration);
+	*   ```;
+	*
+	* @param migration Builds the migration from the configuration and the sibling capabilities.
+	*/
+	withMigration(migration) {
+		const capabilities = this.#buildState;
+		return new V1Builder({
+			...capabilities,
+			migration
+		});
+	}
+	withKeys(keysCapability) {
+		return new V1Builder({
+			...this.#buildState,
+			keysCapability
+		});
+	}
+	build(configuration) {
+		const v1Context = this.#buildContextFromBuildState(configuration);
+		const migration = this.#resolveMigration(configuration, () => v1Context);
+		return {
+			__polyTag__: V1Tag,
+			coinsAndBalances: v1Context.coinsAndBalancesCapability,
+			keys: v1Context.keysCapability,
+			serialization: v1Context.serializationCapability,
+			transactionHistory: v1Context.transactionHistoryService,
+			startAux: this.#resolveStartAux(),
+			start(context) {
+				return require_dist.gen(function* () {
+					return new RunningV1Variant(yield* require_dist.Scope, context, v1Context);
+				});
+			},
+			migrateState: (previousState) => migration.migrate(previousState).pipe(require_dist.mapError$2((error) => new require_dist.WalletRuntimeError({
+				message: "Failed to migrate shielded wallet state into this variant",
+				cause: error
+			}))),
+			deserializeState: (serialized) => {
+				return v1Context.serializationCapability.deserialize(null, serialized);
+			}
+		};
+	}
+	/**
+	* Resolves the configured migration, or the empty-wallet fallback when none was configured.
+	*
+	* @remarks
+	*   The fallback is written as a nullary function on purpose. It ignores whatever preceded it — it builds an empty
+	*   wallet from nothing — which makes it a valid migration from _any_ previous state, but a `StateMigration<null>`
+	*   value could only be widened to `StateMigration<TPreviousState>` through a cast. Declaring no parameter says the
+	*   same thing to the type system without one.
+	*/
+	/**
+	* Resolves the configured start-aux derivation.
+	*
+	* @remarks
+	*   Unlike the migration there is no sensible fallback: the default derivation produces this ledger version's secret
+	*   keys, which is only correct for a builder that kept a sync service expecting them. A builder that replaced sync
+	*   and did not say how to derive its own key material is misconfigured, and is told so at build time rather than
+	*   silently handed key objects of the wrong shape at the first migration.
+	*/
+	#resolveStartAux() {
+		const configured = this.#buildState.startAux;
+		if (configured === void 0) throw new Error("Not all components are configured in V1 Builder: startAux");
+		return configured;
+	}
+	#resolveMigration(configuration, getContext) {
+		const configured = this.#buildState.migration;
+		return configured === void 0 ? { migrate: () => makeEmptyWalletMigration(configuration).migrate(null) } : configured(configuration, getContext);
+	}
+	#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 ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-shielded/dist/ShieldedWallet.js
+/**
+* Builds a shielded wallet class over a variant either side of a protocol boundary.
+*
+* @remarks
+*   The boundary is `configuration.forks.v9` and nothing else: the V1 variant is registered from the minimum supported
+*   version and the ledger-v9 one from the fork version, so the version at which the runtime hands over and the version
+*   at which each variant stops applying are the same number, taken from one place.
+*
+*   Each variant is built from its own configuration. What the wallet layer needs — the network it is on and where the
+*   boundary lies — it takes separately, because neither variant knows there is another one.
+* @example
+*   ```typescript
+*   const Wallet = CustomForkingShieldedWallet(
+*     { networkId, forks },
+*     { builder: new V1Builder().withDefaults(), configuration: v1Configuration },
+*     { builder: new V2Builder().withDefaults().withMigration(makeCrossLedgerMigration), configuration: v2Configuration },
+*   );
+*   const wallet = Wallet.startWithSeed(seed);
+*   ```;
+*
+* @param configuration What the wallet layer needs: the network, and where the boundary lies.
+* @param v1 The variant that reads the chain below the boundary, with the configuration it is built from.
+* @param v2 The variant that reads it from the boundary, with the configuration it is built from.
+* @returns The wallet class.
+*/
+function CustomForkingShieldedWallet(configuration, v1, v2) {
+	const v1Builder = v1.builder;
+	const v2Builder = v2.builder;
+	const BaseWallet = require_dist.WalletBuilder.init().withVariant(require_dist.MinSupportedVersion, v1Builder, v1.configuration).withVariant(configuration.forks.v9, v2Builder, v2.configuration).build();
+	const variants = BaseWallet.allVariantsRecord();
+	/** Nothing retained: never started, or stopped. */
+	const noKeys = {
+		v8: require_dist.none(),
+		v9: require_dist.none()
+	};
+	/** Both sides, derived from one seed. */
+	const keysFromSeed = (seed) => ({
+		v8: require_dist.some(variants[V1Tag].variant.startAux.fromSeed(seed)),
+		v9: require_dist.some(variants[V2Tag].variant.startAux.fromSeed(seed))
+	});
+	/**
+	* What a variant can be started with, or why it cannot be.
+	*
+	* @remarks
+	*   Two different failures, deliberately distinguished: a wallet that was never started (or has been stopped) holds
+	*   nothing at all, while one started with the other side's key objects holds something it must not use here.
+	*/
+	const auxFor = (retained, side, variantTag) => require_dist.fromOption(side, () => new require_dist.MissingStartAuxError({
+		message: require_dist.isNone(retained.v8) && require_dist.isNone(retained.v9) ? "This wallet holds no key material: it has not been started, or it has been stopped. Start it before asking it to synchronize or to build a transaction." : `This wallet holds key material of the other protocol version only, which the variant ${String(variantTag)} cannot use: key objects belong to one ledger version's runtime. Start this wallet with material that answers for either side — startWithSeed(seed), or startWithKeys({ v8, v9 }).`,
+		variantTag
+	}));
+	const v8Aux = (retained) => auxFor(retained, retained.v8, V1Tag);
+	const v9Aux = (retained) => auxFor(retained, retained.v9, V2Tag);
+	/**
+	* The protocol versions each variant owns, and the version a transaction it builds is stamped with.
+	*
+	* @remarks
+	*   The stamp is the version at which the variant that built the transaction became current — the floor of its epoch —
+	*   rather than the block height the chain happened to be at. Every decision the stamp is later read for asks which
+	*   side of the boundary the bytes belong to: which prover proves them, which validator checks them, which variant
+	*   may unwrap them. The epoch floor is the one value guaranteed to answer that the same way as any other version in
+	*   the same epoch, and it is derived here from the same `forks.v9` the variants are registered at.
+	*/
+	const v8Epoch = require_dist.epochOf(require_dist.MinSupportedVersion, configuration.forks.v9);
+	const v9Epoch = require_dist.epochOf(configuration.forks.v9, configuration.forks.v9);
+	const [v8Stamp] = v8Epoch;
+	const [v9Stamp] = v9Epoch;
+	/** Seals a balancing result, which is absent when the wallet had nothing of its own to add. */
+	const sealV8 = (result) => result === void 0 ? void 0 : require_dist.WalletTransaction.adopt("Unproven", result, v8Stamp);
+	const sealV9 = (result) => result === void 0 ? void 0 : require_dist.WalletTransaction.adopt("Unproven", result, v9Stamp);
+	/**
+	* How long a start waits for the chain to say which version it is on.
+	*
+	* @remarks
+	*   Short, because what is being bought is small: the alternative to an answer is the hand-over this wallet has always
+	*   done, which costs one migration and no correctness on a chain that produces events. It is a ceiling rather than a
+	*   typical cost — an unreachable indexer refuses a connection long before this — and it exists so that a probe which
+	*   neither answers nor fails cannot hold a start open indefinitely.
+	*/
+	const probeTimeout = require_dist.seconds(5);
+	/**
+	* The variant the chain's current version belongs to, or nothing.
+	*
+	* @remarks
+	*   Nothing covers every way the question can fail to produce an answer, and they are deliberately not distinguished:
+	*   no probe configured, a probe that rejected, a probe that outlived the wallet's patience, or a version no
+	*   registered variant claims. Each means the same thing to a caller — start where a wallet with no history starts —
+	*   and none of them is a reason to fail.
+	*/
+	const probedStart = configuration.chainVersionProbe === void 0 ? require_dist.succeedNone : require_dist.pipe(require_dist.tryPromise(configuration.chainVersionProbe), require_dist.timeout(probeTimeout), require_dist.map$2((version) => require_dist.map$5(BaseWallet.variantFor(version), (variant) => ({
+		version,
+		variant
+	}))), require_dist.orElseSucceed(() => require_dist.none()));
+	/**
+	* A fresh state of the variant a probed start begins at, recording the version the chain reported.
+	*
+	* @remarks
+	*   Built exactly as the head-variant boot path builds its own — an empty state of that variant, from that ledger
+	*   version's keys — and then annotated with the observed version, which is what keeps a variant from starting
+	*   outside its own activation range and signalling backwards on sight.
+	*/
+	const freshStateAt = (variant, keys, version) => require_dist.getVersionedVariantTag(variant) === V2Tag ? CoreWallet$1.withProtocolVersion(CoreWallet$1.initEmpty(keys.v9, configuration.networkId), version) : CoreWallet.withProtocolVersion(CoreWallet.initEmpty(keys.v8, configuration.networkId), version);
+	return class ForkingShieldedWalletImplementation extends BaseWallet {
+		static configuration = configuration;
+		/**
+		* Starts at the variant the chain says it is on, or at the head variant when it does not say.
+		*
+		* @remarks
+		*   The second branch is the whole of this wallet's previous behaviour, unchanged and reached whenever the chain was
+		*   not asked or did not answer: the V1 variant, an empty state, and a hand-over on the first batch that reports a
+		*   version it does not own.
+		* @param keys One ledger version's keys per side of the boundary, since either side may be the one that runs.
+		* @returns The started wallet.
+		*/
+		static #startProbed(keys) {
+			return require_dist.pipe(probedStart, require_dist.map$2(require_dist.match$1({
+				onNone: () => ForkingShieldedWalletImplementation.startFirst(ForkingShieldedWalletImplementation, CoreWallet.initEmpty(keys.v8, configuration.networkId)),
+				onSome: ({ version, variant }) => ForkingShieldedWalletImplementation.startAtVariant(ForkingShieldedWalletImplementation, variant, freshStateAt(variant, keys, version))
+			})), require_dist.runPromise$1);
+		}
+		static async startWithSeed(seed) {
+			const derived = keysFromSeed(require_dist.WalletSeed(seed));
+			const wallet = await ForkingShieldedWalletImplementation.#startProbed({
+				v8: require_dist.getOrThrow(derived.v8),
+				v9: require_dist.getOrThrow(derived.v9)
+			});
+			wallet.#retainKeys(derived);
+			return wallet;
+		}
+		static async startWithKeys(keys) {
+			const wallet = await ForkingShieldedWalletImplementation.#startProbed(keys);
+			wallet.#retainKeys({
+				v8: require_dist.some(keys.v8),
+				v9: require_dist.some(keys.v9)
+			});
+			return wallet;
+		}
+		static tryRestore(serializedState) {
+			return variantForSnapshot(serializedState, (version) => ForkingShieldedWalletImplementation.variantFor(version), require_dist.head(ForkingShieldedWalletImplementation.allVariants())).pipe(require_dist.flatMap$4((variant) => {
+				const deserialized = variant.variant.deserializeState(serializedState);
+				return require_dist.map$6(deserialized, (state) => ForkingShieldedWalletImplementation.startAtVariant(ForkingShieldedWalletImplementation, variant, state));
+			}));
+		}
+		static restore(serializedState) {
+			return require_dist.getOrThrow$1(ForkingShieldedWalletImplementation.tryRestore(serializedState));
+		}
+		state;
+		/**
+		* What the application started this wallet with, kept so synchronization can be started again.
+		*
+		* @remarks
+		*   A migration starts a fresh variant whose sync has never run, and sync needs key material that is deliberately
+		*   absent from anything the wallet serializes. A retained seed answers for both variants; retained key objects
+		*   answer only for the ledger-v9 one, which is the ledger version this wallet's public API speaks. Cleared by
+		*   {@link stop} so a stopped wallet cannot be resurrected by a late activation.
+		*/
+		#retainedKeys = require_dist.unsafeMake(noKeys);
+		/** Remembers key material for both sides of the boundary. */
+		#retainKeys(keys) {
+			require_dist.set(this.#retainedKeys, keys).pipe(require_dist.runSync);
+		}
+		/**
+		* Starts synchronization on a variant that has just become current, with key material it can use.
+		*
+		* @param running The variant to start.
+		* @param auxFor That variant's own resolution of what it can be started with.
+		*/
+		#resumeSyncOn(running, keysFor) {
+			return require_dist.get$1(this.#retainedKeys).pipe(require_dist.flatMap$1((retained) => require_dist.isNone(retained.v8) && require_dist.isNone(retained.v9) ? require_dist._void : require_dist.toEffect(keysFor(retained)).pipe(require_dist.flatMap$1((aux) => running.startSyncInBackground(aux)))));
+		}
+		/**
+		* Whether the activation watcher has been registered.
+		*
+		* @remarks
+		*   Registration is per wallet, not per `start`: watchers accumulate, so registering on every call would restart sync
+		*   once per historical `start` on the next activation. Flipped with `getAndSet` so concurrent `start` calls cannot
+		*   both observe it unset.
+		*/
+		#watcherRegistered = require_dist.unsafeMake(false);
+		constructor(runtime, scope) {
+			super(runtime, scope);
+			this.state = this.rawState.pipe(rxjs.map((emission) => emission.variantTag === V2Tag ? ShieldedWalletState.fromVariant(variants[V2Tag].variant, emission) : ShieldedWalletState.fromVariant(variants[V1Tag].variant, emission)), rxjs.shareReplay({
+				refCount: true,
+				bufferSize: 1
+			}));
+		}
+		/**
+		* Everything a start does once the wallet holds its key material: watch for the next variant, synchronize on this
+		* one.
+		*
+		* @remarks
+		*   The same work whichever start was called — what the three differ in is only what they retained a moment earlier —
+		*   so it is stated once. The watcher is registered before the first dispatch and only once per wallet:
+		*   `onVariantActivation` resolves only after its subscription is live, so an activation racing a start is queued
+		*   rather than missed, and watchers accumulate, so registering per call would restart synchronization once per
+		*   historical start.
+		*
+		*   Both branches of the dispatch resolve their keys from what was retained rather than from what the caller passed,
+		*   because the variant that is current is not the caller's to know: a wallet restored below the boundary is on the
+		*   ledger-v8 one whatever the application holds.
+		*/
+		#startSynchronizing() {
+			return require_dist.gen(this, function* () {
+				if (!(yield* require_dist.getAndSet(this.#watcherRegistered, true))) yield* this.runtime.onVariantActivation({
+					[V1Tag]: (v1) => this.#resumeSyncOn(v1, v8Aux),
+					[V2Tag]: (v2) => this.#resumeSyncOn(v2, v9Aux)
+				});
+				yield* this.runtime.dispatch({
+					[V1Tag]: (v1) => this.#resumeSyncOn(v1, v8Aux),
+					[V2Tag]: (v2) => this.#resumeSyncOn(v2, v9Aux)
+				});
+			});
+		}
+		/**
+		* Starts background synchronization on whichever variant is current, and keeps the keys for the next one.
+		*
+		* @remarks
+		*   The keys are ledger-v9's, so they are retained against that variant alone and answer for it alone. A wallet still
+		*   on the V1 variant is started from whatever it holds for _that_ side — which a wallet built from a seed, or from
+		*   both versions' keys, can always answer and one holding only these cannot.
+		*
+		*   That is the position of a wallet restored from a snapshot written below the boundary: a snapshot carries no key
+		*   material, so these keys leave it with nothing the running variant can use, and it says so rather than
+		*   pretending to have started. {@link ForkingShieldedWallet.startWithSeed} and
+		*   {@link ForkingShieldedWallet.startWithKeys} are the same wallet started with material that answers for either
+		*   side.
+		* @param secretKeys The ledger-v9's Zswap secret keys.
+		*/
+		start(secretKeys) {
+			return require_dist.gen(this, function* () {
+				yield* require_dist.update(this.#retainedKeys, (retained) => ({
+					...retained,
+					v9: require_dist.some(secretKeys)
+				}));
+				yield* this.#startSynchronizing();
+			}).pipe(require_dist.runPromise$1);
+		}
+		startWithSeed(seed) {
+			return require_dist.gen(this, function* () {
+				yield* require_dist.set(this.#retainedKeys, keysFromSeed(require_dist.WalletSeed(seed)));
+				yield* this.#startSynchronizing();
+			}).pipe(require_dist.runPromise$1);
+		}
+		startWithKeys(keys) {
+			return require_dist.gen(this, function* () {
+				yield* require_dist.set(this.#retainedKeys, {
+					v8: require_dist.some(keys.v8),
+					v9: require_dist.some(keys.v9)
+				});
+				yield* this.#startSynchronizing();
+			}).pipe(require_dist.runPromise$1);
+		}
+		async stop() {
+			require_dist.set(this.#retainedKeys, noKeys).pipe(require_dist.runSync);
+			await super.stop();
+		}
+		/**
+		* The key material the variant that is current can use, from what this wallet retained.
+		*
+		* @remarks
+		*   Transacting needs the same secrets synchronization does, and for the same reason: coin selection reads coins only
+		*   their owner can decrypt. A wallet that was never started, or one holding key objects of the other ledger
+		*   version, has none the current variant can use and says so by name.
+		*/
+		#requireAux(keysFor) {
+			return require_dist.get$1(this.#retainedKeys).pipe(require_dist.flatMap$1((retained) => require_dist.toEffect(keysFor(retained))));
+		}
+		/**
+		* Balances a transaction with shielded coins, on whichever side of the boundary it was built.
+		*
+		* @param tx The transaction to balance, which must have been built in the epoch this wallet is currently in.
+		* @returns The balancing transaction, stamped with the version it was built at, or nothing when none is needed.
+		*/
+		balanceTransaction(tx) {
+			return this.runtime.dispatch({
+				[V1Tag]: (v1) => require_dist.all([this.#requireAux(v8Aux), require_dist.toEffect(require_dist.WalletTransaction.unwrapWithin(tx, v8Epoch))]).pipe(require_dist.flatMap$1(([keys, unwrapped]) => v1.balanceTransaction(keys, unwrapped)), require_dist.map$2(sealV8)),
+				[V2Tag]: (v2) => require_dist.all([this.#requireAux(v9Aux), require_dist.toEffect(require_dist.WalletTransaction.unwrapWithin(tx, v9Epoch))]).pipe(require_dist.flatMap$1(([keys, unwrapped]) => v2.balanceTransaction(keys, unwrapped)), require_dist.map$2(sealV9))
+			}).pipe(require_dist.runPromise$1);
+		}
+		transferTransaction(outputs) {
+			return this.runtime.dispatch({
+				[V1Tag]: (v1) => this.#requireAux(v8Aux).pipe(require_dist.flatMap$1((keys) => v1.transferTransaction(keys, outputs)), require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unproven", tx, v8Stamp))),
+				[V2Tag]: (v2) => this.#requireAux(v9Aux).pipe(require_dist.flatMap$1((keys) => v2.transferTransaction(keys, outputs)), require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unproven", tx, v9Stamp)))
+			}).pipe(require_dist.runPromise$1);
+		}
+		initSwap(desiredInputs, desiredOutputs) {
+			return this.runtime.dispatch({
+				[V1Tag]: (v1) => this.#requireAux(v8Aux).pipe(require_dist.flatMap$1((keys) => v1.initSwap(keys, desiredInputs, desiredOutputs)), require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unproven", tx, v8Stamp))),
+				[V2Tag]: (v2) => this.#requireAux(v9Aux).pipe(require_dist.flatMap$1((keys) => v2.initSwap(keys, desiredInputs, desiredOutputs)), require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unproven", tx, v9Stamp)))
+			}).pipe(require_dist.runPromise$1);
+		}
+		/**
+		* Un-records a transaction this wallet produced, releasing the coins it had booked.
+		*
+		* @remarks
+		*   A transaction built on the other side of the boundary is not one the current variant could have booked coins for,
+		*   so there is nothing of it to release and this resolves having done nothing. That is the one place a version
+		*   mismatch is not an error: the facade reverts all three wallets together when a submission fails, and a refusal
+		*   here would strand that whole path over a transaction this wallet was never holding anything for.
+		*
+		*   The coins a ledger-v8 transaction did book are not left behind by that no-op: they crossed the boundary as
+		*   reservations, and the first sync update after the crossing releases every one of them, because no transaction
+		*   of that ledger version can be included any more (`v2/CoreWallet.completeCrossing`).
+		* @param transaction The transaction to un-record.
+		*/
+		revertTransaction(transaction) {
+			return this.runtime.dispatch({
+				[V1Tag]: (v1) => require_dist.match$2(require_dist.WalletTransaction.unwrapWithin(transaction, v8Epoch), {
+					onLeft: () => require_dist._void,
+					onRight: (unwrapped) => v1.revertTransaction(unwrapped)
+				}),
+				[V2Tag]: (v2) => require_dist.match$2(require_dist.WalletTransaction.unwrapWithin(transaction, v9Epoch), {
+					onLeft: () => require_dist._void,
+					onRight: (unwrapped) => v2.revertTransaction(unwrapped)
+				})
+			}).pipe(require_dist.runPromise$1);
+		}
+		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);
+		}
+	};
+}
+/**
+* Builds the shielded wallet this package ships: the default variant either side of `configuration.forks.v9`.
+*
+* @remarks
+*   Both variants read the chain through the indexer and record transaction history in the same storage; each is built
+*   from the same application configuration, because what they ask for happens to coincide. The V2 variant is
+*   registered with the cross-ledger migration, which is what makes the hand-over carry identity and a cursor onto a
+*   fresh state rather than start a wallet from nothing.
+*
+*   **Transacting works on either side of the boundary**: the active variant builds with its own ledger and its own
+*   derived keys, and every result travels as a handle stamped with the epoch that built it. Proving a ledger-v8
+*   transaction still requires a proving server registered below the boundary.
+*
+*   **The chain is asked where it is before a variant is chosen.** The indexer this wallet already syncs from answers
+*   which protocol version the chain is on, so a start on a chain past the boundary begins on V2 rather than handing
+*   over immediately. An application that would rather ask something else — a cache, a value it already holds —
+*   supplies its own `chainVersionProbe`; one whose chain cannot be reached loses nothing, because the answer is
+*   best-effort and its absence is the behaviour this wallet had before.
+* @param configuration What the wallet and both its variants are built from, including where the boundary lies.
+* @returns The wallet class.
+*/
+function ShieldedWallet(configuration) {
+	return CustomForkingShieldedWallet({
+		...configuration,
+		chainVersionProbe: configuration.chainVersionProbe ?? require_dist.makeIndexerChainVersionProbe(configuration)
+	}, {
+		builder: new V1Builder().withDefaults(),
+		configuration
+	}, {
+		builder: new V2Builder().withDefaults().withMigration(() => makeCrossLedgerMigration()),
+		configuration
+	});
+}
+//#endregion
+exports.CustomForkingShieldedWallet = CustomForkingShieldedWallet;
+exports.CustomShieldedWallet = CustomShieldedWallet;
+Object.defineProperty(exports, "Restore", {
+	enumerable: true,
+	get: function() {
+		return Restore_exports;
+	}
+});
+exports.ShieldedSectionSchema = ShieldedSectionSchema;
+exports.ShieldedSectionSchema$1 = ShieldedSectionSchema;
+exports.ShieldedWallet = ShieldedWallet;
+exports.ShieldedWalletState = ShieldedWalletState;
+exports.V9_NATIVE_FORK_VERSION = V9_NATIVE_FORK_VERSION;
+exports.mergeShieldedSections = mergeShieldedSections;
+exports.mergeShieldedSections$1 = mergeShieldedSections;