@laceio/sdk 0.1.1 → 0.1.2-canary.0

package/dist/dist-CykEjYEX.cjs

@@ -0,0 +1,3814 @@
+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");
+const require_v8Signatures = require("./v8Signatures-CO_Uloy7.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/effect/dist/esm/internal/matcher.js
+/** @internal */
+const TypeId = /* @__PURE__ */ Symbol.for("@effect/matcher/Matcher");
+const TypeMatcherProto = {
+	[TypeId]: {
+		_input: require_dist.identity,
+		_filters: require_dist.identity,
+		_remaining: require_dist.identity,
+		_result: require_dist.identity,
+		_return: require_dist.identity
+	},
+	_tag: "TypeMatcher",
+	add(_case) {
+		return makeTypeMatcher([...this.cases, _case]);
+	},
+	pipe() {
+		return require_dist.pipeArguments(this, arguments);
+	}
+};
+function makeTypeMatcher(cases) {
+	const matcher = Object.create(TypeMatcherProto);
+	matcher.cases = cases;
+	return matcher;
+}
+const ValueMatcherProto = {
+	[TypeId]: {
+		_input: require_dist.identity,
+		_filters: require_dist.identity,
+		_remaining: require_dist.identity,
+		_result: require_dist.identity,
+		_provided: require_dist.identity,
+		_return: require_dist.identity
+	},
+	_tag: "ValueMatcher",
+	add(_case) {
+		if (this.value._tag === "Right") return this;
+		if (_case._tag === "When" && _case.guard(this.provided) === true) return makeValueMatcher(this.provided, require_dist.right(_case.evaluate(this.provided)));
+		else if (_case._tag === "Not" && _case.guard(this.provided) === false) return makeValueMatcher(this.provided, require_dist.right(_case.evaluate(this.provided)));
+		return this;
+	},
+	pipe() {
+		return require_dist.pipeArguments(this, arguments);
+	}
+};
+function makeValueMatcher(provided, value) {
+	const matcher = Object.create(ValueMatcherProto);
+	matcher.provided = provided;
+	matcher.value = value;
+	return matcher;
+}
+const makeWhen = (guard, evaluate) => ({
+	_tag: "When",
+	guard,
+	evaluate
+});
+const makePredicate = (pattern) => {
+	if (typeof pattern === "function") return pattern;
+	else if (Array.isArray(pattern)) {
+		const predicates = pattern.map(makePredicate);
+		const len = predicates.length;
+		return (u) => {
+			if (!Array.isArray(u)) return false;
+			for (let i = 0; i < len; i++) if (predicates[i](u[i]) === false) return false;
+			return true;
+		};
+	} else if (pattern !== null && typeof pattern === "object") {
+		const keysAndPredicates = Object.entries(pattern).map(([k, p]) => [k, makePredicate(p)]);
+		const len = keysAndPredicates.length;
+		return (u) => {
+			if (typeof u !== "object" || u === null) return false;
+			for (let i = 0; i < len; i++) {
+				const [key, predicate] = keysAndPredicates[i];
+				if (!(key in u) || predicate(u[key]) === false) return false;
+			}
+			return true;
+		};
+	}
+	return (u) => u === pattern;
+};
+/** @internal */
+const value$1 = (i) => makeValueMatcher(i, require_dist.left(i));
+/** @internal */
+const when$1 = (pattern, f) => (self) => self.add(makeWhen(makePredicate(pattern), f));
+/** @internal */
+const discriminators$1 = (field) => (fields) => {
+	const predicate = makeWhen((arg) => arg != null && arg[field] in fields, (data) => fields[data[field]](data));
+	return (self) => self.add(predicate);
+};
+/** @internal */
+const discriminatorsExhaustive$1 = (field) => (fields) => {
+	const addCases = discriminators$1(field)(fields);
+	return (matcher) => exhaustive$1(addCases(matcher));
+};
+/** @internal */
+const either$1 = (self) => {
+	if (self._tag === "ValueMatcher") return self.value;
+	const len = self.cases.length;
+	if (len === 1) {
+		const _case = self.cases[0];
+		return (input) => {
+			if (_case._tag === "When" && _case.guard(input) === true) return require_dist.right(_case.evaluate(input));
+			else if (_case._tag === "Not" && _case.guard(input) === false) return require_dist.right(_case.evaluate(input));
+			return require_dist.left(input);
+		};
+	}
+	return (input) => {
+		for (let i = 0; i < len; i++) {
+			const _case = self.cases[i];
+			if (_case._tag === "When" && _case.guard(input) === true) return require_dist.right(_case.evaluate(input));
+			else if (_case._tag === "Not" && _case.guard(input) === false) return require_dist.right(_case.evaluate(input));
+		}
+		return require_dist.left(input);
+	};
+};
+const getExhaustiveAbsurdErrorMessage = "effect/Match/exhaustive: absurd";
+/** @internal */
+const exhaustive$1 = (self) => {
+	const toEither = either$1(self);
+	if (require_dist.isEither(toEither)) {
+		if (toEither._tag === "Right") return toEither.right;
+		throw new Error(getExhaustiveAbsurdErrorMessage);
+	}
+	return (u) => {
+		const result = toEither(u);
+		if (result._tag === "Right") return result.right;
+		throw new Error(getExhaustiveAbsurdErrorMessage);
+	};
+};
+/**
+* Creates a matcher from a specific value.
+*
+* **Details**
+*
+* This function allows you to define a `Matcher` directly from a given value,
+* rather than from a type. This is useful when working with known values,
+* enabling structured pattern matching on objects, primitives, or any data
+* structure.
+*
+* Once the matcher is created, you can use pattern-matching functions like
+* {@link when} to define how different cases should be handled.
+*
+* **Example** (Matching an Object by Property)
+*
+* ```ts
+* import { Match } from "effect"
+*
+* const input = { name: "John", age: 30 }
+*
+* // Create a matcher for the specific object
+* const result = Match.value(input).pipe(
+*   // Match when the 'name' property is "John"
+*   Match.when(
+*     { name: "John" },
+*     (user) => `${user.name} is ${user.age} years old`
+*   ),
+*   // Provide a fallback if no match is found
+*   Match.orElse(() => "Oh, not John")
+* )
+*
+* console.log(result)
+* // Output: "John is 30 years old"
+* ```
+*
+* @see {@link type} for creating a matcher from a specific type.
+*
+* @category Creating a matcher
+* @since 1.0.0
+*/
+const value = value$1;
+/**
+* Defines a condition for matching values.
+*
+* **Details**
+*
+* This function enables pattern matching by checking whether a given value
+* satisfies a condition. It supports both direct value comparisons and
+* predicate functions. If the condition is met, the associated function is
+* executed.
+*
+* This function is useful when defining matchers that need to check for
+* specific values or apply logical conditions to determine a match. It works
+* well with structured objects and primitive types.
+*
+* **Example** (Matching with Values and Predicates)
+*
+* ```ts
+* import { Match } from "effect"
+*
+* // Create a matcher for objects with an "age" property
+* const match = Match.type<{ age: number }>().pipe(
+*   // Match when age is greater than 18
+*   Match.when({ age: (age) => age > 18 }, (user) => `Age: ${user.age}`),
+*   // Match when age is exactly 18
+*   Match.when({ age: 18 }, () => "You can vote"),
+*   // Fallback case for all other ages
+*   Match.orElse((user) => `${user.age} is too young`)
+* )
+*
+* console.log(match({ age: 20 }))
+* // Output: "Age: 20"
+*
+* console.log(match({ age: 18 }))
+* // Output: "You can vote"
+*
+* console.log(match({ age: 4 }))
+* // Output: "4 is too young"
+* ```
+*
+* @see {@link whenOr} Use this when multiple patterns should match in a single
+* condition.
+* @see {@link whenAnd} Use this when a value must match all provided patterns.
+* @see {@link orElse} Provides a fallback when no patterns match.
+*
+* @category Defining patterns
+* @since 1.0.0
+*/
+const when = when$1;
+/**
+* Matches values based on a discriminator field and **ensures all cases are
+* handled**.
+*
+* **Details*+
+*
+* This function is similar to {@link discriminators}, but **requires that all
+* possible cases** are explicitly handled. It is useful when working with
+* discriminated unions, where a specific field (e.g., `"type"`) determines the
+* shape of an object. Each possible value of the field must have a
+* corresponding handler, ensuring **exhaustiveness checking** at compile time.
+*
+* This function **does not require** `Match.exhaustive` at the end of the
+* pipeline because it enforces exhaustiveness by design.
+*
+* @example
+* ```ts
+* import { Match, pipe } from "effect"
+*
+* const match = pipe(
+*   Match.type<{ type: "A"; a: string } | { type: "B"; b: number } | { type: "C"; c: boolean }>(),
+*   Match.discriminatorsExhaustive("type")({
+*     A: (a) => a.a,
+*     B: (b) => b.b,
+*     C: (c) => c.c
+*   })
+* )
+* ```
+*
+* @category Defining patterns
+* @since 1.0.0
+*/
+const discriminatorsExhaustive = discriminatorsExhaustive$1;
+require_dist.isString;
+require_dist.isNumber;
+require_dist.isBoolean;
+require_dist.isUndefined;
+require_dist.isNull;
+require_dist.isBigInt;
+require_dist.isSymbol;
+require_dist.isDate;
+require_dist.isRecord;
+/**
+* The `Match.exhaustive` method finalizes the pattern matching process by
+* ensuring that all possible cases are accounted for. If any case is missing,
+* TypeScript will produce a type error. This is particularly useful when
+* working with unions, as it helps prevent unintended gaps in pattern matching.
+*
+* **Example** (Ensuring All Cases Are Covered)
+*
+* ```ts
+* import { Match } from "effect"
+*
+* // Create a matcher for string or number values
+* const match = Match.type<string | number>().pipe(
+*   // Match when the value is a number
+*   Match.when(Match.number, (n) => `number: ${n}`),
+*   // Mark the match as exhaustive, ensuring all cases are handled
+*   // TypeScript will throw an error if any case is missing
+*   // @ts-expect-error Type 'string' is not assignable to type 'never'
+*   Match.exhaustive
+* )
+* ```
+*
+* @category Completion
+* @since 1.0.0
+*/
+const exhaustive = exhaustive$1;
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/UnshieldedWalletAPI.js
+var UnshieldedWalletState = class UnshieldedWalletState {
+	/**
+	* 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 UnshieldedWalletState(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),
+		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 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();
+	}
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v2/RunningV2Variant.js
+const progress$1 = (state) => {
+	const appliedId = state.progress?.appliedId ?? 0n;
+	const sourceGap = (state.progress?.highestTransactionId ?? 0n) - appliedId;
+	const applyGap = appliedId - appliedId;
+	return [require_dist.ProgressUpdate({
+		sourceGap,
+		applyGap
+	})];
+};
+/**
+* The version signals this variant puts on its state stream.
+*
+* @remarks
+*   Two of them, for two different situations. A transition is the ordinary one: the state moved to a version the variant
+*   may or may not own, and the runtime decides. The healing emission covers restore: a snapshot taken between the
+*   moment sync annotated an out-of-range version and the moment the runtime acted on it comes back with a version this
+*   variant does not own and no transition to announce it, so it would sit there forever. Announcing it on the first
+*   observation is what forward-migrates such a snapshot.
+*/
+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;
+	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() {
+		return this.startSync().pipe(require_dist.runScoped(require_dist.drain), require_dist.forkScoped, require_dist.provideService(require_dist.Scope, this.#scope));
+	}
+	startSync() {
+		return require_dist.pipe(require_dist.get(this.#context.stateRef), require_dist.fromEffect, require_dist.flatMap((state) => this.#v2Context.syncService.updates(state)), require_dist.mapEffect((update) => {
+			return require_dist.updateEffect(this.#context.stateRef, (state) => require_dist.pipe(this.#v2Context.syncCapability.applyUpdate(state, update, this.#context.activationRange), require_dist.toEffect));
+		}), 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)));
+		}))));
+	}
+	balanceFinalizedTransaction(tx) {
+		return require_dist.modifyEffect(this.#context.stateRef, (state) => {
+			return require_dist.pipe(this.#v2Context.transactingCapability.balanceFinalizedTransaction(state, tx), require_dist.toEffect);
+		});
+	}
+	balanceUnboundTransaction(tx) {
+		return require_dist.modifyEffect(this.#context.stateRef, (state) => {
+			return require_dist.pipe(this.#v2Context.transactingCapability.balanceUnboundTransaction(state, tx), require_dist.toEffect);
+		});
+	}
+	balanceUnprovenTransaction(tx) {
+		return require_dist.modifyEffect(this.#context.stateRef, (state) => {
+			return require_dist.pipe(this.#v2Context.transactingCapability.balanceUnprovenTransaction(state, tx), require_dist.toEffect);
+		});
+	}
+	transferTransaction(outputs, ttl) {
+		return require_dist.modifyEffect(this.#context.stateRef, (state) => {
+			return require_dist.pipe(this.#v2Context.transactingCapability.makeTransfer(state, outputs, ttl), require_dist.toEffect, require_dist.map$2(({ transaction, newState }) => [transaction, newState]));
+		});
+	}
+	rotateUtxos(guaranteedUtxos, fallibleUtxos, nightVerifyingKey, ttl) {
+		return require_dist.modifyEffect(this.#context.stateRef, (state) => {
+			return require_dist.pipe(this.#v2Context.transactingCapability.rotateUtxos(state, guaranteedUtxos, fallibleUtxos, nightVerifyingKey, ttl), require_dist.toEffect, require_dist.map$2(({ transaction, newState }) => [transaction, newState]));
+		});
+	}
+	initSwap(desiredInputs, desiredOutputs, ttl) {
+		return require_dist.modifyEffect(this.#context.stateRef, (state) => {
+			return require_dist.pipe(this.#v2Context.transactingCapability.initSwap(state, desiredInputs, desiredOutputs, ttl), require_dist.map$2(({ transaction, newState }) => [transaction, newState]));
+		});
+	}
+	signUnprovenTransaction(transaction, signSegment) {
+		return this.#v2Context.signingService.sign(transaction, signSegment);
+	}
+	signUnboundTransaction(transaction, signSegment) {
+		return this.#v2Context.signingService.sign(transaction, signSegment);
+	}
+	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-unshielded-wallet/dist/v2/WalletError.js
+var OtherWalletError$1 = class extends require_dist.TaggedError("Wallet.Other") {};
+var SyncWalletError$1 = class extends require_dist.TaggedError("Wallet.Sync") {};
+var InsufficientFundsError$1 = class extends require_dist.TaggedError("Wallet.InsufficientFunds") {};
+var TransactingError$1 = class extends require_dist.TaggedError("Wallet.Transacting") {};
+var SignError$1 = class extends require_dist.TaggedError("Wallet.Sign") {};
+/**
+* Raised when a signature scheme (`schnorr` vs `ecdsa`) is mixed across an unshielded key, address, or signature.
+* Mismatches are rejected early — at wallet construction or at signature provision — never silently coerced. The `at`
+* field records where the mismatch was caught.
+*/
+var SchemeMismatchError = class extends require_dist.TaggedError("Wallet.SchemeMismatch") {};
+var ApplyTransactionError$1 = class extends require_dist.TaggedError("Wallet.ApplyTransaction") {};
+/**
+* Raised when a sync source delivers a transaction the wallet has already folded — an id strictly below its applied
+* cursor — so applying it again would double-count the UTXOs that transaction created or spent.
+*
+* @remarks
+*   The id a wallet is served is the indexer's global transaction id filtered to this address, so what reaches it is a
+*   strictly increasing but sparse subsequence: "is this past my cursor?" is the only ordering question it can answer,
+*   and contiguity is not one of them. An id EQUAL to the cursor is the resume boundary answered inclusively and folds
+*   to a no-op rather than to this error; only a strictly lower one is a replay.
+*
+*   Nothing is written when it is produced. The fold hands this back in place of a new state, so the running variant
+*   never writes its `SubscriptionRef`: the wallet keeps the state and the cursor it had, the sync stream fails, and
+*   the retry reopens the subscription at that same unmoved cursor — which is what gives the source the chance to
+*   deliver the timeline in order.
+* @example
+*   ```ts
+*   import { Either } from 'effect';
+*
+*   const outcome = capability.applyUpdate(wallet, update, activeRange);
+*   if (Either.isLeft(outcome) && outcome.left._tag === 'Wallet.OutOfOrderSyncUpdate') {
+*   console.warn(`replayed ${outcome.left.received}, already at ${outcome.left.expected}`);
+*   }
+*   ```
+*/
+var OutOfOrderSyncUpdateError$1 = class extends require_dist.TaggedError("Wallet.OutOfOrderSyncUpdate") {};
+var RollbackUtxoError$1 = class extends require_dist.TaggedError("Wallet.RollbackUtxo") {};
+var SpendUtxoError$1 = class extends require_dist.TaggedError("Wallet.SpendUtxo") {};
+var TransactionHistoryError$1 = class extends require_dist.TaggedError("Wallet.TransactionHistory") {};
+var UtxoNotFoundError$1 = class extends require_dist.TaggedError("UtxoNotFoundError") {};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/SchemeConsistency.js
+const otherScheme = (kind) => kind === "schnorr" ? "ecdsa" : "schnorr";
+/**
+* Asserts that a {@link PublicKey}'s stored address was derived from its stored verifying key. A `schnorr` address
+* bundled with an `ecdsa` key (or the inverse) is rejected at wallet construction.
+*
+* @param publicKey - The keystore-derived public key bundle to validate.
+* @returns `Right(publicKey)` when the address matches the key; `Left(SchemeMismatchError)` tagged `at: 'construction'`
+*   when it does not; or `Left(OtherWalletError)` when the key cannot be decoded at all.
+*/
+const assertKeyAddressConsistency$1 = (publicKey) => require_dist.pipe(require_dist.try_$1({
+	try: () => (0, _midnightntwrk_ledger_v9.addressFromKey)(publicKey.publicKey),
+	catch: (cause) => new OtherWalletError$1({
+		message: `Unshielded verifying key could not be decoded as a ${publicKey.publicKey.tag} key.`,
+		cause
+	})
+}), require_dist.flatMap$4((derivedAddress) => {
+	if (derivedAddress === publicKey.addressHex) return require_dist.right(publicKey);
+	const supplied = publicKey.publicKey.tag;
+	const expected = otherScheme(supplied);
+	return require_dist.left(new SchemeMismatchError({
+		at: "construction",
+		expected,
+		supplied,
+		message: `Unshielded address does not match its verifying key: the address is derived under the ${expected} scheme but the supplied key is ${supplied}. Signature schemes must not be mixed.`
+	}));
+}));
+/**
+* Asserts that a supplied signature shares the scheme of the verifying key it will be checked against. Used at
+* signature-provision time so a `schnorr` signature can never be attached under an `ecdsa` key (or the inverse).
+*
+* @param key - The verifying key the signature must match.
+* @param signature - The supplied signature.
+* @returns `Right(signature)` (unchanged — no coercion) when the schemes match; otherwise `Left(SchemeMismatchError)`
+*   tagged `at: 'signature-provision'`, with `expected` = the key's scheme and `supplied` = the signature's scheme.
+*/
+const assertSignatureMatchesKey = (key, signature) => {
+	if (key.tag === signature.tag) return require_dist.right(signature);
+	return require_dist.left(new SchemeMismatchError({
+		at: "signature-provision",
+		expected: key.tag,
+		supplied: signature.tag,
+		message: `Signature scheme does not match the signing key: expected a ${key.tag} signature but a ${signature.tag} signature was supplied. Signature schemes must not be mixed.`
+	}));
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v2/SyncProgress.js
+const SyncProgress$1 = { isCompleteWithin(data, maxGap = 50n) {
+	const applyLag = BigInt(Math.abs(Number(data.highestTransactionId - data.appliedId)));
+	return data.isConnected && applyLag <= maxGap;
+} };
+const createSyncProgress$1 = (params = {}) => {
+	const { appliedId = 0n, highestTransactionId = 0n, isConnected = false } = params;
+	return {
+		appliedId,
+		highestTransactionId,
+		isConnected,
+		isStrictlyComplete() {
+			return SyncProgress$1.isCompleteWithin(this, 0n);
+		},
+		isCompleteWithin(maxGap) {
+			return SyncProgress$1.isCompleteWithin(this, maxGap);
+		}
+	};
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v2/UnshieldedState.js
+var UtxoWithMeta = class extends require_dist.Class {};
+const UtxoHash$1 = (utxo) => `${utxo.intentHash}#${utxo.outputNo}`;
+/**
+* The first UTXO an update reports as spent that this state holds in neither map.
+*
+* @remarks
+*   A spend naming a UTXO the wallet has never held is not noise to absorb: it is the only observable sign that the
+*   source delivered a spend ahead of the create it consumes. Absorbed, the create arrives afterwards and puts an
+*   already-spent UTXO into the available set, where it will be offered for coin selection and produce a transaction
+*   the chain rejects. Reported, the fold fails before the caller's cursor moves, and the retry re-fetches the pair in
+*   order.
+* @param state The state the update is being folded into.
+* @param spentUtxos The UTXOs the update reports as spent.
+* @returns The first entry the state does not know, or `Option.none()` when every spend names a UTXO it holds.
+*/
+const firstUnknownSpend$1 = (state, spentUtxos) => require_dist.findFirst(spentUtxos, (spent) => {
+	const hash = UtxoHash$1(spent.utxo);
+	return !require_dist.has(state.availableUtxos, hash) && !require_dist.has(state.pendingUtxos, hash);
+});
+const UnshieldedState$1 = {
+	empty: () => ({
+		availableUtxos: require_dist.empty$1(),
+		pendingUtxos: require_dist.empty$1()
+	}),
+	restore: (availableUtxos, pendingUtxos) => ({
+		availableUtxos: require_dist.fromIterable(availableUtxos.map((utxo) => [UtxoHash$1(utxo.utxo), utxo])),
+		pendingUtxos: require_dist.fromIterable(pendingUtxos.map((utxo) => [UtxoHash$1(utxo.utxo), utxo]))
+	}),
+	spend: (state, utxo) => require_dist.gen$1(function* () {
+		const hash = UtxoHash$1(utxo.utxo);
+		if (!require_dist.has(state.availableUtxos, hash)) return yield* require_dist.left(new UtxoNotFoundError$1({ utxo: utxo.utxo }));
+		return {
+			availableUtxos: require_dist.remove(state.availableUtxos, hash),
+			pendingUtxos: require_dist.set$1(state.pendingUtxos, hash, utxo)
+		};
+	}),
+	rollbackSpend: (state, utxo) => {
+		const hash = UtxoHash$1(utxo.utxo);
+		if (!require_dist.has(state.pendingUtxos, hash)) return require_dist.right(state);
+		return require_dist.right({
+			availableUtxos: require_dist.set$1(state.availableUtxos, hash, utxo),
+			pendingUtxos: require_dist.remove(state.pendingUtxos, hash)
+		});
+	},
+	spendByUtxo: (state, utxo) => require_dist.gen$1(function* () {
+		const hash = UtxoHash$1(utxo);
+		const found = yield* require_dist.fromOption(require_dist.get$2(state.availableUtxos, hash), () => new UtxoNotFoundError$1({ utxo }));
+		return yield* UnshieldedState$1.spend(state, found);
+	}),
+	rollbackSpendByUtxo: (state, utxo) => require_dist.pipe(require_dist.get$2(state.pendingUtxos, UtxoHash$1(utxo)), require_dist.match$1({
+		onNone: () => require_dist.right(state),
+		onSome: (found) => UnshieldedState$1.rollbackSpend(state, found)
+	})),
+	applyUpdate: (state, update) => require_dist.gen$1(function* () {
+		if (!["SUCCESS", "PARTIAL_SUCCESS"].includes(update.status)) return yield* require_dist.left(new ApplyTransactionError$1({ message: `Invalid status: ${update.status}` }));
+		const unknownSpend = firstUnknownSpend$1(state, update.spentUtxos);
+		if (require_dist.isSome(unknownSpend)) return yield* require_dist.left(new UtxoNotFoundError$1({ utxo: unknownSpend.value.utxo }));
+		return {
+			availableUtxos: require_dist.union$1(require_dist.removeMany(state.availableUtxos, update.spentUtxos.map((utxo) => UtxoHash$1(utxo.utxo))), require_dist.fromIterable(update.createdUtxos.map((utxo) => [UtxoHash$1(utxo.utxo), utxo]))),
+			pendingUtxos: require_dist.removeMany(state.pendingUtxos, update.spentUtxos.map((utxo) => UtxoHash$1(utxo.utxo)))
+		};
+	}),
+	applyFailedUpdate: (state, update) => require_dist.gen$1(function* () {
+		if (update.status !== "FAILURE") return yield* require_dist.left(new ApplyTransactionError$1({ message: `Invalid status: ${update.status}` }));
+		const unknownSpend = firstUnknownSpend$1(state, update.spentUtxos);
+		if (require_dist.isSome(unknownSpend)) return yield* require_dist.left(new UtxoNotFoundError$1({ utxo: unknownSpend.value.utxo }));
+		return {
+			availableUtxos: require_dist.union$1(state.availableUtxos, require_dist.fromIterable(update.spentUtxos.map((utxo) => [UtxoHash$1(utxo.utxo), utxo]))),
+			pendingUtxos: require_dist.removeMany(state.pendingUtxos, update.spentUtxos.map((utxo) => UtxoHash$1(utxo.utxo)))
+		};
+	}),
+	toArrays: (state) => ({
+		availableUtxos: require_dist.toValues(state.availableUtxos),
+		pendingUtxos: require_dist.toValues(state.pendingUtxos)
+	})
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v2/CoreWallet.js
+const CoreWallet$1 = {
+	init(publicKey, networkId) {
+		return {
+			state: UnshieldedState$1.empty(),
+			publicKey,
+			protocolVersion: require_dist.MinSupportedVersion,
+			progress: createSyncProgress$1(),
+			networkId
+		};
+	},
+	restore(state, publicKey, syncProgress, protocolVersion, networkId) {
+		return {
+			state,
+			publicKey,
+			protocolVersion,
+			progress: createSyncProgress$1(syncProgress),
+			networkId
+		};
+	},
+	updateProgress(wallet, { appliedId, highestTransactionId, isConnected }) {
+		const progress = createSyncProgress$1({
+			appliedId: appliedId ?? wallet.progress.appliedId,
+			highestTransactionId: highestTransactionId ?? wallet.progress.highestTransactionId,
+			isConnected: isConnected ?? wallet.progress.isConnected
+		});
+		return {
+			...wallet,
+			progress
+		};
+	},
+	withProtocolVersion(wallet, version) {
+		return version > wallet.protocolVersion ? {
+			...wallet,
+			protocolVersion: version
+		} : wallet;
+	},
+	applyUpdate(coreWallet, update) {
+		return UnshieldedState$1.applyUpdate(coreWallet.state, update).pipe(require_dist.map$6((state) => ({
+			...coreWallet,
+			state
+		})), require_dist.mapLeft((error) => new ApplyTransactionError$1(error)));
+	},
+	applyFailedUpdate(coreWallet, update) {
+		return UnshieldedState$1.applyFailedUpdate(coreWallet.state, update).pipe(require_dist.map$6((state) => ({
+			...coreWallet,
+			state
+		})), require_dist.mapLeft((error) => new ApplyTransactionError$1(error)));
+	},
+	rollbackUtxo(coreWallet, utxo) {
+		return UnshieldedState$1.rollbackSpendByUtxo(coreWallet.state, utxo).pipe(require_dist.map$6((state) => ({
+			...coreWallet,
+			state
+		})), require_dist.mapLeft((error) => new RollbackUtxoError$1(error)));
+	},
+	spend(coreWallet, utxo) {
+		return UnshieldedState$1.spendByUtxo(coreWallet.state, utxo).pipe(require_dist.map$6((state) => ({
+			...coreWallet,
+			state
+		})), require_dist.mapLeft((error) => new SpendUtxoError$1(error)));
+	},
+	spendUtxos(wallet, utxos) {
+		return require_dist.pipe(utxos, require_dist.reduce(require_dist.right([[], wallet.state]), (acc, utxoToSpend) => acc.pipe(require_dist.flatMap$4(([accUtxos, state]) => UnshieldedState$1.spendByUtxo(state, utxoToSpend).pipe(require_dist.map$6((nextState) => [accUtxos.concat([utxoToSpend]), nextState]), require_dist.mapLeft((error) => new SpendUtxoError$1(error)))))), require_dist.map$6(([spentUtxos, state]) => [spentUtxos, {
+			...wallet,
+			state
+		}]));
+	}
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v2/Serialization.js
+const makeDefaultV2SerializationCapability = () => {
+	const SignatureKindSchema = require_dist.Literal("schnorr", "ecdsa");
+	const SignatureVerifyingKeySchema = require_dist.Struct({
+		tag: SignatureKindSchema,
+		value: require_dist.String$
+	});
+	const LegacySignatureVerifyingKeySchema = require_dist.transform(require_dist.String$, require_dist.typeSchema(SignatureVerifyingKeySchema), {
+		strict: true,
+		decode: (value) => ({
+			tag: "schnorr",
+			value
+		}),
+		encode: ({ value }) => value
+	});
+	const UtxoWithMetaSchema = require_dist.Struct({
+		utxo: require_dist.Struct({
+			value: require_dist.BigInt$,
+			owner: require_dist.String$,
+			type: require_dist.String$,
+			intentHash: require_dist.String$,
+			outputNo: require_dist.Number$
+		}),
+		meta: require_dist.Struct({
+			ctime: require_dist.Date$,
+			registeredForDustGeneration: require_dist.Boolean$
+		})
+	});
+	const SnapshotSchema = require_dist.Struct({
+		publicKey: require_dist.Struct({
+			publicKey: require_dist.Union(SignatureVerifyingKeySchema, LegacySignatureVerifyingKeySchema),
+			addressHex: require_dist.String$,
+			address: require_dist.String$
+		}),
+		state: require_dist.Struct({
+			availableUtxos: require_dist.Array$(UtxoWithMetaSchema),
+			pendingUtxos: require_dist.Array$(UtxoWithMetaSchema)
+		}),
+		protocolVersion: require_dist.BigInt$,
+		appliedId: require_dist.optional(require_dist.BigInt$),
+		networkId: require_dist.String$
+	});
+	return {
+		serialize: (wallet) => {
+			const buildSnapshot = (w) => ({
+				publicKey: w.publicKey,
+				state: UnshieldedState$1.toArrays(w.state),
+				protocolVersion: w.protocolVersion,
+				networkId: w.networkId,
+				appliedId: w.progress?.appliedId
+			});
+			return require_dist.pipe(wallet, buildSnapshot, require_dist.encodeSync(SnapshotSchema), JSON.stringify);
+		},
+		deserialize: (serialized) => require_dist.pipe(serialized, require_dist.decodeUnknownEither(require_dist.parseJson(SnapshotSchema)), require_dist.mapLeft((err) => new OtherWalletError$1(err)), require_dist.flatMap$4((snapshot) => require_dist.pipe(assertKeyAddressConsistency$1(snapshot.publicKey), require_dist.map$6(() => snapshot))), require_dist.map$6((snapshot) => {
+			return CoreWallet$1.restore(UnshieldedState$1.restore(snapshot.state.availableUtxos, snapshot.state.pendingUtxos), snapshot.publicKey, {
+				highestTransactionId: snapshot.appliedId ?? 0n,
+				appliedId: snapshot.appliedId ?? 0n
+			}, require_dist.ProtocolVersion(snapshot.protocolVersion), snapshot.networkId);
+		}))
+	};
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v2/SyncSchema.js
+const DateFromMillis$1 = require_dist.transform(require_dist.Number$, require_dist.DateFromSelf, {
+	strict: true,
+	decode: (millis) => new Date(millis),
+	encode: (date) => date.getTime()
+});
+const WireUtxoSchema$1 = require_dist.Struct({
+	value: require_dist.SafeBigInt,
+	owner: require_dist.String$,
+	tokenType: require_dist.String$,
+	intentHash: require_dist.String$,
+	outputIndex: require_dist.Number$,
+	ctime: require_dist.Number$,
+	registeredForDustGeneration: require_dist.Boolean$
+});
+const UtxoWithMetaSchema$1 = require_dist.transform(WireUtxoSchema$1, require_dist.typeSchema(require_dist.Struct({
+	utxo: require_dist.Struct({
+		value: require_dist.BigIntSchema,
+		owner: require_dist.String$,
+		type: require_dist.String$,
+		intentHash: require_dist.String$,
+		outputNo: require_dist.Number$
+	}),
+	meta: require_dist.Struct({
+		ctime: require_dist.DateFromSelf,
+		registeredForDustGeneration: require_dist.Boolean$
+	})
+})), {
+	strict: true,
+	decode: (wire) => ({
+		utxo: {
+			value: wire.value,
+			owner: wire.owner,
+			type: wire.tokenType,
+			intentHash: wire.intentHash,
+			outputNo: wire.outputIndex
+		},
+		meta: {
+			ctime: /* @__PURE__ */ new Date(wire.ctime * 1e3),
+			registeredForDustGeneration: wire.registeredForDustGeneration
+		}
+	}),
+	encode: (domain) => ({
+		value: domain.utxo.value,
+		owner: domain.utxo.owner,
+		tokenType: domain.utxo.type,
+		intentHash: domain.utxo.intentHash,
+		outputIndex: domain.utxo.outputNo,
+		ctime: Math.floor(domain.meta.ctime.getTime() / 1e3),
+		registeredForDustGeneration: domain.meta.registeredForDustGeneration
+	})
+});
+const UnshieldedTransactionSchema$1 = require_dist.Data(require_dist.Struct({
+	id: require_dist.Number$,
+	hash: require_dist.String$,
+	type: require_dist.Literal("RegularTransaction", "SystemTransaction", "BridgeClaimTransaction"),
+	protocolVersion: require_dist.Number$,
+	identifiers: require_dist.optional(require_dist.Array$(require_dist.String$)),
+	block: require_dist.Struct({
+		hash: require_dist.String$,
+		height: require_dist.Number$,
+		timestamp: DateFromMillis$1
+	}),
+	fees: require_dist.optional(require_dist.Struct({
+		paidFees: require_dist.SafeBigInt,
+		estimatedFees: require_dist.SafeBigInt
+	})),
+	transactionResult: require_dist.optional(require_dist.Struct({
+		status: require_dist.Literal("SUCCESS", "FAILURE", "PARTIAL_SUCCESS"),
+		segments: require_dist.NullOr(require_dist.Array$(require_dist.Struct({
+			id: require_dist.Number$,
+			success: require_dist.Boolean$
+		})))
+	}))
+}));
+const UnshieldedUpdateWireSchema$1 = require_dist.Struct({
+	type: require_dist.Literal("UnshieldedTransaction"),
+	transaction: UnshieldedTransactionSchema$1,
+	createdUtxos: require_dist.Array$(UtxoWithMetaSchema$1),
+	spentUtxos: require_dist.Array$(UtxoWithMetaSchema$1)
+});
+const UnshieldedUpdateSchema$1 = require_dist.transform(UnshieldedUpdateWireSchema$1, require_dist.typeSchema(require_dist.Struct({
+	type: require_dist.Literal("UnshieldedTransaction"),
+	transaction: UnshieldedTransactionSchema$1,
+	createdUtxos: require_dist.Array$(require_dist.typeSchema(UtxoWithMetaSchema$1)),
+	spentUtxos: require_dist.Array$(require_dist.typeSchema(UtxoWithMetaSchema$1)),
+	status: require_dist.Literal("SUCCESS", "FAILURE", "PARTIAL_SUCCESS")
+})), {
+	strict: true,
+	decode: (wire) => {
+		const isStatusImplicitlySuccess = ["SystemTransaction", "BridgeClaimTransaction"].includes(wire.transaction.type);
+		return {
+			...wire,
+			status: isStatusImplicitlySuccess ? "SUCCESS" : wire.transaction.transactionResult.status
+		};
+	},
+	encode: ({ status: _status, ...rest }) => rest
+});
+const ProgressSchema$1 = require_dist.Struct({
+	type: require_dist.Literal("UnshieldedTransactionsProgress"),
+	highestTransactionId: require_dist.Number$,
+	protocolVersion: require_dist.Number$
+});
+const WalletSyncUpdateSchema$1 = require_dist.Union(UnshieldedUpdateSchema$1, ProgressSchema$1);
+const VersionSignalSyncUpdate$1 = { create: (version, highestTransactionId) => {
+	return {
+		type: "VersionSignal",
+		version,
+		highestTransactionId
+	};
+} };
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v2/Sync.js
+/**
+* Whether a reported protocol version belongs to a variant later than the one owning `activeRange`.
+*
+* @remarks
+*   Unshielded sync is message-at-a-time, so this is the whole of the boundary rule — there is no batch to split into an
+*   applied prefix and a deferred suffix, only a yes/no per message. Exported so the indexer and simulator sync
+*   capabilities cannot drift apart on the question.
+* @param version The protocol version the source reported for this message.
+* @param activeRange The running variant's half-open activation range.
+* @returns `true` when the message must be left unapplied.
+*/
+const isBeyondActiveRange$1 = (version, activeRange) => BigInt(version) >= activeRange[1];
+/**
+* Records an observed protocol version on the state, monotonically.
+*
+* @remarks
+*   This is the only thing written when a message is deferred at the boundary, and it is what the runtime watches to
+*   decide that the variant must hand over.
+* @param state The state to annotate.
+* @param version The protocol version the source reported.
+* @returns The state carrying the higher of the two versions.
+*/
+const annotateVersion$1 = (state, version) => CoreWallet$1.withProtocolVersion(state, require_dist.ProtocolVersion(BigInt(version)));
+/**
+* Splits the chain's protocol version off a progress frame, into a signal of its own.
+*
+* @remarks
+*   This is how a wallet nobody pays learns that the chain moved. Ordinarily a version reaches it on a transaction it was
+*   served, and it is served only the transactions that touch its own address — so on a chain that crosses a protocol
+*   boundary and then pays this address nothing, it would observe no version at all and stay on the variant it was
+*   running, with everything built through it routed to that variant's ledger. The progress arm has no such silence:
+*   the indexer emits it before its first sleep and keeps emitting it, on an address the chain has never mentioned
+*   exactly as on a busy one, and it states the version at the chain's tip.
+*
+*   Split off rather than folded in place, because the two things a frame says are governed by different rules. Progress
+*   is bookkeeping and always applies. A version may be recorded only when the wallet is level with the far end of this
+*   address's timeline, or the hand-over would park the sync cursor in front of history that the next variant would
+*   then apply without ever having seen what led to it. Keeping the signal a message of its own leaves that gate
+*   exactly where the capability already implements it — and the frame states both halves in one indexed instant, so
+*   the version can no longer be read against a timeline end that moved between two separate answers.
+*
+*   Two frames are worth no signal. Zero is the source reporting that it has indexed no block yet, not a chain at version
+*   zero; read as a version it would be a claim nobody made. And a version at or below the one the wallet already held
+*   could only ever be a no-op, because the recorded version never goes backwards — suppressing it is what keeps a
+*   settled wallet's progress frames from putting a redundant message on the stream for the rest of its life.
+* @param update The decoded subscription message.
+* @param knownVersion The version the wallet held when this stream opened — a lower bound on what it holds now.
+* @returns The message, followed by the signal when the frame carries a version worth recording.
+*/
+const withVersionSignal$1 = (update, knownVersion) => update.type === "UnshieldedTransactionsProgress" && update.protocolVersion !== 0 && BigInt(update.protocolVersion) > knownVersion ? [update, VersionSignalSyncUpdate$1.create(update.protocolVersion, update.highestTransactionId)] : [update];
+const makeDefaultSyncService$1 = (config) => {
+	return { updates: (state) => {
+		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 { appliedId } = state.progress;
+		const { address } = state.publicKey;
+		return require_dist.pipe(require_dist.UnshieldedTransactions.run({
+			address,
+			transactionId: Number(appliedId)
+		}), require_dist.provideLayer(require_dist.layer({
+			url: indexerWsUrl,
+			keepAlive: indexerClientConnection.keepAlive
+		})), require_dist.mapError((error) => new SyncWalletError$1(error)), require_dist.mapEffect((subscription) => {
+			const { unshieldedTransactions } = subscription;
+			return require_dist.pipe(require_dist.decodeUnknownEither(WalletSyncUpdateSchema$1)(unshieldedTransactions), require_dist.mapLeft((err) => new SyncWalletError$1(err)), require_dist.toEffect);
+		}), require_dist.mapConcat((update) => withVersionSignal$1(update, state.protocolVersion)));
+	} };
+};
+/**
+* Folds a version signal: records the chain's version, and nothing else.
+*
+* @remarks
+*   The same recording the transaction path makes through {@link annotateVersion}: no cursor moves, no UTXO changes hands.
+*   A signal is an observation about the chain, not a piece of it.
+*
+*   One situation makes the observation unsafe to record, and it leaves the state exactly as it was. A transaction still
+*   unapplied below the address's tip means the hand-over would park the cursor in front of history the next variant
+*   would then apply without ever having seen what led to it — and that transaction carries the version itself, so
+*   nothing is lost by waiting for it. 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 — `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 signal What the chain said, and how far this address's timeline goes.
+* @returns The wallet, annotated or untouched.
+*/
+const applyVersionSignal$1 = (state, signal) => require_dist.right(BigInt(signal.highestTransactionId) > state.progress.appliedId ? state : annotateVersion$1(state, signal.version));
+/**
+* Folds a progress frame: moves the far end of the cursor, and nothing else.
+*
+* @remarks
+*   A progress message reports how far the source has got with this address, not a transaction. The chain version it also
+*   carries is deliberately not read here: the source splits that off into its own `VersionSignal`, which is the only
+*   message allowed to annotate, and which alone carries the gate in {@link applyVersionSignal}. Annotating from both
+*   places would put the gate on one route and not the other.
+* @param state The wallet to record on.
+* @param progress The frame.
+* @returns The wallet with the far end of its cursor moved and marked connected.
+*/
+const applyProgress$1 = (state, progress) => require_dist.right(CoreWallet$1.updateProgress(state, {
+	highestTransactionId: BigInt(progress.highestTransactionId),
+	isConnected: true
+}));
+/**
+* Classifies a delivered transaction; {@link applyTransaction} acts on the answer.
+*
+* @remarks
+*   "Is this past the cursor?" is the only ordering question askable here. The id is the indexer's global transaction id
+*   filtered to this address, so a wallet is served a strictly increasing but SPARSE subsequence of it — consecutive
+*   deliveries routinely skip whole runs of ids belonging to other addresses — and demanding contiguity would reject
+*   every honest stream. What a gap cannot hide is a spend whose create was never folded: `UnshieldedState` refuses a
+*   spend of a UTXO it holds in neither map, and that refusal, not this classification, is what catches a spend
+*   delivered ahead of its create. It happens before the cursor moves, so the retry re-fetches the pair in order.
+*
+*   Whether the resume cursor the subscription is opened with is inclusive is undocumented, so the transaction it names
+*   may or may not reappear on a reconnect; calling an equal id `redelivered` makes the fold indifferent either way,
+*   exactly as the shielded and dust wallets treat their own boundary event.
+* @param state The wallet the transaction was delivered to.
+* @param update The delivered transaction.
+* @param activeRange The half-open protocol version range the running variant owns.
+* @returns The placement.
+*/
+const placeTransaction$1 = (state, update, activeRange) => {
+	const received = BigInt(update.transaction.id);
+	const cursor = state.progress.appliedId;
+	return received < cursor ? "replayed" : received === cursor ? "redelivered" : isBeyondActiveRange$1(update.transaction.protocolVersion, activeRange) ? "deferred" : "applicable";
+};
+/**
+* Folds an applicable transaction: the UTXO changes, then the cursor, the history record and the version.
+*
+* @remarks
+*   The history is written only once the fold has succeeded, so a rejected transaction leaves no trace there either.
+* @param state The wallet to fold into.
+* @param update The delivered transaction.
+* @param getContext Where the transaction history lives.
+* @returns The folded wallet, or the fold's refusal.
+*/
+const foldTransaction$1 = (state, update, getContext) => {
+	const payload = {
+		createdUtxos: update.createdUtxos,
+		spentUtxos: update.spentUtxos,
+		status: update.status
+	};
+	return (update.status === "FAILURE" ? CoreWallet$1.applyFailedUpdate(state, payload) : CoreWallet$1.applyUpdate(state, payload)).pipe(require_dist.map$6((wallet) => {
+		const advanced = CoreWallet$1.updateProgress(wallet, { appliedId: BigInt(update.transaction.id) });
+		require_dist.runFork(getContext().transactionHistoryService.put(update));
+		return annotateVersion$1(advanced, update.transaction.protocolVersion);
+	}));
+};
+/**
+* Folds a delivered transaction according to its {@link TransactionPlacement}.
+*
+* @remarks
+*   - `replayed` is refused with {@link OutOfOrderSyncUpdateError} and nothing is applied: folding a create twice resurrects
+*       a UTXO some later transaction has since spent; folding a spend twice removes one some later transaction
+*       re-created. The state is handed back untouched so the retry can re-fetch in order.
+*   - `redelivered` is a no-op in the strongest sense — the same state comes back: no UTXO change, no cursor movement, no
+*       version annotation, no transaction-history write. All of that was done the first time it arrived.
+*   - `deferred` is the hand-over point. The transaction belongs to the next variant, so NOTHING about it is applied; only
+*       the version is recorded, which is what makes the runtime migrate. Because the cursor did not move, the next
+*       variant re-fetches this very transaction and applies it exactly once.
+*   - `applicable` is folded by {@link foldTransaction}.
+*
+* @param state The wallet the transaction was delivered to.
+* @param update The delivered transaction.
+* @param activeRange The half-open protocol version range the running variant owns.
+* @param getContext Where the transaction history lives.
+* @returns The next wallet, or the refusal.
+*/
+const applyTransaction$1 = (state, update, activeRange, getContext) => value(placeTransaction$1(state, update, activeRange)).pipe(when("replayed", () => require_dist.left(new OutOfOrderSyncUpdateError$1({
+	message: `Sync source delivered transaction ${update.transaction.id}, below the applied cursor ${state.progress.appliedId}; the state is left untouched so the retry can re-fetch in order`,
+	expected: state.progress.appliedId,
+	received: BigInt(update.transaction.id)
+}))), when("redelivered", () => require_dist.right(state)), when("deferred", () => require_dist.right(annotateVersion$1(state, update.transaction.protocolVersion))), when("applicable", () => foldTransaction$1(state, update, getContext)), exhaustive);
+const makeDefaultSyncCapability$1 = (_config, getContext) => {
+	return { applyUpdate: (state, update, activeRange) => value(update).pipe(discriminatorsExhaustive("type")({
+		VersionSignal: (signal) => applyVersionSignal$1(state, signal),
+		UnshieldedTransactionsProgress: (progress) => applyProgress$1(state, progress),
+		UnshieldedTransaction: (transaction) => applyTransaction$1(state, transaction, activeRange, getContext)
+	})) };
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v2/TransactionOps.js
+/**
+* Asserts that `signature` shares the scheme of every input owner authorized in `segment`. Pure and synchronous: a
+* mismatch short-circuits with a typed `SchemeMismatchError` so a wrong-scheme signature is never attached.
+*/
+const assertSignatureMatchesSegmentOwners = (transaction, segment, signature) => {
+	const intent = transaction.intents?.get(segment);
+	const owners = [...intent?.guaranteedUnshieldedOffer?.inputs ?? [], ...intent?.fallibleUnshieldedOffer?.inputs ?? []].map((input) => input.owner);
+	const seed = require_dist.right(signature);
+	return require_dist.pipe(owners, require_dist.reduce(seed, (acc, owner) => require_dist.flatMap$4(acc, () => assertSignatureMatchesKey(owner, signature))));
+};
+const TransactionOps$1 = {
+	getSignatureData(tx, segment) {
+		if (!tx.intents) return require_dist.left(new TransactingError$1({ message: "Transaction has no intents" }));
+		const intent = tx.intents.get(segment);
+		if (!intent) return require_dist.left(new TransactingError$1({ message: `Intent with segment ${segment} was not found` }));
+		return require_dist.try_$1({
+			try: () => intent.signatureData(segment),
+			catch: (error) => new TransactingError$1({
+				message: "Failed to get offer signature data",
+				cause: error
+			})
+		});
+	},
+	getSegments(transaction) {
+		return transaction.intents?.keys().toArray() ?? [];
+	},
+	findAvailableSegmentId(transaction) {
+		const used = new Set(transaction.intents?.keys() ?? []);
+		return require_dist.pipe(require_dist.range(1, 65535), require_dist.findFirst$1((segmentId) => !used.has(segmentId)));
+	},
+	addSignature(transaction, signature, segment) {
+		return require_dist.gen$1(function* () {
+			if (!transaction.intents || transaction.intents.size === 0) return yield* require_dist.left(new TransactingError$1({ message: "No intents found in the transaction" }));
+			const intent = transaction.intents?.get(segment);
+			if (!intent) return yield* require_dist.left(new TransactingError$1({ message: `Intent with id ${segment} was not found` }));
+			if (TransactionOps$1.isIntentBound(intent)) return yield* require_dist.left(new TransactingError$1({ message: `Intent at segment ${segment} is already bound` }));
+			if (intent.fallibleUnshieldedOffer) intent.fallibleUnshieldedOffer = yield* TransactionOps$1.addSignaturesToOffer(intent.fallibleUnshieldedOffer, signature, segment, "fallible");
+			if (intent.guaranteedUnshieldedOffer) intent.guaranteedUnshieldedOffer = yield* TransactionOps$1.addSignaturesToOffer(intent.guaranteedUnshieldedOffer, signature, segment, "guaranteed");
+			transaction.intents = transaction.intents.set(segment, intent);
+			return transaction;
+		});
+	},
+	collectSignableData(transaction) {
+		return require_dist.all$1(TransactionOps$1.getSegments(transaction).map((segment) => require_dist.map$6(TransactionOps$1.getSignatureData(transaction, segment), (data) => ({
+			segment,
+			data
+		}))));
+	},
+	attachSignatures(transaction, signatures) {
+		return require_dist.gen$1(function* () {
+			yield* require_dist.all$1(signatures.map(({ segment, signature }) => assertSignatureMatchesSegmentOwners(transaction, segment, signature)));
+			const seed = require_dist.right(transaction);
+			return yield* require_dist.pipe(signatures, require_dist.reduce(seed, (acc, { segment, signature }) => require_dist.flatMap$4(acc, (tx) => TransactionOps$1.addSignature(tx, signature, segment))));
+		});
+	},
+	getImbalances(transaction, segment) {
+		const imbalances = transaction.imbalances(segment).entries().filter(([token, value]) => token.tag === "unshielded" && value !== 0n).map(([token, value]) => [token.raw.toString(), value]).toArray();
+		return require_dist.Imbalances.fromEntries(imbalances);
+	},
+	addSignaturesToOffer(offer, signature, segment, offerType) {
+		return require_dist.pipe(offer.inputs, require_dist.map$3((_, i) => offer.signatures.at(i) ?? new _midnightntwrk_ledger_v9.SignatureEnabled(signature)), (signatures) => require_dist.try_$1({
+			try: () => offer.addSignatures(signatures),
+			catch: (error) => new TransactingError$1({
+				message: `Failed to add ${offerType} signature at segment ${segment}`,
+				cause: error
+			})
+		}));
+	},
+	isIntentBound(intent) {
+		return intent.binding.instance === "binding";
+	},
+	extractOwnInputs(transaction, signatureVerifyingKey) {
+		const segments = TransactionOps$1.getSegments(transaction);
+		const ownerAddress = (0, _midnightntwrk_ledger_v9.addressFromKey)(signatureVerifyingKey);
+		const isOwn = (input) => input.owner.tag === signatureVerifyingKey.tag && input.owner.value === signatureVerifyingKey.value;
+		const toUtxo = (input) => ({
+			...input,
+			owner: ownerAddress
+		});
+		return require_dist.pipe(segments, require_dist.flatMap$2((segment) => {
+			const intent = transaction.intents?.get(segment);
+			if (!intent) return [];
+			const { guaranteedUnshieldedOffer, fallibleUnshieldedOffer } = intent;
+			const ownedInputsfromGuaranteedSection = guaranteedUnshieldedOffer?.inputs ? guaranteedUnshieldedOffer.inputs.filter(isOwn) : [];
+			const ownedInputsfromFallibleSection = fallibleUnshieldedOffer ? fallibleUnshieldedOffer.inputs.filter(isOwn) : [];
+			return [...ownedInputsfromGuaranteedSection, ...ownedInputsfromFallibleSection].map(toUtxo);
+		}));
+	}
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v2/Transacting.js
+const GUARANTEED_SEGMENT$1 = 0;
+const makeDefaultTransactingCapability$1 = (config, getContext) => {
+	return new TransactingCapabilityImplementation$1(config.networkId, () => getContext().coinSelection, () => getContext().coinsAndBalancesCapability, () => getContext().keysCapability, TransactionOps$1);
+};
+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;
+	}
+	/**
+	* Balances an unbound transaction Note: Unbound transactions are balanced in place and returned
+	*
+	* @param wallet - The wallet to balance the transaction with
+	* @param transaction - The transaction to balance
+	* @returns The balanced transaction and the new wallet state if successful, otherwise an error
+	*/
+	balanceUnboundTransaction(wallet, transaction) {
+		return this.#balanceUnboundishTransaction(wallet, transaction);
+	}
+	/**
+	* Balances an unproven transaction Note: This method does the same thing as balanceUnboundTransaction but is provided
+	* for convenience and type safety
+	*
+	* @param wallet - The wallet to balance the transaction with
+	* @param transaction - The transaction to balance
+	* @returns The balanced transaction and the new wallet state if successful, otherwise an error
+	*/
+	balanceUnprovenTransaction(wallet, transaction) {
+		return this.#balanceUnboundishTransaction(wallet, transaction);
+	}
+	/**
+	* Balances a bound transaction Note: In bound transactions we can only balance the guaranteed section in intents
+	*
+	* @param wallet - The wallet to balance the transaction with
+	* @param transaction - The transaction to balance
+	* @returns A balancing counterpart transaction (which should be merged with the original transaction ) and the new
+	*   wallet state if successful, otherwise an error
+	*/
+	balanceFinalizedTransaction(wallet, transaction) {
+		return require_dist.gen$1(this, function* () {
+			const segments = this.txOps.getSegments(transaction);
+			for (const segment of segments) {
+				const intent = transaction.intents?.get(segment);
+				if (!this.txOps.isIntentBound(intent)) return yield* require_dist.left(new TransactingError$1({ message: `Intent with id ${segment} is not bound` }));
+			}
+			const intent = transaction.intents?.get(segments[0]);
+			const imbalances = this.txOps.getImbalances(transaction, GUARANTEED_SEGMENT$1);
+			if (imbalances.size === 0) return [void 0, wallet];
+			const recipe = yield* this.#balanceSegment(wallet, imbalances, require_dist.Imbalances.empty(), this.getCoinSelection());
+			const { newState, offer } = yield* this.#prepareOffer(wallet, recipe);
+			const balancingIntent = _midnightntwrk_ledger_v9.Intent.new(intent.ttl);
+			balancingIntent.guaranteedUnshieldedOffer = offer;
+			const segmentId = require_dist.getOrElse(this.txOps.findAvailableSegmentId(transaction), () => 1);
+			return [_midnightntwrk_ledger_v9.Transaction.fromParts(this.networkId).addIntent({
+				tag: "specific",
+				value: segmentId
+			}, balancingIntent), newState];
+		});
+	}
+	/**
+	* Makes a transfer transaction
+	*
+	* @param wallet - The wallet to make the transfer with
+	* @param outputs - The outputs for the transfer
+	* @param ttl - The TTL for the transaction
+	* @returns The balanced transfer transaction and the new wallet state if successful, otherwise an error
+	*/
+	makeTransfer(wallet, outputs, ttl) {
+		return require_dist.gen$1(this, function* () {
+			const { networkId } = this;
+			if (!outputs.every((output) => output.amount > 0n)) return yield* require_dist.left(new TransactingError$1({ message: "The amount of all inputs needs to be positive" }));
+			const ledgerOutputs = outputs.map((output) => {
+				return {
+					value: output.amount,
+					owner: output.receiverAddress.data.toString("hex"),
+					type: output.type
+				};
+			});
+			const recipe = yield* this.#balanceSegment(wallet, require_dist.Imbalances.empty(), require_dist.Imbalances.fromEntries(ledgerOutputs.map((output) => [output.type, output.value])), this.getCoinSelection());
+			const { newState, offer } = yield* this.#prepareOffer(wallet, {
+				inputs: recipe.inputs,
+				outputs: [...recipe.outputs, ...ledgerOutputs]
+			});
+			const intent = _midnightntwrk_ledger_v9.Intent.new(ttl);
+			if (ledgerOutputs.some((output) => output.type === require_dist.Token.night)) intent.fallibleUnshieldedOffer = offer;
+			else intent.guaranteedUnshieldedOffer = offer;
+			return {
+				newState,
+				transaction: _midnightntwrk_ledger_v9.Transaction.fromParts(networkId, void 0, void 0, intent)
+			};
+		});
+	}
+	rotateUtxos(wallet, guaranteedUtxos, fallibleUtxos, nightVerifyingKey, ttl) {
+		return require_dist.gen$1(this, function* () {
+			const { networkId } = this;
+			if (guaranteedUtxos.length === 0 && fallibleUtxos.length === 0) return yield* require_dist.left(new TransactingError$1({ message: "At least one UTxO must be provided to rotateUtxos" }));
+			const ownerAddress = _midnightntwrk_ledger_v9.addressFromKey(nightVerifyingKey);
+			const makeOffer = (utxos) => {
+				if (utxos.length === 0) return require_dist.none();
+				const inputs = utxos.map(({ utxo }) => ({
+					value: utxo.value,
+					type: utxo.type,
+					intentHash: utxo.intentHash,
+					outputNo: utxo.outputNo,
+					owner: nightVerifyingKey
+				}));
+				const totalValue = require_dist.pipe(utxos, require_dist.map$3(({ utxo }) => utxo.value), require_dist.reduce(0n, (a, b) => a + b));
+				const output = {
+					owner: ownerAddress,
+					type: require_dist.Token.night,
+					value: totalValue
+				};
+				return require_dist.some(_midnightntwrk_ledger_v9.UnshieldedOffer.new(inputs, [output], []));
+			};
+			const allUtxos = [...guaranteedUtxos, ...fallibleUtxos].map(({ utxo }) => utxo);
+			const [, walletAfterBooking] = yield* CoreWallet$1.spendUtxos(wallet, allUtxos);
+			const guaranteedOffer = makeOffer(guaranteedUtxos);
+			const fallibleOffer = makeOffer(fallibleUtxos);
+			const intent = require_dist.pipe(_midnightntwrk_ledger_v9.Intent.new(ttl), (i) => require_dist.match$1(guaranteedOffer, {
+				onNone: () => i,
+				onSome: (offer) => {
+					i.guaranteedUnshieldedOffer = offer;
+					return i;
+				}
+			}), (i) => require_dist.match$1(fallibleOffer, {
+				onNone: () => i,
+				onSome: (offer) => {
+					i.fallibleUnshieldedOffer = offer;
+					return i;
+				}
+			}));
+			return {
+				newState: walletAfterBooking,
+				transaction: _midnightntwrk_ledger_v9.Transaction.fromParts(networkId, void 0, void 0, intent)
+			};
+		});
+	}
+	/**
+	* Initializes a swap transaction
+	*
+	* @param wallet - The wallet to initialize the swap for
+	* @param desiredInputs - The desired inputs for the swap
+	* @param desiredOutputs - The desired outputs for the swap
+	* @param ttl - The TTL for the swap
+	* @returns The initialized swap transaction and the new wallet state if successful, otherwise an error
+	*/
+	initSwap(wallet, desiredInputs, desiredOutputs, ttl) {
+		return require_dist.gen$1(this, function* () {
+			const { networkId } = this;
+			if (!desiredOutputs.every((output) => output.amount > 0n)) return yield* require_dist.left(new TransactingError$1({ message: "The amount of all outputs needs to be positive" }));
+			if (!Object.entries(desiredInputs).every(([, amount]) => amount > 0n)) return yield* require_dist.left(new TransactingError$1({ message: "The amount of all inputs needs to be positive" }));
+			const ledgerOutputs = desiredOutputs.map((output) => ({
+				value: output.amount,
+				owner: output.receiverAddress.data.toString("hex"),
+				type: output.type
+			}));
+			const targetImbalances = require_dist.Imbalances.fromEntries(Object.entries(desiredInputs));
+			const recipe = yield* this.#balanceSegment(wallet, require_dist.Imbalances.empty(), targetImbalances, this.getCoinSelection());
+			const { newState, offer } = yield* this.#prepareOffer(wallet, {
+				inputs: recipe.inputs,
+				outputs: [...recipe.outputs, ...ledgerOutputs]
+			});
+			const intent = _midnightntwrk_ledger_v9.Intent.new(ttl);
+			intent.guaranteedUnshieldedOffer = offer;
+			return {
+				newState,
+				transaction: _midnightntwrk_ledger_v9.Transaction.fromParts(networkId, void 0, void 0, intent)
+			};
+		});
+	}
+	/**
+	* Reverts a transaction by rolling back all inputs owned by this wallet
+	*
+	* @param wallet - The wallet to revert the transaction for
+	* @param transaction - The transaction to revert (can be FinalizedTransaction, UnboundTransaction, or
+	*   UnprovenTransaction)
+	* @returns The updated wallet with rolled back UTXOs if successful, otherwise an error
+	*/
+	revertTransaction(wallet, transaction) {
+		return require_dist.pipe(this.txOps.extractOwnInputs(transaction, wallet.publicKey.publicKey), require_dist.reduce(require_dist.right(wallet), (walletAcc, utxo) => require_dist.pipe(walletAcc, require_dist.flatMap$4((w) => CoreWallet$1.rollbackUtxo(w, utxo)))));
+	}
+	/**
+	* Balances a segment of a transaction
+	*
+	* @param wallet - The wallet to balance the segment for
+	* @param imbalances - The imbalances to balance the segment for
+	* @param targetImbalances - The target imbalances to balance the segment for
+	* @param coinSelection - The coin selection to use for the balance recipe
+	* @returns The balance recipe if successful, otherwise an error
+	*/
+	#balanceSegment(wallet, imbalances, targetImbalances, coinSelection) {
+		return require_dist.try_$1({
+			try: () => require_dist.getBalanceRecipe({
+				coins: this.getCoins().getAvailableCoins(wallet).map(({ utxo }) => utxo),
+				initialImbalances: imbalances,
+				feeTokenType: "",
+				transactionCostModel: {
+					inputFeeOverhead: 0n,
+					outputFeeOverhead: 0n
+				},
+				coinSelection,
+				createOutput: (coin) => ({
+					...coin,
+					owner: wallet.publicKey.addressHex
+				}),
+				isCoinEqual: (a, b) => a.intentHash === b.intentHash && a.outputNo === b.outputNo,
+				targetImbalances
+			}),
+			catch: (err) => {
+				if (err instanceof require_dist.InsufficientFundsError) return new InsufficientFundsError$1({
+					message: "Insufficient funds",
+					tokenType: err.tokenType,
+					amount: imbalances.get(err.tokenType) ?? 0n
+				});
+				else return new OtherWalletError$1({
+					message: "Balancing unshielded segment failed",
+					cause: err
+				});
+			}
+		});
+	}
+	/**
+	* Prepares an offer for a given balance recipe
+	*
+	* @param wallet - The wallet to prepare the offer for
+	* @param balanceRecipe - The balance recipe to prepare the offer for
+	* @returns The prepared offer and the new wallet state if successful, otherwise an error
+	*/
+	#prepareOffer(wallet, balanceRecipe) {
+		return require_dist.gen$1(function* () {
+			const [spentInputs, updatedWallet] = yield* CoreWallet$1.spendUtxos(wallet, balanceRecipe.inputs);
+			const { publicKey } = wallet.publicKey;
+			const ledgerInputs = spentInputs.map((input) => ({
+				...input,
+				intentHash: input.intentHash,
+				owner: publicKey
+			}));
+			return {
+				newState: updatedWallet,
+				offer: yield* require_dist.try_$1({
+					try: () => _midnightntwrk_ledger_v9.UnshieldedOffer.new(ledgerInputs, [...balanceRecipe.outputs], []),
+					catch: (error) => new TransactingError$1({
+						message: "Failed to create counter offer",
+						cause: error
+					})
+				})
+			};
+		});
+	}
+	#mergeOffers(offerA, offerB) {
+		return require_dist.pipe(require_dist.fromNullable(offerB), require_dist.match$1({
+			onNone: () => require_dist.right(offerA),
+			onSome: (offerB) => require_dist.try_$1({
+				try: () => _midnightntwrk_ledger_v9.UnshieldedOffer.new([...offerB.inputs, ...offerA.inputs], [...offerB.outputs, ...offerA.outputs], [...offerB.signatures, ...offerA.signatures]),
+				catch: (error) => new TransactingError$1({
+					message: "Failed to merge offers",
+					cause: error
+				})
+			})
+		}));
+	}
+	/**
+	* Balances an unboundish (unproven or unbound) transaction
+	*
+	* @param wallet - The wallet to balance the transaction with
+	* @param transaction - The transaction to balance
+	* @returns The balanced transaction and the new wallet state if successful, otherwise an error
+	* @todo - https://shielded.atlassian.net/browse/PM-21260
+	*/
+	#balanceUnboundishTransaction(wallet, transaction) {
+		return require_dist.gen$1(this, function* () {
+			const segments = this.txOps.getSegments(transaction);
+			if (segments.length === 0) return [void 0, wallet];
+			for (const segment of [...segments, GUARANTEED_SEGMENT$1]) {
+				const imbalances = this.txOps.getImbalances(transaction, segment);
+				if (imbalances.size === 0) continue;
+				const intentSegment = segment === GUARANTEED_SEGMENT$1 ? segments[0] : segment;
+				const intent = transaction.intents?.get(intentSegment);
+				if (!intent) return yield* require_dist.left(new TransactingError$1({ message: `Intent with id ${segment} was not found` }));
+				if (this.txOps.isIntentBound(intent)) return yield* require_dist.left(new TransactingError$1({ message: `Intent with id ${segment} is already bound` }));
+				const recipe = yield* this.#balanceSegment(wallet, imbalances, require_dist.Imbalances.empty(), this.getCoinSelection());
+				const { offer } = yield* this.#prepareOffer(wallet, recipe);
+				const targetOffer = segment !== GUARANTEED_SEGMENT$1 ? intent.fallibleUnshieldedOffer : intent.guaranteedUnshieldedOffer;
+				const mergedOffer = yield* this.#mergeOffers(offer, targetOffer);
+				if (segment !== GUARANTEED_SEGMENT$1) intent.fallibleUnshieldedOffer = mergedOffer;
+				else intent.guaranteedUnshieldedOffer = mergedOffer;
+				transaction.intents = transaction.intents.set(intentSegment, intent);
+			}
+			return [transaction, wallet];
+		});
+	}
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/KeyStore.js
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+const PublicKey = { fromKeyStore: (keystore) => {
+	return {
+		publicKey: keystore.getPublicKey(),
+		addressHex: keystore.getAddress(),
+		address: keystore.getBech32Address().asString()
+	};
+} };
+const createKeystore = (secretKey, networkId) => {
+	const ledgerSigningKey = {
+		tag: secretKey.kind,
+		value: require__polyfill_buffer_patch.import_buffer.Buffer.from(secretKey.secret).toString("hex")
+	};
+	const keystore = {
+		getSecretKey: () => require__polyfill_buffer_patch.import_buffer.Buffer.from(secretKey.secret),
+		getBech32Address: () => {
+			const address = keystore.getAddress();
+			const addressBuffer = require__polyfill_buffer_patch.import_buffer.Buffer.from(address, "hex");
+			return require_dist.UnshieldedAddress.codec.encode(networkId, new require_dist.UnshieldedAddress(addressBuffer));
+		},
+		getPublicKey: () => (0, _midnightntwrk_ledger_v9.signatureVerifyingKey)(ledgerSigningKey),
+		getAddress: () => (0, _midnightntwrk_ledger_v9.addressFromKey)(keystore.getPublicKey()),
+		signData: (data) => (0, _midnightntwrk_ledger_v9.signData)(ledgerSigningKey, data),
+		signDataAsync: (data) => Promise.resolve(keystore.signData(data))
+	};
+	return keystore;
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/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
+*   UTXOs and a public key 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.init(PublicKey.fromKeyStore(createKeystore({
+		kind: "schnorr",
+		secret: seed
+	}, configuration.networkId)), configuration.networkId));
+} });
+/**
+* The migration across a ledger-version boundary: a structural carry of everything the wallet holds, all of it
+* spendable.
+*
+* @remarks
+*   This is where unshielded parts company with shielded and dust. Those two start the new variant on a **fresh, empty**
+*   state and let the indexer's ledger-v9 replay hand their coins back, because their coins are shielded: re-deriving
+*   them means decrypting events with secret keys that migration, by design, never receives. Unshielded has no such
+*   problem. Its UTXOs are public ledger data that the wallet holds as plain records, so they can simply be rebuilt on
+*   the other side — no replay to wait for, no keys required, and no window in which the wallet reports a zero balance
+*   it does not have.
+*
+*   So every UTXO crosses, field for field, along with the address, the network, and the protocol version that triggered
+*   the hand-over. **Bookings do not.** A UTXO the previous variant had reserved for a transaction still in flight is
+*   restored as _available_, and the new state crosses with nothing pending, because the transaction that reserved it
+*   cannot exist on this side: the transaction codec moved at the boundary, so a transaction built by the previous
+*   ledger version can never be included in a ledger-v9 block. A booking exists only to stop a UTXO being spent twice
+*   while its transaction might still land, and past the boundary it never can — its reason expires at the boundary
+*   itself. Carrying one over would lock those funds for the wallet's lifetime instead: nothing on this side can
+*   un-book them, because the transaction that would identify them is unreadable to this ledger version, and the
+*   booking outlives serialization.
+*
+*   Releasing is **exact** here rather than merely eventually consistent. The hand-over fires only once the previous
+*   variant has applied the complete ledger-v8 timeline: a transaction the source reports at or beyond the boundary is
+*   left entirely unapplied and only annotates the version, so everything before it is already folded in, and the
+*   version signal a quiet chain hands over on is recorded only when the wallet is caught up on its own transaction
+*   ids. A ledger-v8 transaction that did land has therefore already confirmed by the time this runs — clearing its own
+*   bookings as it was applied — and whatever is still booked belongs to a transaction that never will land. Even if an
+*   unapplied ledger-v8 event were somehow to reach the new variant afterwards, the release stays safe rather than
+*   merely lucky: {@link UnshieldedState.applyUpdate} removes a confirmed spend from **both** maps, so a
+*   released-then-confirmed UTXO leaves the available set exactly as if it had never been released.
+*
+*   The one transformation is the verifying key, which gains the scheme tag that ledger-v9 requires and ledger-v8 had no
+*   room for — the same widening the deserializer already performs on legacy snapshots, which is where the `schnorr`
+*   default comes from: ledger-v8 had exactly one signature scheme, so a key that reaches here can only have been a
+*   schnorr key.
+*
+*   Sync progress is carried **unchanged** — parked, not rewound and not advanced. The boundary transaction was observed
+*   and annotated but deliberately never applied, so the cursor still points just before it; the new variant re-fetches
+*   it from there and applies it exactly once. Rewinding to zero would re-apply history the wallet already holds;
+*   advancing past it would lose the boundary transaction outright.
+* @returns A migration from a previous-ledger-version wallet.
+*/
+const makeCrossLedgerMigration = () => ({ migrate: (previousState) => require_dist.succeed(CoreWallet$1.restore(UnshieldedState$1.restore([...Array.from(require_dist.values(previousState.state.availableUtxos), carryUtxo), ...Array.from(require_dist.values(previousState.state.pendingUtxos), carryUtxo)], []), {
+	publicKey: {
+		tag: "schnorr",
+		value: previousState.publicKey.publicKey
+	},
+	addressHex: previousState.publicKey.addressHex,
+	address: previousState.publicKey.address
+}, {
+	appliedId: previousState.progress.appliedId,
+	highestTransactionId: previousState.progress.highestTransactionId
+}, require_dist.ProtocolVersion(previousState.protocolVersion), previousState.networkId)) });
+/**
+* Rebuilds a previous-version UTXO as one of this version's, field for field — save one.
+*
+* @remarks
+*   `registeredForDustGeneration` crosses as `false` rather than as whatever the previous version reported, because the
+*   fork wipes the ledger's Dust generation state outright and its chain-side replay restores generation for
+*   cNIGHT-backed Night only. The node's own fork test states the consequence for everything else: "the fork wipes dust
+*   state ... the registration funds itself from the retroactive DUST its now-generationless NIGHT accrued"
+*   (`util/toolkit/tests/hardfork_e2e.rs`, step 5c).
+*
+*   The crossing is the only place the wallet's copy of the flag can be brought in line. The indexer reports it as of the
+*   current Dust epoch at read time, so a fresh sync after the v9 fork reads `false` — but it never re-emits a UTxO the
+*   wallet already synced on ledger-v8 with `true`, and there is no ledger-v9 event that would revise it. Flipping it
+*   here is what makes a carried UTxO say what the indexer would say of it today.
+*
+*   Known limitation: cNIGHT-backed Night _is_ restored chain-side, and reads `false` here until a later sync-time update
+*   says otherwise. It fails closed — a registration built over it claims a fee allowance the ledger does not grant and
+*   is refused rather than mis-submitted.
+*/
+const carryUtxo = (carried) => new UtxoWithMeta({
+	utxo: {
+		value: carried.utxo.value,
+		owner: carried.utxo.owner,
+		type: carried.utxo.type,
+		intentHash: carried.utxo.intentHash,
+		outputNo: carried.utxo.outputNo
+	},
+	meta: {
+		ctime: carried.meta.ctime,
+		registeredForDustGeneration: false
+	}
+});
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v2/Signing.js
+/**
+* The default signing service: collect each segment's signable data (pure), invoke the async signer once per segment
+* (sequentially — segment counts are tiny), then attach the signatures (pure, with scheme validation). A signer
+* rejection or throw is wrapped in a {@link SignError}; a scheme mismatch short-circuits inside `attachSignatures`
+* before anything is attached, so no partially-signed transaction can escape.
+*/
+const makeDefaultSigningService$1 = () => ({ sign(transaction, signSegment) {
+	return require_dist.gen(function* () {
+		const segments = yield* require_dist.toEffect(TransactionOps$1.collectSignableData(transaction));
+		const signatures = yield* require_dist.forEach(segments, (segment) => require_dist.pipe(require_dist.tryPromise({
+			try: () => signSegment(segment.data),
+			catch: (cause) => new SignError$1({
+				message: "Signer callback failed",
+				cause
+			})
+		}), require_dist.map$2((signature) => ({
+			segment: segment.segment,
+			signature
+		}))));
+		return yield* require_dist.toEffect(TransactionOps$1.attachSignatures(transaction, signatures));
+	});
+} });
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v2/CoinsAndBalances.js
+const calculateBalances$1 = (utxos) => utxos.reduce((acc, { utxo }) => ({
+	...acc,
+	[utxo.type]: acc[utxo.type] === void 0 ? utxo.value : acc[utxo.type] + utxo.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) => UnshieldedState$1.toArrays(state.state).availableUtxos;
+	const getPendingCoins = (state) => UnshieldedState$1.toArrays(state.state).pendingUtxos;
+	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-unshielded-wallet/dist/v2/Keys.js
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+const makeDefaultKeysCapability$1 = () => {
+	return {
+		getPublicKey: (state) => {
+			return state.publicKey.publicKey;
+		},
+		getAddress: (state) => {
+			return new require_dist.UnshieldedAddress(require__polyfill_buffer_patch.import_buffer.Buffer.from(state.publicKey.addressHex, "hex"));
+		}
+	};
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v2/TransactionHistory.js
+const UtxoSchema$1 = require_dist.Struct({
+	value: require_dist.SafeBigInt,
+	owner: require_dist.String$,
+	tokenType: require_dist.String$,
+	intentHash: require_dist.String$,
+	outputIndex: require_dist.Number$
+});
+const UnshieldedSectionSchema = require_dist.Struct({
+	id: require_dist.Number$,
+	createdUtxos: require_dist.Array$(UtxoSchema$1),
+	spentUtxos: require_dist.Array$(UtxoSchema$1)
+});
+const mergeUnshieldedSections = (existing, incoming) => ({
+	...existing,
+	...incoming
+});
+require_dist.extendEntrySchema({ unshielded: require_dist.optional(UnshieldedSectionSchema) });
+const convertUpdateToFinalizedInput$1 = ({ transaction, createdUtxos, spentUtxos, status }) => ({
+	hash: transaction.hash,
+	protocolVersion: transaction.protocolVersion,
+	status,
+	identifiers: transaction.identifiers ?? [],
+	timestamp: transaction.block.timestamp,
+	finalizedBlock: {
+		hash: transaction.block.hash,
+		height: transaction.block.height,
+		timestamp: transaction.block.timestamp
+	},
+	unshielded: {
+		id: transaction.id,
+		createdUtxos: createdUtxos.map(({ utxo }) => ({
+			value: utxo.value,
+			owner: utxo.owner,
+			tokenType: utxo.type,
+			intentHash: utxo.intentHash,
+			outputIndex: utxo.outputNo
+		})),
+		spentUtxos: spentUtxos.map(({ utxo }) => ({
+			value: utxo.value,
+			owner: utxo.owner,
+			tokenType: utxo.type,
+			intentHash: utxo.intentHash,
+			outputIndex: utxo.outputNo
+		}))
+	}
+});
+const makeDefaultTransactionHistoryService$1 = (config, _getContext) => {
+	const txHistoryStorage = config.txHistoryStorage;
+	return { put: (update) => require_dist.tryPromise({
+		try: () => txHistoryStorage.gotFinalized(convertUpdateToFinalizedInput$1(update)),
+		catch: (e) => new TransactionHistoryError$1({
+			message: "Failed to record finalized history entry",
+			cause: e
+		})
+	}) };
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v2/V2Builder.js
+var V2Builder = class V2Builder {
+	#buildState;
+	constructor(buildState = {}) {
+		this.#buildState = buildState;
+	}
+	withDefaults() {
+		return this.withSyncDefaults().withSerializationDefaults().withTransactingDefaults().withSigningDefaults().withCoinsAndBalancesDefaults().withTransactionHistoryDefaults().withKeysDefaults().withCoinSelectionDefaults();
+	}
+	withSyncDefaults() {
+		return this.withSync(makeDefaultSyncService$1, makeDefaultSyncCapability$1);
+	}
+	withSync(syncService, syncCapability) {
+		return new V2Builder({
+			...this.#buildState,
+			syncService,
+			syncCapability
+		});
+	}
+	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
+		});
+	}
+	withSigningDefaults() {
+		return this.withSigning(makeDefaultSigningService$1);
+	}
+	withSigning(signingService) {
+		return new V2Builder({
+			...this.#buildState,
+			signingService
+		});
+	}
+	/**
+	* Configures this variant to start from an empty wallet when there is nothing before it.
+	*
+	* @remarks
+	*   The default for a first-registered variant, and what `startEmpty` relies on.
+	* @returns A builder whose previous state is `null`.
+	*/
+	withMigrationDefaults() {
+		return this.withMigration((configuration) => makeEmptyWalletMigration$1({ networkId: configuration.networkId }));
+	}
+	/**
+	* Configures how this variant produces its first state from whatever variant preceded it.
+	*
+	* @remarks
+	*   The context is a method-level type parameter rather than the builder's own `TContext`, matching `withSync` and
+	*   `withKeys` in this file. Binding it to the builder's `TContext` would make the builder invariant in it and break
+	*   the partially-configured chains the tests build.
+	* @param migration Produces the strategy from the configuration and the variant context.
+	* @returns A builder whose previous state is whatever the strategy consumes.
+	*/
+	withMigration(migration) {
+		const { migration: _replaced, ...capabilities } = this.#buildState;
+		return new V2Builder({
+			...capabilities,
+			migration
+		});
+	}
+	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);
+	}
+	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,
+			start(context) {
+				return require_dist.gen(function* () {
+					return new RunningV2Variant(yield* require_dist.Scope, context, v2Context);
+				});
+			},
+			migrateState(previousState) {
+				return migration.migrate(previousState).pipe(require_dist.mapError$2((error) => new require_dist.WalletRuntimeError({
+					message: "Failed to migrate unshielded wallet state into this variant",
+					cause: error
+				})));
+			},
+			deserializeState: (serialized) => {
+				return v2Context.serializationCapability.deserialize(serialized);
+			}
+		};
+	}
+	/**
+	* The migration strategy to build with.
+	*
+	* @remarks
+	*   An unconfigured builder produces an empty wallet, which is what `startEmpty` asks of a first variant. The nullary
+	*   wrapper is what lets the `null`-consuming default stand in for a `TPreviousState`-consuming strategy without a
+	*   cast: the argument is simply not passed on.
+	*/
+	#resolveMigration(configuration, getContext) {
+		const configured = this.#buildState.migration;
+		return configured === void 0 ? { migrate: () => makeEmptyWalletMigration$1({ networkId: configuration.networkId }).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, signingService, 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),
+			signingService: signingService(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",
+		"signingService",
+		"coinSelection",
+		"serializationCapability",
+		"coinsAndBalancesCapability",
+		"keysCapability",
+		"transactionHistoryService"
+	].every((key) => typeof buildState[key] == "function");
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/SingleVariantUnshieldedWallet.js
+function CustomUnshieldedWallet(configuration, builder) {
+	const buildArgs = [configuration];
+	const BaseWallet = require_dist.WalletBuilder.init().withVariant(require_dist.MinSupportedVersion, builder).build(...buildArgs);
+	/** The whole of the protocol timeline: one variant answers for every version this wallet will ever see. */
+	const wholeTimeline = require_dist.epochOf(require_dist.MinSupportedVersion, require_dist.MinSupportedVersion);
+	/** Reads a transaction a caller handed in, which a single-variant wallet accepts at any version. */
+	const carried = (handle) => require_dist.toEffect(require_dist.WalletTransaction.unwrapWithin(handle, wholeTimeline));
+	/** Seals a transaction this wallet built, at the version its one variant answers from. */
+	const seal = (transaction) => require_dist.WalletTransaction.adopt("Unproven", transaction, require_dist.MinSupportedVersion);
+	const sealUnproven = (result) => result === void 0 ? void 0 : seal(result);
+	const sealUnbound = (result) => result === void 0 ? void 0 : require_dist.WalletTransaction.adopt("Unbound", result, require_dist.MinSupportedVersion);
+	return class CustomUnshieldedWalletImplementation extends BaseWallet {
+		static startWithPublicKey(publicKeys) {
+			return CustomUnshieldedWalletImplementation.startFirst(CustomUnshieldedWalletImplementation, CoreWallet$1.init(publicKeys, configuration.networkId));
+		}
+		static restore(serializedState) {
+			const deserialized = CustomUnshieldedWalletImplementation.allVariantsRecord()[V2Tag].variant.deserializeState(serializedState).pipe(require_dist.getOrThrow$1);
+			return CustomUnshieldedWalletImplementation.startFirst(CustomUnshieldedWalletImplementation, deserialized);
+		}
+		state;
+		constructor(runtime, scope) {
+			super(runtime, scope);
+			this.state = this.rawState.pipe(rxjs.map((emission) => UnshieldedWalletState.fromVariant(CustomUnshieldedWalletImplementation.allVariantsRecord()[V2Tag].variant, emission)), rxjs.shareReplay({
+				refCount: true,
+				bufferSize: 1
+			}));
+		}
+		/**
+		* 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);
+		/**
+		* Whether the wallet is currently started.
+		*
+		* @remarks
+		*   The unshielded counterpart of the retained start-aux the shielded and dust wallets hold. This wallet is
+		*   watch-only — sync needs nothing secret, and signing is supplied per call by the caller — so there is no key to
+		*   keep and the restart needs no argument. All the watcher has to know is whether a stopped wallet should be left
+		*   stopped, which is what this records; `stop` clears it so a stopped wallet cannot be resurrected by a late
+		*   activation.
+		*/
+		#started = require_dist.unsafeMake(false);
+		start() {
+			return require_dist.gen(this, function* () {
+				yield* require_dist.set(this.#started, true);
+				if (!(yield* require_dist.getAndSet(this.#watcherRegistered, true))) yield* this.runtime.onVariantActivation({ [V2Tag]: (v2) => require_dist.get$1(this.#started).pipe(require_dist.flatMap$1((started) => started ? v2.startSyncInBackground() : require_dist._void)) });
+				yield* this.runtime.dispatch({ [V2Tag]: (v2) => v2.startSyncInBackground() });
+			}).pipe(require_dist.runPromise$1);
+		}
+		async stop() {
+			require_dist.set(this.#started, false).pipe(require_dist.runSync);
+			await super.stop();
+		}
+		balanceFinalizedTransaction(tx) {
+			return this.runtime.dispatch({ [V2Tag]: (v2) => carried(tx).pipe(require_dist.flatMap$1((unwrapped) => v2.balanceFinalizedTransaction(unwrapped)), require_dist.map$2(sealUnproven)) }).pipe(require_dist.runPromise$1);
+		}
+		balanceUnboundTransaction(tx) {
+			return this.runtime.dispatch({ [V2Tag]: (v2) => carried(tx).pipe(require_dist.flatMap$1((unwrapped) => v2.balanceUnboundTransaction(unwrapped)), require_dist.map$2(sealUnbound)) }).pipe(require_dist.runPromise$1);
+		}
+		balanceUnprovenTransaction(tx) {
+			return this.runtime.dispatch({ [V2Tag]: (v2) => carried(tx).pipe(require_dist.flatMap$1((unwrapped) => v2.balanceUnprovenTransaction(unwrapped)), require_dist.map$2(sealUnproven)) }).pipe(require_dist.runPromise$1);
+		}
+		transferTransaction(outputs, ttl) {
+			return this.runtime.dispatch({ [V2Tag]: (v2) => v2.transferTransaction(outputs, ttl).pipe(require_dist.map$2(seal)) }).pipe(require_dist.runPromise$1);
+		}
+		rotateUtxos(guaranteedUtxos, fallibleUtxos, nightVerifyingKey, ttl) {
+			return this.runtime.dispatch({ [V2Tag]: (v2) => v2.rotateUtxos(guaranteedUtxos, fallibleUtxos, nightVerifyingKey, ttl).pipe(require_dist.map$2(seal)) }).pipe(require_dist.runPromise$1);
+		}
+		initSwap(desiredInputs, desiredOutputs, ttl) {
+			return this.runtime.dispatch({ [V2Tag]: (v2) => v2.initSwap(desiredInputs, desiredOutputs, ttl).pipe(require_dist.map$2(seal)) }).pipe(require_dist.runPromise$1);
+		}
+		signUnprovenTransaction(transaction, signSegment) {
+			return this.runtime.dispatch({ [V2Tag]: (v2) => carried(transaction).pipe(require_dist.flatMap$1((unwrapped) => v2.signUnprovenTransaction(unwrapped, signSegment)), require_dist.map$2(seal)) }).pipe(require_dist.runPromise$1);
+		}
+		signUnboundTransaction(transaction, signSegment) {
+			return this.runtime.dispatch({ [V2Tag]: (v2) => carried(transaction).pipe(require_dist.flatMap$1((unwrapped) => v2.signUnboundTransaction(unwrapped, signSegment)), require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unbound", 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, wholeTimeline), {
+				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 [[UnshieldedWalletState.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-unshielded-wallet/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-unshielded-wallet/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 unshielded 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 unshielded 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 unshielded wallet snapshots of protocol version ${protocolVersion}.`,
+		protocolVersion
+	}))
+});
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v1/RunningV1Variant.js
+const progress = (state) => {
+	const appliedId = state.progress?.appliedId ?? 0n;
+	const sourceGap = (state.progress?.highestTransactionId ?? 0n) - appliedId;
+	const applyGap = appliedId - appliedId;
+	return [require_dist.ProgressUpdate({
+		sourceGap,
+		applyGap
+	})];
+};
+/**
+* The version signals this variant puts on its state stream.
+*
+* @remarks
+*   Two of them, for two different situations. A transition is the ordinary one: the state moved to a version the variant
+*   may or may not own, and the runtime decides. The healing emission covers restore: a snapshot taken between the
+*   moment sync annotated an out-of-range version and the moment the runtime acted on it comes back with a version this
+*   variant does not own and no transition to announce it, so it would sit there forever. Announcing it on the first
+*   observation is what forward-migrates such a snapshot.
+*/
+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;
+	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() {
+		return this.startSync().pipe(require_dist.runScoped(require_dist.drain), require_dist.forkScoped, require_dist.provideService(require_dist.Scope, this.#scope));
+	}
+	startSync() {
+		return require_dist.pipe(require_dist.get(this.#context.stateRef), require_dist.fromEffect, require_dist.flatMap((state) => this.#v1Context.syncService.updates(state)), require_dist.mapEffect((update) => {
+			return require_dist.updateEffect(this.#context.stateRef, (state) => require_dist.pipe(this.#v1Context.syncCapability.applyUpdate(state, update, this.#context.activationRange), require_dist.toEffect));
+		}), 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)));
+		}))));
+	}
+	balanceFinalizedTransaction(tx) {
+		return require_dist.modifyEffect(this.#context.stateRef, (state) => {
+			return require_dist.pipe(this.#v1Context.transactingCapability.balanceFinalizedTransaction(state, tx), require_dist.toEffect);
+		});
+	}
+	balanceUnboundTransaction(tx) {
+		return require_dist.modifyEffect(this.#context.stateRef, (state) => {
+			return require_dist.pipe(this.#v1Context.transactingCapability.balanceUnboundTransaction(state, tx), require_dist.toEffect);
+		});
+	}
+	balanceUnprovenTransaction(tx) {
+		return require_dist.modifyEffect(this.#context.stateRef, (state) => {
+			return require_dist.pipe(this.#v1Context.transactingCapability.balanceUnprovenTransaction(state, tx), require_dist.toEffect);
+		});
+	}
+	transferTransaction(outputs, ttl) {
+		return require_dist.modifyEffect(this.#context.stateRef, (state) => {
+			return require_dist.pipe(this.#v1Context.transactingCapability.makeTransfer(state, outputs, ttl), require_dist.toEffect, require_dist.map$2(({ transaction, newState }) => [transaction, newState]));
+		});
+	}
+	rotateUtxos(guaranteedUtxos, fallibleUtxos, nightVerifyingKey, ttl) {
+		return require_dist.modifyEffect(this.#context.stateRef, (state) => {
+			return require_dist.pipe(this.#v1Context.transactingCapability.rotateUtxos(state, guaranteedUtxos, fallibleUtxos, nightVerifyingKey, ttl), require_dist.toEffect, require_dist.map$2(({ transaction, newState }) => [transaction, newState]));
+		});
+	}
+	initSwap(desiredInputs, desiredOutputs, ttl) {
+		return require_dist.modifyEffect(this.#context.stateRef, (state) => {
+			return require_dist.pipe(this.#v1Context.transactingCapability.initSwap(state, desiredInputs, desiredOutputs, ttl), require_dist.map$2(({ transaction, newState }) => [transaction, newState]));
+		});
+	}
+	signUnprovenTransaction(transaction, signSegment) {
+		return this.#v1Context.signingService.sign(transaction, signSegment);
+	}
+	signUnboundTransaction(transaction, signSegment) {
+		return this.#v1Context.signingService.sign(transaction, signSegment);
+	}
+	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-unshielded-wallet/dist/v1/WalletError.js
+var OtherWalletError = class extends require_dist.TaggedError("Wallet.Other") {};
+var SyncWalletError = class extends require_dist.TaggedError("Wallet.Sync") {};
+var InsufficientFundsError = class extends require_dist.TaggedError("Wallet.InsufficientFunds") {};
+var TransactingError = class extends require_dist.TaggedError("Wallet.Transacting") {};
+var SignError = class extends require_dist.TaggedError("Wallet.Sign") {};
+var ApplyTransactionError = class extends require_dist.TaggedError("Wallet.ApplyTransaction") {};
+/**
+* Raised when a sync source delivers a transaction the wallet has already folded — an id strictly below its applied
+* cursor — so applying it again would double-count the UTXOs that transaction created or spent.
+*
+* @remarks
+*   The id a wallet is served is the indexer's global transaction id filtered to this address, so what reaches it is a
+*   strictly increasing but sparse subsequence: "is this past my cursor?" is the only ordering question it can answer,
+*   and contiguity is not one of them. An id EQUAL to the cursor is the resume boundary answered inclusively and folds
+*   to a no-op rather than to this error; only a strictly lower one is a replay.
+*
+*   Nothing is written when it is produced. The fold hands this back in place of a new state, so the running variant
+*   never writes its `SubscriptionRef`: the wallet keeps the state and the cursor it had, the sync stream fails, and
+*   the retry reopens the subscription at that same unmoved cursor — which is what gives the source the chance to
+*   deliver the timeline in order.
+* @example
+*   ```ts
+*   import { Either } from 'effect';
+*
+*   const outcome = capability.applyUpdate(wallet, update, activeRange);
+*   if (Either.isLeft(outcome) && outcome.left._tag === 'Wallet.OutOfOrderSyncUpdate') {
+*   console.warn(`replayed ${outcome.left.received}, already at ${outcome.left.expected}`);
+*   }
+*   ```
+*/
+var OutOfOrderSyncUpdateError = class extends require_dist.TaggedError("Wallet.OutOfOrderSyncUpdate") {};
+var RollbackUtxoError = class extends require_dist.TaggedError("Wallet.RollbackUtxo") {};
+var SpendUtxoError = class extends require_dist.TaggedError("Wallet.SpendUtxo") {};
+var TransactionHistoryError = class extends require_dist.TaggedError("Wallet.TransactionHistory") {};
+var UtxoNotFoundError = class extends require_dist.TaggedError("UtxoNotFoundError") {};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v1/SyncProgress.js
+const SyncProgress = { isCompleteWithin(data, maxGap = 50n) {
+	const applyLag = BigInt(Math.abs(Number(data.highestTransactionId - data.appliedId)));
+	return data.isConnected && applyLag <= maxGap;
+} };
+const createSyncProgress = (params = {}) => {
+	const { appliedId = 0n, highestTransactionId = 0n, isConnected = false } = params;
+	return {
+		appliedId,
+		highestTransactionId,
+		isConnected,
+		isStrictlyComplete() {
+			return SyncProgress.isCompleteWithin(this, 0n);
+		},
+		isCompleteWithin(maxGap) {
+			return SyncProgress.isCompleteWithin(this, maxGap);
+		}
+	};
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v1/UnshieldedState.js
+const UtxoHash = (utxo) => `${utxo.intentHash}#${utxo.outputNo}`;
+/**
+* The first UTXO an update reports as spent that this state holds in neither map.
+*
+* @remarks
+*   A spend naming a UTXO the wallet has never held is not noise to absorb: it is the only observable sign that the
+*   source delivered a spend ahead of the create it consumes. Absorbed, the create arrives afterwards and puts an
+*   already-spent UTXO into the available set, where it will be offered for coin selection and produce a transaction
+*   the chain rejects. Reported, the fold fails before the caller's cursor moves, and the retry re-fetches the pair in
+*   order.
+* @param state The state the update is being folded into.
+* @param spentUtxos The UTXOs the update reports as spent.
+* @returns The first entry the state does not know, or `Option.none()` when every spend names a UTXO it holds.
+*/
+const firstUnknownSpend = (state, spentUtxos) => require_dist.findFirst(spentUtxos, (spent) => {
+	const hash = UtxoHash(spent.utxo);
+	return !require_dist.has(state.availableUtxos, hash) && !require_dist.has(state.pendingUtxos, hash);
+});
+const UnshieldedState = {
+	empty: () => ({
+		availableUtxos: require_dist.empty$1(),
+		pendingUtxos: require_dist.empty$1()
+	}),
+	restore: (availableUtxos, pendingUtxos) => ({
+		availableUtxos: require_dist.fromIterable(availableUtxos.map((utxo) => [UtxoHash(utxo.utxo), utxo])),
+		pendingUtxos: require_dist.fromIterable(pendingUtxos.map((utxo) => [UtxoHash(utxo.utxo), utxo]))
+	}),
+	spend: (state, utxo) => require_dist.gen$1(function* () {
+		const hash = UtxoHash(utxo.utxo);
+		if (!require_dist.has(state.availableUtxos, hash)) return yield* require_dist.left(new UtxoNotFoundError({ utxo: utxo.utxo }));
+		return {
+			availableUtxos: require_dist.remove(state.availableUtxos, hash),
+			pendingUtxos: require_dist.set$1(state.pendingUtxos, hash, utxo)
+		};
+	}),
+	rollbackSpend: (state, utxo) => {
+		const hash = UtxoHash(utxo.utxo);
+		if (!require_dist.has(state.pendingUtxos, hash)) return require_dist.right(state);
+		return require_dist.right({
+			availableUtxos: require_dist.set$1(state.availableUtxos, hash, utxo),
+			pendingUtxos: require_dist.remove(state.pendingUtxos, hash)
+		});
+	},
+	spendByUtxo: (state, utxo) => require_dist.gen$1(function* () {
+		const hash = UtxoHash(utxo);
+		const found = yield* require_dist.fromOption(require_dist.get$2(state.availableUtxos, hash), () => new UtxoNotFoundError({ utxo }));
+		return yield* UnshieldedState.spend(state, found);
+	}),
+	rollbackSpendByUtxo: (state, utxo) => require_dist.pipe(require_dist.get$2(state.pendingUtxos, UtxoHash(utxo)), require_dist.match$1({
+		onNone: () => require_dist.right(state),
+		onSome: (found) => UnshieldedState.rollbackSpend(state, found)
+	})),
+	applyUpdate: (state, update) => require_dist.gen$1(function* () {
+		if (!["SUCCESS", "PARTIAL_SUCCESS"].includes(update.status)) return yield* require_dist.left(new ApplyTransactionError({ message: `Invalid status: ${update.status}` }));
+		const unknownSpend = firstUnknownSpend(state, update.spentUtxos);
+		if (require_dist.isSome(unknownSpend)) return yield* require_dist.left(new UtxoNotFoundError({ utxo: unknownSpend.value.utxo }));
+		return {
+			availableUtxos: require_dist.union$1(require_dist.removeMany(state.availableUtxos, update.spentUtxos.map((utxo) => UtxoHash(utxo.utxo))), require_dist.fromIterable(update.createdUtxos.map((utxo) => [UtxoHash(utxo.utxo), utxo]))),
+			pendingUtxos: require_dist.removeMany(state.pendingUtxos, update.spentUtxos.map((utxo) => UtxoHash(utxo.utxo)))
+		};
+	}),
+	applyFailedUpdate: (state, update) => require_dist.gen$1(function* () {
+		if (update.status !== "FAILURE") return yield* require_dist.left(new ApplyTransactionError({ message: `Invalid status: ${update.status}` }));
+		const unknownSpend = firstUnknownSpend(state, update.spentUtxos);
+		if (require_dist.isSome(unknownSpend)) return yield* require_dist.left(new UtxoNotFoundError({ utxo: unknownSpend.value.utxo }));
+		return {
+			availableUtxos: require_dist.union$1(state.availableUtxos, require_dist.fromIterable(update.spentUtxos.map((utxo) => [UtxoHash(utxo.utxo), utxo]))),
+			pendingUtxos: require_dist.removeMany(state.pendingUtxos, update.spentUtxos.map((utxo) => UtxoHash(utxo.utxo)))
+		};
+	}),
+	toArrays: (state) => ({
+		availableUtxos: require_dist.toValues(state.availableUtxos),
+		pendingUtxos: require_dist.toValues(state.pendingUtxos)
+	})
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v1/CoreWallet.js
+const CoreWallet = {
+	init(publicKey, networkId) {
+		return {
+			state: UnshieldedState.empty(),
+			publicKey,
+			protocolVersion: require_dist.MinSupportedVersion,
+			progress: createSyncProgress(),
+			networkId
+		};
+	},
+	restore(state, publicKey, syncProgress, protocolVersion, networkId) {
+		return {
+			state,
+			publicKey,
+			protocolVersion,
+			progress: createSyncProgress(syncProgress),
+			networkId
+		};
+	},
+	updateProgress(wallet, { appliedId, highestTransactionId, isConnected }) {
+		const progress = createSyncProgress({
+			appliedId: appliedId ?? wallet.progress.appliedId,
+			highestTransactionId: highestTransactionId ?? wallet.progress.highestTransactionId,
+			isConnected: isConnected ?? wallet.progress.isConnected
+		});
+		return {
+			...wallet,
+			progress
+		};
+	},
+	withProtocolVersion(wallet, version) {
+		return version > wallet.protocolVersion ? {
+			...wallet,
+			protocolVersion: version
+		} : wallet;
+	},
+	applyUpdate(coreWallet, update) {
+		return UnshieldedState.applyUpdate(coreWallet.state, update).pipe(require_dist.map$6((state) => ({
+			...coreWallet,
+			state
+		})), require_dist.mapLeft((error) => new ApplyTransactionError(error)));
+	},
+	applyFailedUpdate(coreWallet, update) {
+		return UnshieldedState.applyFailedUpdate(coreWallet.state, update).pipe(require_dist.map$6((state) => ({
+			...coreWallet,
+			state
+		})), require_dist.mapLeft((error) => new ApplyTransactionError(error)));
+	},
+	rollbackUtxo(coreWallet, utxo) {
+		return UnshieldedState.rollbackSpendByUtxo(coreWallet.state, utxo).pipe(require_dist.map$6((state) => ({
+			...coreWallet,
+			state
+		})), require_dist.mapLeft((error) => new RollbackUtxoError(error)));
+	},
+	spend(coreWallet, utxo) {
+		return UnshieldedState.spendByUtxo(coreWallet.state, utxo).pipe(require_dist.map$6((state) => ({
+			...coreWallet,
+			state
+		})), require_dist.mapLeft((error) => new SpendUtxoError(error)));
+	},
+	spendUtxos(wallet, utxos) {
+		return require_dist.pipe(utxos, require_dist.reduce(require_dist.right([[], wallet.state]), (acc, utxoToSpend) => acc.pipe(require_dist.flatMap$4(([accUtxos, state]) => UnshieldedState.spendByUtxo(state, utxoToSpend).pipe(require_dist.map$6((nextState) => [accUtxos.concat([utxoToSpend]), nextState]), require_dist.mapLeft((error) => new SpendUtxoError(error)))))), require_dist.map$6(([spentUtxos, state]) => [spentUtxos, {
+			...wallet,
+			state
+		}]));
+	}
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v1/Serialization.js
+/**
+* Asserts that a {@link PublicKey}'s stored address was really derived from its stored verifying key.
+*
+* @remarks
+*   Deserialization is a trust boundary — a snapshot is whatever was handed back to the wallet — and the schema alone
+*   cannot catch a spliced key/address pair, since both fields are well-formed strings either way. Deriving one from
+*   the other is what shows they belong together. Deriving also exercises the ledger's key decoder, which traps in wasm
+*   on a malformed key, so the call is wrapped and the boundary fails closed with a typed error rather than letting an
+*   exception escape.
+*
+*   The ledger-v9 variant makes the same assertion but reports a mismatch as a `SchemeMismatchError`, naming the
+*   signature scheme the address must have been derived under. Ledger-v8 has a single scheme, so there is no scheme to
+*   name and the mismatch is an ordinary wallet error.
+* @param publicKey - The public-key bundle read out of a snapshot.
+* @returns `Right(publicKey)` when the address matches the key; otherwise `Left(OtherWalletError)`.
+*/
+const assertKeyAddressConsistency = (publicKey) => require_dist.pipe(require_dist.try_$1({
+	try: () => (0, _midnight_ntwrk_ledger_v8.addressFromKey)(publicKey.publicKey),
+	catch: (cause) => new OtherWalletError({
+		message: "Unshielded verifying key could not be decoded.",
+		cause
+	})
+}), require_dist.flatMap$4((derivedAddress) => derivedAddress === publicKey.addressHex ? require_dist.right(publicKey) : require_dist.left(new OtherWalletError({ message: "Unshielded address does not match its verifying key." }))));
+const makeDefaultV1SerializationCapability = () => {
+	const UtxoWithMetaSchema = require_dist.Struct({
+		utxo: require_dist.Struct({
+			value: require_dist.BigInt$,
+			owner: require_dist.String$,
+			type: require_dist.String$,
+			intentHash: require_dist.String$,
+			outputNo: require_dist.Number$
+		}),
+		meta: require_dist.Struct({
+			ctime: require_dist.Date$,
+			registeredForDustGeneration: require_dist.Boolean$
+		})
+	});
+	const SnapshotSchema = require_dist.Struct({
+		publicKey: require_dist.Struct({
+			publicKey: require_dist.String$,
+			addressHex: require_dist.String$,
+			address: require_dist.String$
+		}),
+		state: require_dist.Struct({
+			availableUtxos: require_dist.Array$(UtxoWithMetaSchema),
+			pendingUtxos: require_dist.Array$(UtxoWithMetaSchema)
+		}),
+		protocolVersion: require_dist.BigInt$,
+		appliedId: require_dist.optional(require_dist.BigInt$),
+		networkId: require_dist.String$
+	});
+	return {
+		serialize: (wallet) => {
+			const buildSnapshot = (w) => ({
+				publicKey: w.publicKey,
+				state: UnshieldedState.toArrays(w.state),
+				protocolVersion: w.protocolVersion,
+				networkId: w.networkId,
+				appliedId: w.progress?.appliedId
+			});
+			return require_dist.pipe(wallet, buildSnapshot, require_dist.encodeSync(SnapshotSchema), JSON.stringify);
+		},
+		deserialize: (serialized) => require_dist.pipe(serialized, require_dist.decodeUnknownEither(require_dist.parseJson(SnapshotSchema)), require_dist.mapLeft((err) => new OtherWalletError(err)), require_dist.flatMap$4((snapshot) => require_dist.pipe(assertKeyAddressConsistency(snapshot.publicKey), require_dist.map$6(() => snapshot))), require_dist.map$6((snapshot) => {
+			return CoreWallet.restore(UnshieldedState.restore(snapshot.state.availableUtxos, snapshot.state.pendingUtxos), snapshot.publicKey, {
+				highestTransactionId: snapshot.appliedId ?? 0n,
+				appliedId: snapshot.appliedId ?? 0n
+			}, require_dist.ProtocolVersion(snapshot.protocolVersion), snapshot.networkId);
+		}))
+	};
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v1/SyncSchema.js
+const DateFromMillis = require_dist.transform(require_dist.Number$, require_dist.DateFromSelf, {
+	strict: true,
+	decode: (millis) => new Date(millis),
+	encode: (date) => date.getTime()
+});
+const WireUtxoSchema = require_dist.Struct({
+	value: require_dist.SafeBigInt,
+	owner: require_dist.String$,
+	tokenType: require_dist.String$,
+	intentHash: require_dist.String$,
+	outputIndex: require_dist.Number$,
+	ctime: require_dist.Number$,
+	registeredForDustGeneration: require_dist.Boolean$
+});
+const UtxoWithMetaSchema = require_dist.transform(WireUtxoSchema, require_dist.typeSchema(require_dist.Struct({
+	utxo: require_dist.Struct({
+		value: require_dist.BigIntSchema,
+		owner: require_dist.String$,
+		type: require_dist.String$,
+		intentHash: require_dist.String$,
+		outputNo: require_dist.Number$
+	}),
+	meta: require_dist.Struct({
+		ctime: require_dist.DateFromSelf,
+		registeredForDustGeneration: require_dist.Boolean$
+	})
+})), {
+	strict: true,
+	decode: (wire) => ({
+		utxo: {
+			value: wire.value,
+			owner: wire.owner,
+			type: wire.tokenType,
+			intentHash: wire.intentHash,
+			outputNo: wire.outputIndex
+		},
+		meta: {
+			ctime: /* @__PURE__ */ new Date(wire.ctime * 1e3),
+			registeredForDustGeneration: wire.registeredForDustGeneration
+		}
+	}),
+	encode: (domain) => ({
+		value: domain.utxo.value,
+		owner: domain.utxo.owner,
+		tokenType: domain.utxo.type,
+		intentHash: domain.utxo.intentHash,
+		outputIndex: domain.utxo.outputNo,
+		ctime: Math.floor(domain.meta.ctime.getTime() / 1e3),
+		registeredForDustGeneration: domain.meta.registeredForDustGeneration
+	})
+});
+const UnshieldedTransactionSchema = require_dist.Data(require_dist.Struct({
+	id: require_dist.Number$,
+	hash: require_dist.String$,
+	type: require_dist.Literal("RegularTransaction", "SystemTransaction", "BridgeClaimTransaction"),
+	protocolVersion: require_dist.Number$,
+	identifiers: require_dist.optional(require_dist.Array$(require_dist.String$)),
+	block: require_dist.Struct({
+		hash: require_dist.String$,
+		height: require_dist.Number$,
+		timestamp: DateFromMillis
+	}),
+	fees: require_dist.optional(require_dist.Struct({
+		paidFees: require_dist.SafeBigInt,
+		estimatedFees: require_dist.SafeBigInt
+	})),
+	transactionResult: require_dist.optional(require_dist.Struct({
+		status: require_dist.Literal("SUCCESS", "FAILURE", "PARTIAL_SUCCESS"),
+		segments: require_dist.NullOr(require_dist.Array$(require_dist.Struct({
+			id: require_dist.Number$,
+			success: require_dist.Boolean$
+		})))
+	}))
+}));
+const UnshieldedUpdateWireSchema = require_dist.Struct({
+	type: require_dist.Literal("UnshieldedTransaction"),
+	transaction: UnshieldedTransactionSchema,
+	createdUtxos: require_dist.Array$(UtxoWithMetaSchema),
+	spentUtxos: require_dist.Array$(UtxoWithMetaSchema)
+});
+const UnshieldedUpdateSchema = require_dist.transform(UnshieldedUpdateWireSchema, require_dist.typeSchema(require_dist.Struct({
+	type: require_dist.Literal("UnshieldedTransaction"),
+	transaction: UnshieldedTransactionSchema,
+	createdUtxos: require_dist.Array$(require_dist.typeSchema(UtxoWithMetaSchema)),
+	spentUtxos: require_dist.Array$(require_dist.typeSchema(UtxoWithMetaSchema)),
+	status: require_dist.Literal("SUCCESS", "FAILURE", "PARTIAL_SUCCESS")
+})), {
+	strict: true,
+	decode: (wire) => {
+		const isStatusImplicitlySuccess = ["SystemTransaction", "BridgeClaimTransaction"].includes(wire.transaction.type);
+		return {
+			...wire,
+			status: isStatusImplicitlySuccess ? "SUCCESS" : wire.transaction.transactionResult.status
+		};
+	},
+	encode: ({ status: _status, ...rest }) => rest
+});
+const ProgressSchema = require_dist.Struct({
+	type: require_dist.Literal("UnshieldedTransactionsProgress"),
+	highestTransactionId: require_dist.Number$,
+	protocolVersion: require_dist.Number$
+});
+const WalletSyncUpdateSchema = require_dist.Union(UnshieldedUpdateSchema, ProgressSchema);
+const VersionSignalSyncUpdate = { create: (version, highestTransactionId) => {
+	return {
+		type: "VersionSignal",
+		version,
+		highestTransactionId
+	};
+} };
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v1/Sync.js
+/**
+* Whether a reported protocol version belongs to a variant later than the one owning `activeRange`.
+*
+* @remarks
+*   Unshielded sync is message-at-a-time, so this is the whole of the boundary rule — there is no batch to split into an
+*   applied prefix and a deferred suffix, only a yes/no per message. Exported so the indexer and simulator sync
+*   capabilities cannot drift apart on the question.
+* @param version The protocol version the source reported for this message.
+* @param activeRange The running variant's half-open activation range.
+* @returns `true` when the message must be left unapplied.
+*/
+const isBeyondActiveRange = (version, activeRange) => BigInt(version) >= activeRange[1];
+/**
+* Records an observed protocol version on the state, monotonically.
+*
+* @remarks
+*   This is the only thing written when a message is deferred at the boundary, and it is what the runtime watches to
+*   decide that the variant must hand over.
+* @param state The state to annotate.
+* @param version The protocol version the source reported.
+* @returns The state carrying the higher of the two versions.
+*/
+const annotateVersion = (state, version) => CoreWallet.withProtocolVersion(state, require_dist.ProtocolVersion(BigInt(version)));
+/**
+* Splits the chain's protocol version off a progress frame, into a signal of its own.
+*
+* @remarks
+*   This is how a wallet nobody pays learns that the chain moved. Ordinarily a version reaches it on a transaction it was
+*   served, and it is served only the transactions that touch its own address — so on a chain that crosses a protocol
+*   boundary and then pays this address nothing, it would observe no version at all and stay on the variant it was
+*   running, with everything built through it routed to that variant's ledger. The progress arm has no such silence:
+*   the indexer emits it before its first sleep and keeps emitting it, on an address the chain has never mentioned
+*   exactly as on a busy one, and it states the version at the chain's tip.
+*
+*   Split off rather than folded in place, because the two things a frame says are governed by different rules. Progress
+*   is bookkeeping and always applies. A version may be recorded only when the wallet is level with the far end of this
+*   address's timeline, or the hand-over would park the sync cursor in front of history that the next variant would
+*   then apply without ever having seen what led to it. Keeping the signal a message of its own leaves that gate
+*   exactly where the capability already implements it — and the frame states both halves in one indexed instant, so
+*   the version can no longer be read against a timeline end that moved between two separate answers.
+*
+*   Two frames are worth no signal. Zero is the source reporting that it has indexed no block yet, not a chain at version
+*   zero; read as a version it would be a claim nobody made. And a version at or below the one the wallet already held
+*   could only ever be a no-op, because the recorded version never goes backwards — suppressing it is what keeps a
+*   settled wallet's progress frames from putting a redundant message on the stream for the rest of its life.
+* @param update The decoded subscription message.
+* @param knownVersion The version the wallet held when this stream opened — a lower bound on what it holds now.
+* @returns The message, followed by the signal when the frame carries a version worth recording.
+*/
+const withVersionSignal = (update, knownVersion) => update.type === "UnshieldedTransactionsProgress" && update.protocolVersion !== 0 && BigInt(update.protocolVersion) > knownVersion ? [update, VersionSignalSyncUpdate.create(update.protocolVersion, update.highestTransactionId)] : [update];
+const makeDefaultSyncService = (config) => {
+	return { updates: (state) => {
+		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 { appliedId } = state.progress;
+		const { address } = state.publicKey;
+		return require_dist.pipe(require_dist.UnshieldedTransactions.run({
+			address,
+			transactionId: Number(appliedId)
+		}), require_dist.provideLayer(require_dist.layer({
+			url: indexerWsUrl,
+			keepAlive: indexerClientConnection.keepAlive
+		})), require_dist.mapError((error) => new SyncWalletError(error)), require_dist.mapEffect((subscription) => {
+			const { unshieldedTransactions } = subscription;
+			return require_dist.pipe(require_dist.decodeUnknownEither(WalletSyncUpdateSchema)(unshieldedTransactions), require_dist.mapLeft((err) => new SyncWalletError(err)), require_dist.toEffect);
+		}), require_dist.mapConcat((update) => withVersionSignal(update, state.protocolVersion)));
+	} };
+};
+/**
+* Folds a version signal: records the chain's version, and nothing else.
+*
+* @remarks
+*   The same recording the transaction path makes through {@link annotateVersion}: no cursor moves, no UTXO changes hands.
+*   A signal is an observation about the chain, not a piece of it.
+*
+*   One situation makes the observation unsafe to record, and it leaves the state exactly as it was. A transaction still
+*   unapplied below the address's tip means the hand-over would park the cursor in front of history the next variant
+*   would then apply without ever having seen what led to it — and that transaction carries the version itself, so
+*   nothing is lost by waiting for it. 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 — `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 signal What the chain said, and how far this address's timeline goes.
+* @returns The wallet, annotated or untouched.
+*/
+const applyVersionSignal = (state, signal) => require_dist.right(BigInt(signal.highestTransactionId) > state.progress.appliedId ? state : annotateVersion(state, signal.version));
+/**
+* Folds a progress frame: moves the far end of the cursor, and nothing else.
+*
+* @remarks
+*   A progress message reports how far the source has got with this address, not a transaction. The chain version it also
+*   carries is deliberately not read here: the source splits that off into its own `VersionSignal`, which is the only
+*   message allowed to annotate, and which alone carries the gate in {@link applyVersionSignal}. Annotating from both
+*   places would put the gate on one route and not the other.
+* @param state The wallet to record on.
+* @param progress The frame.
+* @returns The wallet with the far end of its cursor moved and marked connected.
+*/
+const applyProgress = (state, progress) => require_dist.right(CoreWallet.updateProgress(state, {
+	highestTransactionId: BigInt(progress.highestTransactionId),
+	isConnected: true
+}));
+/**
+* Classifies a delivered transaction; {@link applyTransaction} acts on the answer.
+*
+* @remarks
+*   "Is this past the cursor?" is the only ordering question askable here. The id is the indexer's global transaction id
+*   filtered to this address, so a wallet is served a strictly increasing but SPARSE subsequence of it — consecutive
+*   deliveries routinely skip whole runs of ids belonging to other addresses — and demanding contiguity would reject
+*   every honest stream. What a gap cannot hide is a spend whose create was never folded: `UnshieldedState` refuses a
+*   spend of a UTXO it holds in neither map, and that refusal, not this classification, is what catches a spend
+*   delivered ahead of its create. It happens before the cursor moves, so the retry re-fetches the pair in order.
+*
+*   Whether the resume cursor the subscription is opened with is inclusive is undocumented, so the transaction it names
+*   may or may not reappear on a reconnect; calling an equal id `redelivered` makes the fold indifferent either way,
+*   exactly as the shielded and dust wallets treat their own boundary event.
+* @param state The wallet the transaction was delivered to.
+* @param update The delivered transaction.
+* @param activeRange The half-open protocol version range the running variant owns.
+* @returns The placement.
+*/
+const placeTransaction = (state, update, activeRange) => {
+	const received = BigInt(update.transaction.id);
+	const cursor = state.progress.appliedId;
+	return received < cursor ? "replayed" : received === cursor ? "redelivered" : isBeyondActiveRange(update.transaction.protocolVersion, activeRange) ? "deferred" : "applicable";
+};
+/**
+* Folds an applicable transaction: the UTXO changes, then the cursor, the history record and the version.
+*
+* @remarks
+*   The history is written only once the fold has succeeded, so a rejected transaction leaves no trace there either.
+* @param state The wallet to fold into.
+* @param update The delivered transaction.
+* @param getContext Where the transaction history lives.
+* @returns The folded wallet, or the fold's refusal.
+*/
+const foldTransaction = (state, update, getContext) => {
+	const payload = {
+		createdUtxos: update.createdUtxos,
+		spentUtxos: update.spentUtxos,
+		status: update.status
+	};
+	return (update.status === "FAILURE" ? CoreWallet.applyFailedUpdate(state, payload) : CoreWallet.applyUpdate(state, payload)).pipe(require_dist.map$6((wallet) => {
+		const advanced = CoreWallet.updateProgress(wallet, { appliedId: BigInt(update.transaction.id) });
+		require_dist.runFork(getContext().transactionHistoryService.put(update));
+		return annotateVersion(advanced, update.transaction.protocolVersion);
+	}));
+};
+/**
+* Folds a delivered transaction according to its {@link TransactionPlacement}.
+*
+* @remarks
+*   - `replayed` is refused with {@link OutOfOrderSyncUpdateError} and nothing is applied: folding a create twice resurrects
+*       a UTXO some later transaction has since spent; folding a spend twice removes one some later transaction
+*       re-created. The state is handed back untouched so the retry can re-fetch in order.
+*   - `redelivered` is a no-op in the strongest sense — the same state comes back: no UTXO change, no cursor movement, no
+*       version annotation, no transaction-history write. All of that was done the first time it arrived.
+*   - `deferred` is the hand-over point. The transaction belongs to the next variant, so NOTHING about it is applied; only
+*       the version is recorded, which is what makes the runtime migrate. Because the cursor did not move, the next
+*       variant re-fetches this very transaction and applies it exactly once.
+*   - `applicable` is folded by {@link foldTransaction}.
+*
+* @param state The wallet the transaction was delivered to.
+* @param update The delivered transaction.
+* @param activeRange The half-open protocol version range the running variant owns.
+* @param getContext Where the transaction history lives.
+* @returns The next wallet, or the refusal.
+*/
+const applyTransaction = (state, update, activeRange, getContext) => value(placeTransaction(state, update, activeRange)).pipe(when("replayed", () => require_dist.left(new OutOfOrderSyncUpdateError({
+	message: `Sync source delivered transaction ${update.transaction.id}, below the applied cursor ${state.progress.appliedId}; the state is left untouched so the retry can re-fetch in order`,
+	expected: state.progress.appliedId,
+	received: BigInt(update.transaction.id)
+}))), when("redelivered", () => require_dist.right(state)), when("deferred", () => require_dist.right(annotateVersion(state, update.transaction.protocolVersion))), when("applicable", () => foldTransaction(state, update, getContext)), exhaustive);
+const makeDefaultSyncCapability = (_config, getContext) => {
+	return { applyUpdate: (state, update, activeRange) => value(update).pipe(discriminatorsExhaustive("type")({
+		VersionSignal: (signal) => applyVersionSignal(state, signal),
+		UnshieldedTransactionsProgress: (progress) => applyProgress(state, progress),
+		UnshieldedTransaction: (transaction) => applyTransaction(state, transaction, activeRange, getContext)
+	})) };
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v1/TransactionOps.js
+const TransactionOps = {
+	getSignatureData(tx, segment) {
+		if (!tx.intents) return require_dist.left(new TransactingError({ message: "Transaction has no intents" }));
+		const intent = tx.intents.get(segment);
+		if (!intent) return require_dist.left(new TransactingError({ message: `Intent with segment ${segment} was not found` }));
+		return require_dist.try_$1({
+			try: () => intent.signatureData(segment),
+			catch: (error) => new TransactingError({
+				message: "Failed to get offer signature data",
+				cause: error
+			})
+		});
+	},
+	getSegments(transaction) {
+		return transaction.intents?.keys().toArray() ?? [];
+	},
+	findAvailableSegmentId(transaction) {
+		const used = new Set(transaction.intents?.keys() ?? []);
+		return require_dist.pipe(require_dist.range(1, 65535), require_dist.findFirst$1((segmentId) => !used.has(segmentId)));
+	},
+	addSignature(transaction, signature, segment) {
+		return require_dist.gen$1(function* () {
+			if (!transaction.intents || transaction.intents.size === 0) return yield* require_dist.left(new TransactingError({ message: "No intents found in the transaction" }));
+			const intent = transaction.intents?.get(segment);
+			if (!intent) return yield* require_dist.left(new TransactingError({ message: `Intent with id ${segment} was not found` }));
+			if (TransactionOps.isIntentBound(intent)) return yield* require_dist.left(new TransactingError({ message: `Intent at segment ${segment} is already bound` }));
+			if (intent.fallibleUnshieldedOffer) intent.fallibleUnshieldedOffer = yield* TransactionOps.addSignaturesToOffer(intent.fallibleUnshieldedOffer, signature, segment, "fallible");
+			if (intent.guaranteedUnshieldedOffer) intent.guaranteedUnshieldedOffer = yield* TransactionOps.addSignaturesToOffer(intent.guaranteedUnshieldedOffer, signature, segment, "guaranteed");
+			transaction.intents = transaction.intents.set(segment, intent);
+			return transaction;
+		});
+	},
+	collectSignableData(transaction) {
+		return require_dist.all$1(TransactionOps.getSegments(transaction).map((segment) => require_dist.map$6(TransactionOps.getSignatureData(transaction, segment), (data) => ({
+			segment,
+			data
+		}))));
+	},
+	attachSignatures(transaction, signatures) {
+		const seed = require_dist.right(transaction);
+		return require_dist.pipe(signatures, require_dist.reduce(seed, (acc, { segment, signature }) => require_dist.flatMap$4(acc, (tx) => TransactionOps.addSignature(tx, signature, segment))));
+	},
+	getImbalances(transaction, segment) {
+		const imbalances = transaction.imbalances(segment).entries().filter(([token, value]) => token.tag === "unshielded" && value !== 0n).map(([token, value]) => [token.raw.toString(), value]).toArray();
+		return require_dist.Imbalances.fromEntries(imbalances);
+	},
+	addSignaturesToOffer(offer, signature, segment, offerType) {
+		return require_dist.pipe(offer.inputs, require_dist.map$3((_, i) => offer.signatures.at(i) ?? signature), (signatures) => require_dist.try_$1({
+			try: () => offer.addSignatures(signatures),
+			catch: (error) => new TransactingError({
+				message: `Failed to add ${offerType} signature at segment ${segment}`,
+				cause: error
+			})
+		}));
+	},
+	isIntentBound(intent) {
+		return intent.binding.instance === "binding";
+	},
+	extractOwnInputs(transaction, signatureVerifyingKey) {
+		const segments = TransactionOps.getSegments(transaction);
+		const ownerAddress = (0, _midnight_ntwrk_ledger_v8.addressFromKey)(signatureVerifyingKey);
+		const toUtxo = (input) => ({
+			...input,
+			owner: ownerAddress
+		});
+		return require_dist.pipe(segments, require_dist.flatMap$2((segment) => {
+			const intent = transaction.intents?.get(segment);
+			if (!intent) return [];
+			const { guaranteedUnshieldedOffer, fallibleUnshieldedOffer } = intent;
+			const ownedInputsfromGuaranteedSection = guaranteedUnshieldedOffer?.inputs ? guaranteedUnshieldedOffer.inputs.filter((input) => input.owner === signatureVerifyingKey) : [];
+			const ownedInputsfromFallibleSection = fallibleUnshieldedOffer ? fallibleUnshieldedOffer.inputs.filter((input) => input.owner === signatureVerifyingKey) : [];
+			return [...ownedInputsfromGuaranteedSection, ...ownedInputsfromFallibleSection].map(toUtxo);
+		}));
+	}
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v1/Transacting.js
+const GUARANTEED_SEGMENT = 0;
+const makeDefaultTransactingCapability = (config, getContext) => {
+	return new TransactingCapabilityImplementation(config.networkId, () => getContext().coinSelection, () => getContext().coinsAndBalancesCapability, () => getContext().keysCapability, TransactionOps);
+};
+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;
+	}
+	/**
+	* Balances an unbound transaction Note: Unbound transactions are balanced in place and returned
+	*
+	* @param wallet - The wallet to balance the transaction with
+	* @param transaction - The transaction to balance
+	* @returns The balanced transaction and the new wallet state if successful, otherwise an error
+	*/
+	balanceUnboundTransaction(wallet, transaction) {
+		return this.#balanceUnboundishTransaction(wallet, transaction);
+	}
+	/**
+	* Balances an unproven transaction Note: This method does the same thing as balanceUnboundTransaction but is provided
+	* for convenience and type safety
+	*
+	* @param wallet - The wallet to balance the transaction with
+	* @param transaction - The transaction to balance
+	* @returns The balanced transaction and the new wallet state if successful, otherwise an error
+	*/
+	balanceUnprovenTransaction(wallet, transaction) {
+		return this.#balanceUnboundishTransaction(wallet, transaction);
+	}
+	/**
+	* Balances a bound transaction Note: In bound transactions we can only balance the guaranteed section in intents
+	*
+	* @param wallet - The wallet to balance the transaction with
+	* @param transaction - The transaction to balance
+	* @returns A balancing counterpart transaction (which should be merged with the original transaction ) and the new
+	*   wallet state if successful, otherwise an error
+	*/
+	balanceFinalizedTransaction(wallet, transaction) {
+		return require_dist.gen$1(this, function* () {
+			const segments = this.txOps.getSegments(transaction);
+			for (const segment of segments) {
+				const intent = transaction.intents?.get(segment);
+				if (!this.txOps.isIntentBound(intent)) return yield* require_dist.left(new TransactingError({ message: `Intent with id ${segment} is not bound` }));
+			}
+			const intent = transaction.intents?.get(segments[0]);
+			const imbalances = this.txOps.getImbalances(transaction, GUARANTEED_SEGMENT);
+			if (imbalances.size === 0) return [void 0, wallet];
+			const recipe = yield* this.#balanceSegment(wallet, imbalances, require_dist.Imbalances.empty(), this.getCoinSelection());
+			const { newState, offer } = yield* this.#prepareOffer(wallet, recipe);
+			const balancingIntent = _midnight_ntwrk_ledger_v8.Intent.new(intent.ttl);
+			balancingIntent.guaranteedUnshieldedOffer = offer;
+			const segmentId = require_dist.getOrElse(this.txOps.findAvailableSegmentId(transaction), () => 1);
+			return [_midnight_ntwrk_ledger_v8.Transaction.fromParts(this.networkId).addIntent({
+				tag: "specific",
+				value: segmentId
+			}, balancingIntent), newState];
+		});
+	}
+	/**
+	* Makes a transfer transaction
+	*
+	* @param wallet - The wallet to make the transfer with
+	* @param outputs - The outputs for the transfer
+	* @param ttl - The TTL for the transaction
+	* @returns The balanced transfer transaction and the new wallet state if successful, otherwise an error
+	*/
+	makeTransfer(wallet, outputs, ttl) {
+		return require_dist.gen$1(this, function* () {
+			const { networkId } = this;
+			if (!outputs.every((output) => output.amount > 0n)) return yield* require_dist.left(new TransactingError({ message: "The amount of all inputs needs to be positive" }));
+			const ledgerOutputs = outputs.map((output) => {
+				return {
+					value: output.amount,
+					owner: output.receiverAddress.data.toString("hex"),
+					type: output.type
+				};
+			});
+			const recipe = yield* this.#balanceSegment(wallet, require_dist.Imbalances.empty(), require_dist.Imbalances.fromEntries(ledgerOutputs.map((output) => [output.type, output.value])), this.getCoinSelection());
+			const { newState, offer } = yield* this.#prepareOffer(wallet, {
+				inputs: recipe.inputs,
+				outputs: [...recipe.outputs, ...ledgerOutputs]
+			});
+			const intent = _midnight_ntwrk_ledger_v8.Intent.new(ttl);
+			if (ledgerOutputs.some((output) => output.type === require_dist.Token.night)) intent.fallibleUnshieldedOffer = offer;
+			else intent.guaranteedUnshieldedOffer = offer;
+			return {
+				newState,
+				transaction: _midnight_ntwrk_ledger_v8.Transaction.fromParts(networkId, void 0, void 0, intent)
+			};
+		});
+	}
+	rotateUtxos(wallet, guaranteedUtxos, fallibleUtxos, nightVerifyingKey, ttl) {
+		return require_dist.gen$1(this, function* () {
+			const { networkId } = this;
+			if (guaranteedUtxos.length === 0 && fallibleUtxos.length === 0) return yield* require_dist.left(new TransactingError({ message: "At least one UTxO must be provided to rotateUtxos" }));
+			const ownerAddress = _midnight_ntwrk_ledger_v8.addressFromKey(nightVerifyingKey);
+			const makeOffer = (utxos) => {
+				if (utxos.length === 0) return require_dist.none();
+				const inputs = utxos.map(({ utxo }) => ({
+					value: utxo.value,
+					type: utxo.type,
+					intentHash: utxo.intentHash,
+					outputNo: utxo.outputNo,
+					owner: nightVerifyingKey
+				}));
+				const totalValue = require_dist.pipe(utxos, require_dist.map$3(({ utxo }) => utxo.value), require_dist.reduce(0n, (a, b) => a + b));
+				const output = {
+					owner: ownerAddress,
+					type: require_dist.Token.night,
+					value: totalValue
+				};
+				return require_dist.some(_midnight_ntwrk_ledger_v8.UnshieldedOffer.new(inputs, [output], []));
+			};
+			const allUtxos = [...guaranteedUtxos, ...fallibleUtxos].map(({ utxo }) => utxo);
+			const [, walletAfterBooking] = yield* CoreWallet.spendUtxos(wallet, allUtxos);
+			const guaranteedOffer = makeOffer(guaranteedUtxos);
+			const fallibleOffer = makeOffer(fallibleUtxos);
+			const intent = require_dist.pipe(_midnight_ntwrk_ledger_v8.Intent.new(ttl), (i) => require_dist.match$1(guaranteedOffer, {
+				onNone: () => i,
+				onSome: (offer) => {
+					i.guaranteedUnshieldedOffer = offer;
+					return i;
+				}
+			}), (i) => require_dist.match$1(fallibleOffer, {
+				onNone: () => i,
+				onSome: (offer) => {
+					i.fallibleUnshieldedOffer = offer;
+					return i;
+				}
+			}));
+			return {
+				newState: walletAfterBooking,
+				transaction: _midnight_ntwrk_ledger_v8.Transaction.fromParts(networkId, void 0, void 0, intent)
+			};
+		});
+	}
+	/**
+	* Initializes a swap transaction
+	*
+	* @param wallet - The wallet to initialize the swap for
+	* @param desiredInputs - The desired inputs for the swap
+	* @param desiredOutputs - The desired outputs for the swap
+	* @param ttl - The TTL for the swap
+	* @returns The initialized swap transaction and the new wallet state if successful, otherwise an error
+	*/
+	initSwap(wallet, desiredInputs, desiredOutputs, ttl) {
+		return require_dist.gen$1(this, function* () {
+			const { networkId } = this;
+			if (!desiredOutputs.every((output) => output.amount > 0n)) return yield* require_dist.left(new TransactingError({ message: "The amount of all outputs needs to be positive" }));
+			if (!Object.entries(desiredInputs).every(([, amount]) => amount > 0n)) return yield* require_dist.left(new TransactingError({ message: "The amount of all inputs needs to be positive" }));
+			const ledgerOutputs = desiredOutputs.map((output) => ({
+				value: output.amount,
+				owner: output.receiverAddress.data.toString("hex"),
+				type: output.type
+			}));
+			const targetImbalances = require_dist.Imbalances.fromEntries(Object.entries(desiredInputs));
+			const recipe = yield* this.#balanceSegment(wallet, require_dist.Imbalances.empty(), targetImbalances, this.getCoinSelection());
+			const { newState, offer } = yield* this.#prepareOffer(wallet, {
+				inputs: recipe.inputs,
+				outputs: [...recipe.outputs, ...ledgerOutputs]
+			});
+			const intent = _midnight_ntwrk_ledger_v8.Intent.new(ttl);
+			intent.guaranteedUnshieldedOffer = offer;
+			return {
+				newState,
+				transaction: _midnight_ntwrk_ledger_v8.Transaction.fromParts(networkId, void 0, void 0, intent)
+			};
+		});
+	}
+	/**
+	* Reverts a transaction by rolling back all inputs owned by this wallet
+	*
+	* @param wallet - The wallet to revert the transaction for
+	* @param transaction - The transaction to revert (can be FinalizedTransaction, UnboundTransaction, or
+	*   UnprovenTransaction)
+	* @returns The updated wallet with rolled back UTXOs if successful, otherwise an error
+	*/
+	revertTransaction(wallet, transaction) {
+		return require_dist.pipe(this.txOps.extractOwnInputs(transaction, wallet.publicKey.publicKey), require_dist.reduce(require_dist.right(wallet), (walletAcc, utxo) => require_dist.pipe(walletAcc, require_dist.flatMap$4((w) => CoreWallet.rollbackUtxo(w, utxo)))));
+	}
+	/**
+	* Balances a segment of a transaction
+	*
+	* @param wallet - The wallet to balance the segment for
+	* @param imbalances - The imbalances to balance the segment for
+	* @param targetImbalances - The target imbalances to balance the segment for
+	* @param coinSelection - The coin selection to use for the balance recipe
+	* @returns The balance recipe if successful, otherwise an error
+	*/
+	#balanceSegment(wallet, imbalances, targetImbalances, coinSelection) {
+		return require_dist.try_$1({
+			try: () => require_dist.getBalanceRecipe({
+				coins: this.getCoins().getAvailableCoins(wallet).map(({ utxo }) => utxo),
+				initialImbalances: imbalances,
+				feeTokenType: "",
+				transactionCostModel: {
+					inputFeeOverhead: 0n,
+					outputFeeOverhead: 0n
+				},
+				coinSelection,
+				createOutput: (coin) => ({
+					...coin,
+					owner: wallet.publicKey.addressHex
+				}),
+				isCoinEqual: (a, b) => a.intentHash === b.intentHash && a.outputNo === b.outputNo,
+				targetImbalances
+			}),
+			catch: (err) => {
+				if (err instanceof require_dist.InsufficientFundsError) return new InsufficientFundsError({
+					message: "Insufficient funds",
+					tokenType: err.tokenType,
+					amount: imbalances.get(err.tokenType) ?? 0n
+				});
+				else return new OtherWalletError({
+					message: "Balancing unshielded segment failed",
+					cause: err
+				});
+			}
+		});
+	}
+	/**
+	* Prepares an offer for a given balance recipe
+	*
+	* @param wallet - The wallet to prepare the offer for
+	* @param balanceRecipe - The balance recipe to prepare the offer for
+	* @returns The prepared offer and the new wallet state if successful, otherwise an error
+	*/
+	#prepareOffer(wallet, balanceRecipe) {
+		return require_dist.gen$1(function* () {
+			const [spentInputs, updatedWallet] = yield* CoreWallet.spendUtxos(wallet, balanceRecipe.inputs);
+			const { publicKey } = wallet.publicKey;
+			const ledgerInputs = spentInputs.map((input) => ({
+				...input,
+				intentHash: input.intentHash,
+				owner: publicKey
+			}));
+			return {
+				newState: updatedWallet,
+				offer: yield* require_dist.try_$1({
+					try: () => _midnight_ntwrk_ledger_v8.UnshieldedOffer.new(ledgerInputs, [...balanceRecipe.outputs], []),
+					catch: (error) => new TransactingError({
+						message: "Failed to create counter offer",
+						cause: error
+					})
+				})
+			};
+		});
+	}
+	#mergeOffers(offerA, offerB) {
+		return require_dist.pipe(require_dist.fromNullable(offerB), require_dist.match$1({
+			onNone: () => require_dist.right(offerA),
+			onSome: (offerB) => require_dist.try_$1({
+				try: () => _midnight_ntwrk_ledger_v8.UnshieldedOffer.new([...offerB.inputs, ...offerA.inputs], [...offerB.outputs, ...offerA.outputs], [...offerB.signatures, ...offerA.signatures]),
+				catch: (error) => new TransactingError({
+					message: "Failed to merge offers",
+					cause: error
+				})
+			})
+		}));
+	}
+	/**
+	* Balances an unboundish (unproven or unbound) transaction
+	*
+	* @param wallet - The wallet to balance the transaction with
+	* @param transaction - The transaction to balance
+	* @returns The balanced transaction and the new wallet state if successful, otherwise an error
+	* @todo - https://shielded.atlassian.net/browse/PM-21260
+	*/
+	#balanceUnboundishTransaction(wallet, transaction) {
+		return require_dist.gen$1(this, function* () {
+			const segments = this.txOps.getSegments(transaction);
+			if (segments.length === 0) return [void 0, wallet];
+			for (const segment of [...segments, GUARANTEED_SEGMENT]) {
+				const imbalances = this.txOps.getImbalances(transaction, segment);
+				if (imbalances.size === 0) continue;
+				const intentSegment = segment === GUARANTEED_SEGMENT ? segments[0] : segment;
+				const intent = transaction.intents?.get(intentSegment);
+				if (!intent) return yield* require_dist.left(new TransactingError({ message: `Intent with id ${segment} was not found` }));
+				if (this.txOps.isIntentBound(intent)) return yield* require_dist.left(new TransactingError({ message: `Intent with id ${segment} is already bound` }));
+				const recipe = yield* this.#balanceSegment(wallet, imbalances, require_dist.Imbalances.empty(), this.getCoinSelection());
+				const { offer } = yield* this.#prepareOffer(wallet, recipe);
+				const targetOffer = segment !== GUARANTEED_SEGMENT ? intent.fallibleUnshieldedOffer : intent.guaranteedUnshieldedOffer;
+				const mergedOffer = yield* this.#mergeOffers(offer, targetOffer);
+				if (segment !== GUARANTEED_SEGMENT) intent.fallibleUnshieldedOffer = mergedOffer;
+				else intent.guaranteedUnshieldedOffer = mergedOffer;
+				transaction.intents = transaction.intents.set(intentSegment, intent);
+			}
+			return [transaction, wallet];
+		});
+	}
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v1/KeyStore.js
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+const PublicKey$1 = { fromKeyStore: (keystore) => {
+	return {
+		publicKey: keystore.getPublicKey(),
+		addressHex: keystore.getAddress(),
+		address: keystore.getBech32Address().asString()
+	};
+} };
+const createKeystore$1 = (secretKey, networkId) => {
+	const keystore = {
+		getSecretKey: () => require__polyfill_buffer_patch.import_buffer.Buffer.from(secretKey),
+		getBech32Address: () => {
+			const address = keystore.getAddress();
+			const addressBuffer = require__polyfill_buffer_patch.import_buffer.Buffer.from(address, "hex");
+			return require_dist.UnshieldedAddress.codec.encode(networkId, new require_dist.UnshieldedAddress(addressBuffer));
+		},
+		getPublicKey: () => (0, _midnight_ntwrk_ledger_v8.signatureVerifyingKey)(keystore.getSecretKey().toString("hex")),
+		getAddress: () => (0, _midnight_ntwrk_ledger_v8.addressFromKey)(keystore.getPublicKey()),
+		signData: (data) => (0, _midnight_ntwrk_ledger_v8.signData)(keystore.getSecretKey().toString("hex"), data),
+		signDataAsync: (data) => Promise.resolve(keystore.signData(data))
+	};
+	return keystore;
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/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
+*   UTXOs and a public key 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.init(PublicKey$1.fromKeyStore(createKeystore$1(seed, configuration.networkId)), configuration.networkId));
+} });
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v1/Signing.js
+/**
+* The default signing service: collect each segment's signable data (pure), invoke the async signer once per segment
+* (sequentially — segment counts are tiny), then attach the signatures (pure). A signer rejection or throw is wrapped
+* in a {@link SignError}.
+*/
+const makeDefaultSigningService = () => ({ sign(transaction, signSegment) {
+	return require_dist.gen(function* () {
+		const segments = yield* require_dist.toEffect(TransactionOps.collectSignableData(transaction));
+		const signatures = yield* require_dist.forEach(segments, (segment) => require_dist.pipe(require_dist.tryPromise({
+			try: () => signSegment(segment.data),
+			catch: (cause) => new SignError({
+				message: "Signer callback failed",
+				cause
+			})
+		}), require_dist.map$2((signature) => ({
+			segment: segment.segment,
+			signature
+		}))));
+		return yield* require_dist.toEffect(TransactionOps.attachSignatures(transaction, signatures));
+	});
+} });
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v1/CoinsAndBalances.js
+const calculateBalances = (utxos) => utxos.reduce((acc, { utxo }) => ({
+	...acc,
+	[utxo.type]: acc[utxo.type] === void 0 ? utxo.value : acc[utxo.type] + utxo.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) => UnshieldedState.toArrays(state.state).availableUtxos;
+	const getPendingCoins = (state) => UnshieldedState.toArrays(state.state).pendingUtxos;
+	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-unshielded-wallet/dist/v1/Keys.js
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+const makeDefaultKeysCapability = () => {
+	return {
+		getPublicKey: (state) => {
+			return state.publicKey.publicKey;
+		},
+		getAddress: (state) => {
+			return new require_dist.UnshieldedAddress(require__polyfill_buffer_patch.import_buffer.Buffer.from(state.publicKey.addressHex, "hex"));
+		}
+	};
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v1/TransactionHistory.js
+const UtxoSchema = require_dist.Struct({
+	value: require_dist.SafeBigInt,
+	owner: require_dist.String$,
+	tokenType: require_dist.String$,
+	intentHash: require_dist.String$,
+	outputIndex: require_dist.Number$
+});
+const UnshieldedSectionSchema$1 = require_dist.Struct({
+	id: require_dist.Number$,
+	createdUtxos: require_dist.Array$(UtxoSchema),
+	spentUtxos: require_dist.Array$(UtxoSchema)
+});
+require_dist.extendEntrySchema({ unshielded: require_dist.optional(UnshieldedSectionSchema$1) });
+const convertUpdateToFinalizedInput = ({ transaction, createdUtxos, spentUtxos, status }) => ({
+	hash: transaction.hash,
+	protocolVersion: transaction.protocolVersion,
+	status,
+	identifiers: transaction.identifiers ?? [],
+	timestamp: transaction.block.timestamp,
+	finalizedBlock: {
+		hash: transaction.block.hash,
+		height: transaction.block.height,
+		timestamp: transaction.block.timestamp
+	},
+	unshielded: {
+		id: transaction.id,
+		createdUtxos: createdUtxos.map(({ utxo }) => ({
+			value: utxo.value,
+			owner: utxo.owner,
+			tokenType: utxo.type,
+			intentHash: utxo.intentHash,
+			outputIndex: utxo.outputNo
+		})),
+		spentUtxos: spentUtxos.map(({ utxo }) => ({
+			value: utxo.value,
+			owner: utxo.owner,
+			tokenType: utxo.type,
+			intentHash: utxo.intentHash,
+			outputIndex: utxo.outputNo
+		}))
+	}
+});
+const makeDefaultTransactionHistoryService = (config, _getContext) => {
+	const txHistoryStorage = config.txHistoryStorage;
+	return { put: (update) => require_dist.tryPromise({
+		try: () => txHistoryStorage.gotFinalized(convertUpdateToFinalizedInput(update)),
+		catch: (e) => new TransactionHistoryError({
+			message: "Failed to record finalized history entry",
+			cause: e
+		})
+	}) };
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/v1/V1Builder.js
+var V1Builder = class V1Builder {
+	#buildState;
+	constructor(buildState = {}) {
+		this.#buildState = buildState;
+	}
+	withDefaults() {
+		return this.withSyncDefaults().withSerializationDefaults().withTransactingDefaults().withSigningDefaults().withCoinsAndBalancesDefaults().withTransactionHistoryDefaults().withKeysDefaults().withCoinSelectionDefaults();
+	}
+	withSyncDefaults() {
+		return this.withSync(makeDefaultSyncService, makeDefaultSyncCapability);
+	}
+	withSync(syncService, syncCapability) {
+		return new V1Builder({
+			...this.#buildState,
+			syncService,
+			syncCapability
+		});
+	}
+	withSerializationDefaults() {
+		return this.withSerialization(makeDefaultV1SerializationCapability);
+	}
+	withSerialization(serializationCapability) {
+		return new V1Builder({
+			...this.#buildState,
+			serializationCapability
+		});
+	}
+	withTransactingDefaults() {
+		return this.withTransacting(makeDefaultTransactingCapability);
+	}
+	withTransacting(transactingCapability) {
+		return new V1Builder({
+			...this.#buildState,
+			transactingCapability
+		});
+	}
+	withSigningDefaults() {
+		return this.withSigning(makeDefaultSigningService);
+	}
+	withSigning(signingService) {
+		return new V1Builder({
+			...this.#buildState,
+			signingService
+		});
+	}
+	/**
+	* Configures this variant to start from an empty wallet when there is nothing before it.
+	*
+	* @remarks
+	*   The default for a first-registered variant, and what `startEmpty` relies on.
+	* @returns A builder whose previous state is `null`.
+	*/
+	withMigrationDefaults() {
+		return this.withMigration((configuration) => makeEmptyWalletMigration({ networkId: configuration.networkId }));
+	}
+	/**
+	* Configures how this variant produces its first state from whatever variant preceded it.
+	*
+	* @remarks
+	*   The context is a method-level type parameter rather than the builder's own `TContext`, matching `withSync` and
+	*   `withKeys` in this file. Binding it to the builder's `TContext` would make the builder invariant in it and break
+	*   the partially-configured chains the tests build.
+	* @param migration Produces the strategy from the configuration and the variant context.
+	* @returns A builder whose previous state is whatever the strategy consumes.
+	*/
+	withMigration(migration) {
+		const { migration: _replaced, ...capabilities } = this.#buildState;
+		return new V1Builder({
+			...capabilities,
+			migration
+		});
+	}
+	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);
+	}
+	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,
+			start(context) {
+				return require_dist.gen(function* () {
+					return new RunningV1Variant(yield* require_dist.Scope, context, v1Context);
+				});
+			},
+			migrateState(previousState) {
+				return migration.migrate(previousState).pipe(require_dist.mapError$2((error) => new require_dist.WalletRuntimeError({
+					message: "Failed to migrate unshielded wallet state into this variant",
+					cause: error
+				})));
+			},
+			deserializeState: (serialized) => {
+				return v1Context.serializationCapability.deserialize(serialized);
+			}
+		};
+	}
+	/**
+	* The migration strategy to build with.
+	*
+	* @remarks
+	*   An unconfigured builder produces an empty wallet, which is what `startEmpty` asks of a first variant. The nullary
+	*   wrapper is what lets the `null`-consuming default stand in for a `TPreviousState`-consuming strategy without a
+	*   cast: the argument is simply not passed on.
+	*/
+	#resolveMigration(configuration, getContext) {
+		const configured = this.#buildState.migration;
+		return configured === void 0 ? { migrate: () => makeEmptyWalletMigration({ networkId: configuration.networkId }).migrate(null) } : configured(configuration, getContext);
+	}
+	#buildContextFromBuildState(configuration) {
+		if (!isBuildStateFull(this.#buildState)) throw new Error("Not all components are configured in V2 Builder");
+		const { syncCapability, syncService, transactingCapability, signingService, 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),
+			signingService: signingService(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",
+		"signingService",
+		"coinSelection",
+		"serializationCapability",
+		"coinsAndBalancesCapability",
+		"keysCapability",
+		"transactionHistoryService"
+	].every((key) => typeof buildState[key] == "function");
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-unshielded-wallet/dist/UnshieldedWallet.js
+/**
+* The same identity, as ledger-v8 has it.
+*
+* @remarks
+*   Unshielded's one genuine version break, and the whole of it. A ledger-v9 verifying key is a `{tag, value}` record
+*   naming a signature scheme; a ledger-v8 one is the bare hex, with no room to name anything, because that ledger
+*   version had exactly one scheme. So a schnorr identity narrows losslessly — dropping a tag whose value was never in
+*   doubt — and the cross-ledger migration widens it back on the way over, which is where its `schnorr` default comes
+*   from.
+*
+*   An ecdsa identity does not narrow at all, and `None` says so rather than dropping the tag and producing a ledger-v8
+*   wallet claiming an identity it does not have: an ecdsa key derives a _different_ address, and the migration back
+*   would relabel it `schnorr`, so the round trip is not merely lossy but wrong. The address itself is a scheme-less
+*   hash and is carried, not re-derived, which is why the schnorr narrowing needs no ledger call at all.
+* @param publicKey The identity in ledger-v9's shape.
+* @returns The same identity as ledger-v8 has it, or `None` when that version cannot express it.
+*/
+const asV1PublicKey = (publicKey) => publicKey.publicKey.tag === "schnorr" ? require_dist.some({
+	publicKey: publicKey.publicKey.value,
+	addressHex: publicKey.addressHex,
+	address: publicKey.address
+}) : require_dist.none();
+/**
+* Builds an unshielded 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 — see {@link SelfConfiguredUnshieldedVariant}.
+* @example
+*   ```typescript
+*   const Wallet = CustomForkingUnshieldedWallet(
+*     { networkId, forks },
+*     { builder: new V1Builder().withDefaults(), configuration: v1Configuration },
+*     { builder: new V2Builder().withDefaults().withMigration(...), configuration: v2Configuration },
+*   );
+*   const wallet = Wallet.startWithPublicKey(publicKey);
+*   ```;
+*
+* @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 CustomForkingUnshieldedWallet(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();
+	/**
+	* The protocol versions each variant owns, and the version a transaction it builds is stamped with.
+	*
+	* @remarks
+	*   The stamp is the floor of the variant's epoch: every decision it is later read for asks which side of the boundary
+	*   the bytes belong to, and the floor answers that the same way as any other version in the same epoch.
+	*/
+	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;
+	/** Reads a transaction built before the boundary, refusing one built after it. */
+	const v8Tx = (handle) => require_dist.toEffect(require_dist.WalletTransaction.unwrapWithin(handle, v8Epoch));
+	/** Reads a transaction built from the boundary, refusing one built before it. */
+	const v9Tx = (handle) => require_dist.toEffect(require_dist.WalletTransaction.unwrapWithin(handle, 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);
+	/**
+	* Adapts the caller's signer to ledger-v8's signature shape.
+	*
+	* @remarks
+	*   The SDK's signing callback speaks ledger-v9's signature — a scheme and its bytes — because that is the shape an
+	*   application writes against once. What ledger-v8 reads is the bytes alone, and only of the one scheme it has, so a
+	*   signer that answers with any other is refused by name here rather than at the WASM boundary.
+	*/
+	const loweredSigner = (signSegment) => (data) => signSegment(data).then((signature) => require_dist.getOrThrowWith(require_v8Signatures.lowerSignature(signature), (error) => error));
+	/**
+	* 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 messages. 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 — the identity, in the shape that variant holds it — 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.
+	* @param variant The variant the chain's version resolved to.
+	* @param publicKey The identity in the shape this wallet's API speaks.
+	* @param v1PublicKey The same identity as ledger-v8 has it, which is only reached when that variant is the one chosen
+	*   — and only a schnorr identity ever gets here at all.
+	*/
+	const freshStateAt = (variant, publicKey, v1PublicKey, version) => require_dist.getVersionedVariantTag(variant) === V2Tag ? CoreWallet$1.withProtocolVersion(CoreWallet$1.init(publicKey, configuration.networkId), version) : CoreWallet.withProtocolVersion(CoreWallet.init(v1PublicKey, configuration.networkId), version);
+	return class ForkingUnshieldedWalletImplementation extends BaseWallet {
+		static configuration = configuration;
+		static startWithPublicKey(publicKey) {
+			return require_dist.match$1(asV1PublicKey(publicKey), {
+				onSome: (v1PublicKey) => require_dist.pipe(probedStart, require_dist.map$2(require_dist.match$1({
+					onNone: () => ForkingUnshieldedWalletImplementation.startFirst(ForkingUnshieldedWalletImplementation, CoreWallet.init(v1PublicKey, configuration.networkId)),
+					onSome: ({ version, variant }) => ForkingUnshieldedWalletImplementation.startAtVariant(ForkingUnshieldedWalletImplementation, variant, freshStateAt(variant, publicKey, v1PublicKey, version))
+				})), require_dist.runPromise$1),
+				onNone: () => Promise.resolve(ForkingUnshieldedWalletImplementation.startAtVariant(ForkingUnshieldedWalletImplementation, variants[V2Tag], CoreWallet$1.withProtocolVersion(CoreWallet$1.init(publicKey, configuration.networkId), configuration.forks.v9)))
+			});
+		}
+		static tryRestore(serializedState) {
+			return variantForSnapshot(serializedState, (version) => ForkingUnshieldedWalletImplementation.variantFor(version), require_dist.head(ForkingUnshieldedWalletImplementation.allVariants())).pipe(require_dist.flatMap$4((variant) => {
+				const deserialized = variant.variant.deserializeState(serializedState);
+				return require_dist.map$6(deserialized, (state) => ForkingUnshieldedWalletImplementation.startAtVariant(ForkingUnshieldedWalletImplementation, variant, state));
+			}));
+		}
+		static restore(serializedState) {
+			return require_dist.getOrThrow$1(ForkingUnshieldedWalletImplementation.tryRestore(serializedState));
+		}
+		state;
+		/**
+		* 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);
+		/**
+		* Whether the wallet is currently started.
+		*
+		* @remarks
+		*   The unshielded counterpart of the retained start material the shielded and dust wallets hold. This wallet is
+		*   watch-only — sync needs nothing secret, and signing is supplied per call by the caller — so there is no key to
+		*   keep and the restart needs no argument. All the watcher has to know is whether a stopped wallet should be left
+		*   stopped, which is what this records; `stop` clears it so a stopped wallet cannot be resurrected by a late
+		*   activation.
+		*/
+		#started = require_dist.unsafeMake(false);
+		constructor(runtime, scope) {
+			super(runtime, scope);
+			this.state = this.rawState.pipe(rxjs.map((emission) => emission.variantTag === V2Tag ? UnshieldedWalletState.fromVariant(variants[V2Tag].variant, emission) : UnshieldedWalletState.fromVariant(variants[V1Tag].variant, emission)), rxjs.shareReplay({
+				refCount: true,
+				bufferSize: 1
+			}));
+		}
+		/**
+		* Starts background synchronization on whichever variant is current.
+		*
+		* @remarks
+		*   Takes no argument, on either side of the boundary, and that is the shape of the whole wallet: an unshielded
+		*   wallet watches an address, and an address is public. A migration therefore strands nothing — the new variant is
+		*   simply told to start, exactly as the old one was.
+		*/
+		start() {
+			return require_dist.gen(this, function* () {
+				yield* require_dist.set(this.#started, true);
+				if (!(yield* require_dist.getAndSet(this.#watcherRegistered, true))) yield* this.runtime.onVariantActivation({
+					[V1Tag]: (v1) => this.#resumeSyncOn(v1),
+					[V2Tag]: (v2) => this.#resumeSyncOn(v2)
+				});
+				yield* this.runtime.dispatch({
+					[V1Tag]: (v1) => v1.startSyncInBackground(),
+					[V2Tag]: (v2) => v2.startSyncInBackground()
+				});
+			}).pipe(require_dist.runPromise$1);
+		}
+		/** Starts synchronization on a variant that has just become current, unless the wallet has been stopped. */
+		#resumeSyncOn(running) {
+			return require_dist.get$1(this.#started).pipe(require_dist.flatMap$1((started) => started ? running.startSyncInBackground() : require_dist._void));
+		}
+		async stop() {
+			require_dist.set(this.#started, false).pipe(require_dist.runSync);
+			await super.stop();
+		}
+		balanceFinalizedTransaction(tx) {
+			return this.runtime.dispatch({
+				[V1Tag]: (v1) => v8Tx(tx).pipe(require_dist.flatMap$1((unwrapped) => v1.balanceFinalizedTransaction(unwrapped)), require_dist.map$2(sealV8)),
+				[V2Tag]: (v2) => v9Tx(tx).pipe(require_dist.flatMap$1((unwrapped) => v2.balanceFinalizedTransaction(unwrapped)), require_dist.map$2(sealV9))
+			}).pipe(require_dist.runPromise$1);
+		}
+		/**
+		* Balances an unbound transaction, which happens in place rather than by producing a second transaction.
+		*
+		* @returns The transaction with this wallet's inputs added, or nothing when it needed none.
+		*/
+		balanceUnboundTransaction(tx) {
+			return this.runtime.dispatch({
+				[V1Tag]: (v1) => v8Tx(tx).pipe(require_dist.flatMap$1((unwrapped) => v1.balanceUnboundTransaction(unwrapped)), require_dist.map$2((result) => result === void 0 ? void 0 : require_dist.WalletTransaction.adopt("Unbound", result, v8Stamp))),
+				[V2Tag]: (v2) => v9Tx(tx).pipe(require_dist.flatMap$1((unwrapped) => v2.balanceUnboundTransaction(unwrapped)), require_dist.map$2((result) => result === void 0 ? void 0 : require_dist.WalletTransaction.adopt("Unbound", result, v9Stamp)))
+			}).pipe(require_dist.runPromise$1);
+		}
+		balanceUnprovenTransaction(tx) {
+			return this.runtime.dispatch({
+				[V1Tag]: (v1) => v8Tx(tx).pipe(require_dist.flatMap$1((unwrapped) => v1.balanceUnprovenTransaction(unwrapped)), require_dist.map$2(sealV8)),
+				[V2Tag]: (v2) => v9Tx(tx).pipe(require_dist.flatMap$1((unwrapped) => v2.balanceUnprovenTransaction(unwrapped)), require_dist.map$2(sealV9))
+			}).pipe(require_dist.runPromise$1);
+		}
+		transferTransaction(outputs, ttl) {
+			return this.runtime.dispatch({
+				[V1Tag]: (v1) => v1.transferTransaction(outputs, ttl).pipe(require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unproven", tx, v8Stamp))),
+				[V2Tag]: (v2) => v2.transferTransaction(outputs, ttl).pipe(require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unproven", tx, v9Stamp)))
+			}).pipe(require_dist.runPromise$1);
+		}
+		rotateUtxos(guaranteedUtxos, fallibleUtxos, nightVerifyingKey, ttl) {
+			return this.runtime.dispatch({
+				[V1Tag]: (v1) => require_dist.toEffect(require_v8Signatures.lowerSignatureVerifyingKey(nightVerifyingKey)).pipe(require_dist.flatMap$1((key) => v1.rotateUtxos(guaranteedUtxos, fallibleUtxos, key, ttl)), require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unproven", tx, v8Stamp))),
+				[V2Tag]: (v2) => v2.rotateUtxos(guaranteedUtxos, fallibleUtxos, nightVerifyingKey, ttl).pipe(require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unproven", tx, v9Stamp)))
+			}).pipe(require_dist.runPromise$1);
+		}
+		initSwap(desiredInputs, desiredOutputs, ttl) {
+			return this.runtime.dispatch({
+				[V1Tag]: (v1) => v1.initSwap(desiredInputs, desiredOutputs, ttl).pipe(require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unproven", tx, v8Stamp))),
+				[V2Tag]: (v2) => v2.initSwap(desiredInputs, desiredOutputs, ttl).pipe(require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unproven", tx, v9Stamp)))
+			}).pipe(require_dist.runPromise$1);
+		}
+		signUnprovenTransaction(transaction, signSegment) {
+			return this.runtime.dispatch({
+				[V1Tag]: (v1) => v8Tx(transaction).pipe(require_dist.flatMap$1((unwrapped) => v1.signUnprovenTransaction(unwrapped, loweredSigner(signSegment))), require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unproven", tx, v8Stamp))),
+				[V2Tag]: (v2) => v9Tx(transaction).pipe(require_dist.flatMap$1((unwrapped) => v2.signUnprovenTransaction(unwrapped, signSegment)), require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unproven", tx, v9Stamp)))
+			}).pipe(require_dist.runPromise$1);
+		}
+		signUnboundTransaction(transaction, signSegment) {
+			return this.runtime.dispatch({
+				[V1Tag]: (v1) => v8Tx(transaction).pipe(require_dist.flatMap$1((unwrapped) => v1.signUnboundTransaction(unwrapped, loweredSigner(signSegment))), require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unbound", tx, v8Stamp))),
+				[V2Tag]: (v2) => v9Tx(transaction).pipe(require_dist.flatMap$1((unwrapped) => v2.signUnboundTransaction(unwrapped, signSegment)), require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unbound", tx, v9Stamp)))
+			}).pipe(require_dist.runPromise$1);
+		}
+		/**
+		* Un-books the UTxOs a transaction of this wallet's had reserved, returning them to the available set.
+		*
+		* @remarks
+		*   A transaction built on the other side of the boundary has nothing booked in the running variant to release, so
+		*   this resolves having done nothing. That is a fact about the crossing rather than an assumption made here:
+		*   {@link Migration.makeCrossLedgerMigration} restores every UTxO the V1 variant had booked as _available_,
+		*   precisely because a ledger-v8 transaction can never be included past the boundary — so by the time the
+		*   ledger-v9 variant is running, no ledger-v8 handle is holding anything. Doing nothing is therefore the whole of
+		*   the correct behaviour, not a release quietly skipped.
+		*
+		*   It is also 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.
+		* @param transaction The transaction to un-book.
+		*/
+		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 [[UnshieldedWalletState.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 unshielded wallet this package ships: the default variant either side of `configuration.forks.v9`.
+*
+* @remarks
+*   Both variants read the chain through the indexer's unshielded-transaction subscription and record transaction history
+*   in the same storage, and both are built from the same application configuration, because what they ask for is
+*   identical — unshielded sync carries no ledger object in either direction, only public UTXO records as JSON.
+*
+*   Transacting, synchronization, balances, coins, addresses, serialization, restore and reverting all work on both
+*   sides: each variant builds with its own ledger version, and what it produces says which version built it.
+*
+*   **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 UnshieldedWallet(configuration) {
+	return CustomForkingUnshieldedWallet({
+		...configuration,
+		chainVersionProbe: configuration.chainVersionProbe ?? require_dist.makeIndexerChainVersionProbe(configuration)
+	}, {
+		builder: new V1Builder().withDefaults(),
+		configuration
+	}, {
+		builder: new V2Builder().withDefaults().withMigration(() => makeCrossLedgerMigration()),
+		configuration
+	});
+}
+//#endregion
+exports.CustomForkingUnshieldedWallet = CustomForkingUnshieldedWallet;
+exports.CustomUnshieldedWallet = CustomUnshieldedWallet;
+exports.PublicKey = PublicKey;
+Object.defineProperty(exports, "UnshieldedRestore", {
+	enumerable: true,
+	get: function() {
+		return Restore_exports;
+	}
+});
+exports.UnshieldedSectionSchema = UnshieldedSectionSchema;
+exports.UnshieldedSectionSchema$1 = UnshieldedSectionSchema;
+exports.UnshieldedWallet = UnshieldedWallet;
+exports.UnshieldedWalletState = UnshieldedWalletState;
+exports.asV1PublicKey = asV1PublicKey;
+exports.createKeystore = createKeystore;
+exports.mergeUnshieldedSections = mergeUnshieldedSections;
+exports.mergeUnshieldedSections$1 = mergeUnshieldedSections;