@laceio/sdk 0.1.1 → 0.1.2-canary.1

package/dist/dist-DqJfSlTd.cjs

@@ -0,0 +1,4413 @@
+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/@midnightntwrk/wallet-sdk-dust-wallet/dist/DustWalletAPI.js
+var DustWalletState = class DustWalletState {
+	/**
+	* 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 DustWalletState(state.version, state.state, {
+		totalCoins: () => variant.coinsAndBalances.getTotalCoins(state.state),
+		availableCoins: () => variant.coinsAndBalances.getAvailableCoins(state.state),
+		pendingCoins: () => variant.coinsAndBalances.getPendingCoins(state.state),
+		publicKey: () => variant.keys.getPublicKey(state.state),
+		address: () => variant.keys.getAddress(state.state),
+		balance: (time) => variant.coinsAndBalances.getWalletBalance(state.state, time),
+		estimateDustGeneration: (nightUtxos, currentTime) => variant.coinsAndBalances.estimateDustGeneration(state.state, nightUtxos, currentTime),
+		splitNightUtxos: (nightUtxos) => variant.coinsAndBalances.splitNightUtxos(nightUtxos),
+		serialize: () => variant.serialization.serialize(state.state)
+	});
+	protocolVersion;
+	state;
+	#projections;
+	get totalCoins() {
+		return this.#projections.totalCoins();
+	}
+	get availableCoins() {
+		return this.#projections.availableCoins();
+	}
+	get pendingCoins() {
+		return this.#projections.pendingCoins();
+	}
+	get publicKey() {
+		return this.#projections.publicKey();
+	}
+	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;
+	}
+	balance(time) {
+		return this.#projections.balance(time);
+	}
+	estimateDustGeneration(nightUtxos, currentTime) {
+		return this.#projections.estimateDustGeneration(nightUtxos, currentTime);
+	}
+	/**
+	* Splits Night UTxOs into the ones a registration puts in its guaranteed and fallible sections.
+	*
+	* @remarks
+	*   Projected here rather than reached for through the capability set, so a reader of this state never has to know
+	*   which variant produced it. The split itself is plain arithmetic over plain data — no ledger object crosses it —
+	*   which is why both variants answer it identically.
+	* @param nightUtxos The UTxOs to split, with their dust generation readings.
+	* @returns The guaranteed and fallible halves.
+	*/
+	splitNightUtxos(nightUtxos) {
+		return this.#projections.splitNightUtxos(nightUtxos);
+	}
+	serialize() {
+		return this.#projections.serialize();
+	}
+};
+/**
+* The largest fee payment a registration over `nightUtxos` could claim for itself, right now.
+*
+* @remarks
+*   What {@link DustWalletAPI.waitForGeneratedDust} waits to reach the fee, and the reading behind it. Two things shape
+*   it. Only Night that does not yet generate Dust earns the retroactive Dust a registration may spend on its own fee —
+*   claiming it for Night that already generates is an overspend the node rejects — and whether a UTxO is one of those
+*   is its `registeredForDustGeneration` flag, which the indexer reports as of the chain's current Dust epoch. And the
+*   allowance is capped at the _single_ highest-generation UTxO, because `splitNightUtxos` puts exactly one in the
+*   registration's guaranteed slot; summing across UTxOs would resolve the wait optimistically and the registration
+*   would still fail the fee check on-chain.
+* @param state The dust wallet state to read.
+* @param nightUtxos The Night UTxOs the registration would carry.
+* @param currentTime The time to project generation to.
+* @returns The claimable fee payment, in Specks. `0n` when every UTxO is already registered for Dust generation.
+*/
+const claimableFeePayment = (state, nightUtxos, currentTime) => state.estimateDustGeneration(nightUtxos, currentTime).filter((estimate) => !estimate.utxo.registeredForDustGeneration).reduce((max, estimate) => estimate.dust.generatedNow > max ? estimate.dust.generatedNow : max, 0n);
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v2/WalletError.js
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+var OtherWalletError$1 = class extends require_dist.TaggedError("Wallet.Other") {};
+var SyncWalletError$1 = class extends require_dist.TaggedError("Wallet.Sync") {};
+var TransactingError$1 = class extends require_dist.TaggedError("Wallet.Transacting") {};
+var InsufficientFundsError$1 = class extends require_dist.TaggedError("Wallet.InsufficientFunds") {};
+var TransactionHistoryError$1 = class extends require_dist.TaggedError("Wallet.TransactionHistory") {};
+/**
+* A batch of dust ledger events was not in ascending id order: an event arrived at or below the one before it, or at or
+* below the applied cursor.
+*
+* @remarks
+*   Order is all the wallet can check: dust events share one id sequence with zswap and contract events in the indexer,
+*   so gaps in the stream are normal and a skipped event is only ever caught by the ledger's own insertion check. The
+*   whole batch is refused, nothing is applied and the cursor stays, so the running variant retries from the same
+*   place.
+* @example
+*   ```ts
+*   if (error._tag === 'Wallet.OutOfOrderSyncUpdate') console.warn(`expected above ${error.expected}, got ${error.received}`);
+*   ```
+*/
+var OutOfOrderSyncUpdateError$1 = class extends require_dist.TaggedError("Wallet.OutOfOrderSyncUpdate") {};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v2/Serialization.js
+const StateSchema$1 = require_dist.declare((input) => input instanceof _midnightntwrk_ledger_v9.DustLocalState).annotations({ identifier: "ledger.DustLocalState" });
+const Uint8ArraySchema$1 = require_dist.declare((input) => input instanceof Uint8Array).annotations({ identifier: "Uint8Array" });
+const StateFromUInt8Array$1 = require_dist.asSchema(require_dist.transformOrFail(Uint8ArraySchema$1, StateSchema$1, {
+	encode: (state) => {
+		return require_dist.try_({
+			try: () => {
+				return state.serialize();
+			},
+			catch: (err) => {
+				return new require_dist.Unexpected(err, "Could not serialize local state");
+			}
+		});
+	},
+	decode: (bytes) => require_dist.try_({
+		try: () => _midnightntwrk_ledger_v9.DustLocalState.deserialize(bytes),
+		catch: (err) => {
+			return new require_dist.Unexpected(err, "Could not deserialize local state");
+		}
+	})
+}));
+const HexedState$1 = require_dist.pipe(require_dist.Uint8ArrayFromHex, require_dist.compose(StateFromUInt8Array$1));
+const SnapshotSchema$1 = require_dist.Struct({
+	publicKey: require_dist.Struct({ publicKey: require_dist.BigInt$ }),
+	state: HexedState$1,
+	protocolVersion: require_dist.BigInt$,
+	networkId: require_dist.String$,
+	offset: require_dist.optional(require_dist.BigInt$)
+});
+const makeDefaultV2SerializationCapability = () => {
+	return {
+		serialize: (wallet) => {
+			const buildSnapshot = (w) => ({
+				publicKey: w.publicKey,
+				state: w.state,
+				protocolVersion: w.protocolVersion,
+				networkId: w.networkId,
+				offset: w.progress?.appliedIndex
+			});
+			return require_dist.pipe(wallet, buildSnapshot, require_dist.encodeSync(SnapshotSchema$1), JSON.stringify);
+		},
+		deserialize: (aux, serialized) => {
+			return require_dist.pipe(serialized, require_dist.decodeUnknownEither(require_dist.parseJson(SnapshotSchema$1)), require_dist.mapLeft((err) => new OtherWalletError$1({
+				message: "Error while deserializing snapshot",
+				cause: err
+			})), require_dist.flatMap$4((snapshot) => require_dist.try_$1({
+				try: () => CoreWallet$1.restore(snapshot.state, snapshot.publicKey, [], {
+					appliedIndex: snapshot.offset ?? 0n,
+					highestRelevantWalletIndex: 0n,
+					highestIndex: 0n,
+					highestRelevantIndex: 0n
+				}, snapshot.protocolVersion, snapshot.networkId),
+				catch: (err) => new OtherWalletError$1({
+					message: "Error while restoring core wallet",
+					cause: err
+				})
+			})));
+		}
+	};
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v2/SyncSchema.js
+const DustStateMerkleTreeCollapsedUpdateSchema = require_dist.declare((input) => input instanceof _midnightntwrk_ledger_v9.DustStateMerkleTreeCollapsedUpdate).annotations({ identifier: "DustStateMerkleTreeCollapsedUpdate" });
+const DustStateMerkleTreeCollapsedUpdateFromUInt8Array = require_dist.asSchema(require_dist.transformOrFail(Uint8ArraySchema$1, DustStateMerkleTreeCollapsedUpdateSchema, {
+	encode: (value) => {
+		return require_dist.try_({
+			try: () => {
+				return value.serialize();
+			},
+			catch: (err) => {
+				return new require_dist.Unexpected(err, "Could not serialize DustStateMerkleTreeCollapsedUpdate");
+			}
+		});
+	},
+	decode: (bytes) => require_dist.try_({
+		try: () => _midnightntwrk_ledger_v9.DustStateMerkleTreeCollapsedUpdate.deserialize(bytes),
+		catch: (err) => {
+			return new require_dist.Unexpected(err, "Could not deserialize DustStateMerkleTreeCollapsedUpdate");
+		}
+	})
+}));
+const HexedDustStateMerkleTreeCollapsedUpdate = require_dist.pipe(require_dist.Uint8ArrayFromHex, require_dist.compose(DustStateMerkleTreeCollapsedUpdateFromUInt8Array));
+/**
+* A collapsed Merkle tree update as the indexer served it, still encoded.
+*
+* @remarks
+*   The update travels as bytes rather than as a `DustStateMerkleTreeCollapsedUpdate`, because whether this ledger
+*   version can read it is not the subscription's question to answer — and a subscription that answered it would answer
+*   for the whole batch at once. One item this wallet was never going to apply would fail the fetch it arrived in, and
+*   the stream would retry the same fetch forever. See {@link readCollapsedUpdate}.
+*/
+const CollapsedMerkleTreeSchema = require_dist.Struct({
+	startIndex: require_dist.Number$,
+	endIndex: require_dist.Number$,
+	update: require_dist.String$,
+	protocolVersion: require_dist.Number$
+});
+/**
+* Reads a collapsed Merkle tree update this wallet is about to apply.
+*
+* @param tree The update as the indexer served it.
+* @returns The decoded update.
+* @throws ParseError if the bytes are not an update this ledger version can deserialize.
+*/
+const readCollapsedUpdate = (tree) => require_dist.decodeSync(HexedDustStateMerkleTreeCollapsedUpdate)(tree.update);
+const WireDustGenerationsUpdateSchema = require_dist.Struct({
+	__typename: require_dist.Literal("DustGenerationsItem"),
+	commitmentMtIndex: require_dist.Number$,
+	generationMtIndex: require_dist.Number$,
+	owner: require_dist.String$,
+	value: require_dist.String$,
+	initialValue: require_dist.String$,
+	backingNight: require_dist.String$,
+	ctime: require_dist.Number$,
+	transactionId: require_dist.Number$,
+	transactionHash: require_dist.String$,
+	collapsedMerkleTree: require_dist.Union(CollapsedMerkleTreeSchema, require_dist.Null)
+});
+const DustGenerationsUpdateSchema = require_dist.transform(WireDustGenerationsUpdateSchema, require_dist.typeSchema(require_dist.Struct({
+	__typename: require_dist.Literal("DustGenerationsItem"),
+	commitmentMtIndex: require_dist.Number$,
+	generationMtIndex: require_dist.Number$,
+	owner: require_dist.String$,
+	value: require_dist.String$,
+	initialValue: require_dist.String$,
+	backingNight: require_dist.String$,
+	ctime: require_dist.DateFromSelf,
+	transactionId: require_dist.Number$,
+	transactionHash: require_dist.String$,
+	collapsedMerkleTree: require_dist.Union(CollapsedMerkleTreeSchema, require_dist.Null)
+})), {
+	strict: true,
+	decode: (wire) => ({
+		...wire,
+		ctime: /* @__PURE__ */ new Date(wire.ctime * 1e3)
+	}),
+	encode: (domain) => ({
+		...domain,
+		ctime: Math.floor(domain.ctime.getTime() / 1e3)
+	})
+});
+const ProgressSchema = require_dist.Struct({
+	__typename: require_dist.Literal("DustGenerationsProgress"),
+	highestIndex: require_dist.Number$,
+	collapsedMerkleTree: require_dist.Union(CollapsedMerkleTreeSchema, require_dist.Null)
+});
+const DustGenerationTreeInsertionPathSchema = require_dist.declare((input) => input instanceof _midnightntwrk_ledger_v9.DustGenerationTreeInsertionPath).annotations({ identifier: "DustGenerationTreeInsertionPath" });
+const DustGenerationTreeInsertionPathFromUInt8Array = require_dist.asSchema(require_dist.transformOrFail(Uint8ArraySchema$1, DustGenerationTreeInsertionPathSchema, {
+	encode: (value) => {
+		return require_dist.try_({
+			try: () => {
+				return value.serialize();
+			},
+			catch: (err) => {
+				return new require_dist.Unexpected(err, "Could not serialize DustGenerationTreeInsertionPath");
+			}
+		});
+	},
+	decode: (bytes) => require_dist.try_({
+		try: () => _midnightntwrk_ledger_v9.DustGenerationTreeInsertionPath.deserialize(bytes),
+		catch: (err) => {
+			return new require_dist.Unexpected(err, "Could not deserialize DustGenerationTreeInsertionPath");
+		}
+	})
+}));
+const HexedDustGenerationTreeInsertionPath = require_dist.pipe(require_dist.Uint8ArrayFromHex, require_dist.compose(DustGenerationTreeInsertionPathFromUInt8Array));
+/**
+* Reads a generation-tree insertion path this wallet is about to apply.
+*
+* @param treeInsertionPath The path as the indexer served it.
+* @returns The decoded path.
+* @throws ParseError if the bytes are not a path this ledger version can deserialize.
+*/
+const readGenerationTreeInsertionPath = (treeInsertionPath) => require_dist.decodeSync(HexedDustGenerationTreeInsertionPath)(treeInsertionPath);
+/**
+* A dtime update as the indexer served it, its insertion path still encoded.
+*
+* @remarks
+*   Structural only, for the same reason as {@link CollapsedMerkleTreeSchema}: a subscription that deserialized on arrival
+*   would decide for the whole batch whether this ledger version can read an item, and fail all of it on the first one
+*   it cannot.
+*/
+const DustGenerationDtimeUpdateItemSchema = require_dist.transform(require_dist.Struct({
+	__typename: require_dist.Literal("DustGenerationDtimeUpdateItem"),
+	generationMtIndex: require_dist.Number$,
+	nightUtxoHash: require_dist.String$,
+	newDtime: require_dist.Number$,
+	treeInsertionPath: require_dist.String$
+}), require_dist.typeSchema(require_dist.Struct({
+	__typename: require_dist.Literal("DustGenerationDtimeUpdateItem"),
+	generationMtIndex: require_dist.Number$,
+	nightUtxoHash: require_dist.String$,
+	newDtime: require_dist.DateFromSelf,
+	treeInsertionPath: require_dist.String$
+})), {
+	strict: true,
+	decode: (wire) => ({
+		...wire,
+		newDtime: /* @__PURE__ */ new Date(wire.newDtime * 1e3)
+	}),
+	encode: (domain) => ({
+		...domain,
+		newDtime: Math.floor(domain.newDtime.getTime() / 1e3)
+	})
+});
+const DustGenerationsSubscriptionSchema = require_dist.Union(DustGenerationsUpdateSchema, ProgressSchema, DustGenerationDtimeUpdateItemSchema);
+const LedgerParametersSchema = require_dist.declare((input) => input instanceof _midnightntwrk_ledger_v9.LedgerParameters).annotations({ identifier: "ledger.Parameters" });
+const LedgerParametersFromUint8Array = require_dist.asSchema(require_dist.transformOrFail(Uint8ArraySchema$1, LedgerParametersSchema, {
+	encode: (e) => {
+		return require_dist.try_({
+			try: () => e.serialize(),
+			catch: (err) => {
+				return new require_dist.Unexpected(err, "Could not serialize Ledger Parameters");
+			}
+		});
+	},
+	decode: (bytes) => require_dist.try_({
+		try: () => _midnightntwrk_ledger_v9.LedgerParameters.deserialize(bytes),
+		catch: (err) => {
+			return new require_dist.Unexpected(err, "Could not deserialize Ledger Parameters");
+		}
+	})
+}));
+const HexedLedgerParameters = require_dist.pipe(require_dist.Uint8ArrayFromHex, require_dist.compose(LedgerParametersFromUint8Array));
+const LedgerEventSchema$1 = require_dist.declare((input) => input instanceof _midnightntwrk_ledger_v9.Event).annotations({ identifier: "ledger.Event" });
+const LedgerEventFromUInt8Array$1 = require_dist.asSchema(require_dist.transformOrFail(Uint8ArraySchema$1, LedgerEventSchema$1, {
+	encode: (e) => {
+		return require_dist.try_({
+			try: () => e.serialize(),
+			catch: (err) => {
+				return new require_dist.Unexpected(err, "Could not serialize Ledger Event");
+			}
+		});
+	},
+	decode: (bytes) => require_dist.try_({
+		try: () => _midnightntwrk_ledger_v9.Event.deserialize(bytes),
+		catch: (err) => {
+			return new require_dist.Unexpected(err, "Could not deserialize Ledger Event");
+		}
+	})
+}));
+const HexedEvent$1 = require_dist.pipe(require_dist.Uint8ArrayFromHex, require_dist.compose(LedgerEventFromUInt8Array$1));
+/**
+* One event of a matched transaction, still encoded.
+*
+* @remarks
+*   The nullifier lookup this arrives through searches from block zero and matches on a nullifier _prefix_ — deliberately
+*   over-fetching, for anonymity — so most of what it returns belongs to other parties, and on a chain that has forked
+*   some of it belongs to the previous ledger version. Deserializing on arrival would let either of those fail the
+*   whole lookup, and with it every dust spend this wallet ever made. See {@link readEvent}.
+*/
+const TransactionEvent = require_dist.Struct({
+	id: require_dist.Number$,
+	raw: require_dist.String$,
+	maxId: require_dist.Number$,
+	protocolVersion: require_dist.Number$
+});
+/**
+* The block a matched transaction sits in, its ledger parameters still encoded.
+*
+* @remarks
+*   `protocolVersion` says which ledger version wrote those parameters, and is therefore what chooses the codec that
+*   reads them — see {@link readNullifierBlockParameters}. Reading them on arrival would mean picking a ledger version
+*   before consulting the one field that says which to pick, which is how a ledger-v8 block takes down the whole
+*   lookup.
+*/
+const NullifierBlockInfoSchema = require_dist.Struct({
+	protocolVersion: require_dist.Number$,
+	ledgerParameters: require_dist.String$
+});
+/**
+* Reads the ledger parameters of a block holding a spend this wallet owns.
+*
+* @param block The block as the indexer served it.
+* @param codecs The ledger parameters codecs this variant is willing to read with.
+* @returns The decoded parameters, or the codec registry's refusal when no codec claims the block's version.
+*/
+const readNullifierBlockParameters = (block, codecs) => require_dist.decode(codecs, require_dist.ProtocolVersion(BigInt(block.protocolVersion)), block.ledgerParameters);
+const NullifierNonRegularTransactionSchema = require_dist.Struct({
+	__typename: require_dist.Literal("SystemTransaction", "BridgeClaimTransaction"),
+	block: NullifierBlockInfoSchema
+});
+const NullifierRegularTransactionSchema = require_dist.Struct({
+	__typename: require_dist.Literal("RegularTransaction"),
+	block: NullifierBlockInfoSchema,
+	id: require_dist.Number$,
+	hash: require_dist.String$,
+	dustLedgerEvents: require_dist.Array$(TransactionEvent),
+	zswapLedgerEvents: require_dist.Array$(TransactionEvent)
+});
+const NullifierTransactionSchema = require_dist.Union(NullifierNonRegularTransactionSchema, NullifierRegularTransactionSchema);
+const DustNullifierTransactionSubscriptionSchema = require_dist.Struct({
+	nullifierLeBytes: require_dist.String$,
+	commitmentLeBytes: require_dist.String$,
+	transactionId: require_dist.Number$,
+	transactionHash: require_dist.String$,
+	blockHeight: require_dist.Number$,
+	blockHash: require_dist.String$,
+	transaction: NullifierTransactionSchema
+});
+const DustGenerationsSyncUpdate = { create: (rawUpdates, secretKey, publicKey, lastSyncedGenerationIndex) => {
+	const { publicKey: dustPublicKey } = publicKey;
+	const dustAddressHex = new require_dist.DustAddress(dustPublicKey).hexString;
+	return {
+		rawUpdates,
+		newGenerations: rawUpdates.filter((u) => u.__typename === "DustGenerationsItem").filter((u) => u.owner === dustAddressHex && u.generationMtIndex > lastSyncedGenerationIndex).toSorted((u1, u2) => u1.generationMtIndex - u2.generationMtIndex).map((u) => {
+			const qdo = {
+				initialValue: BigInt(u.initialValue),
+				owner: dustPublicKey,
+				nonce: (0, _midnightntwrk_ledger_v9.dustFirstNonce)(u.backingNight, dustPublicKey),
+				seq: 0,
+				ctime: u.ctime,
+				backingNight: u.backingNight,
+				mtIndex: BigInt(u.commitmentMtIndex)
+			};
+			return {
+				dustNullifier: (0, _midnightntwrk_ledger_v9.dustNullifier)(qdo, secretKey),
+				genInfo: {
+					value: BigInt(u.value),
+					owner: dustPublicKey,
+					nonce: u.backingNight,
+					dtime: void 0
+				},
+				generationMtIndex: u.generationMtIndex,
+				qdo,
+				transactionId: u.transactionId,
+				transactionHash: u.transactionHash
+			};
+		}),
+		generationDtimeUpdates: rawUpdates.filter((u) => u.__typename === "DustGenerationDtimeUpdateItem").toSorted((u1, u2) => u1.generationMtIndex - u2.generationMtIndex).map(({ __typename, ...rest }) => rest)
+	};
+} };
+const SyncEventsUpdateSchema$1 = require_dist.Struct({
+	id: require_dist.Number$,
+	raw: require_dist.String$,
+	maxId: require_dist.Number$,
+	protocolVersion: require_dist.optional(require_dist.Number$)
+});
+/**
+* Reads an event this variant is going to apply.
+*
+* @remarks
+*   The counterpart of the sync schemas carrying their events encoded: a capability calls this on the batch prefix it
+*   owns, and never on what it defers. Failure here is a genuine one — an event this variant claimed and cannot read —
+*   and is raised rather than returned, because `SyncCapability.applyUpdate` is total in its own domain and the variant
+*   already turns a throw from it into a typed synchronization error.
+* @param event The event-carrying item to read.
+* @returns The event it carries.
+* @throws ParseError if the bytes are not an event this ledger version can deserialize.
+*/
+const readEvent$1 = (event) => require_dist.decodeSync(HexedEvent$1)(event.raw);
+/**
+* Reads an event this variant only might be interested in.
+*
+* @remarks
+*   For sources that over-deliver by design rather than by accident — the nullifier lookup matches on a nullifier
+*   _prefix_ and searches from block zero, so it returns other parties' transactions and, on a chain that has forked,
+*   the previous ledger version's. An event this version cannot read is by construction not one of this wallet's own
+*   spends, so it is skipped rather than raised. Use {@link readEvent} wherever the variant has already claimed the
+*   event.
+* @param event The event-carrying item to read.
+* @returns The event, or `Option.none()` when these bytes are not an event this ledger version reads.
+*/
+const tryReadEvent = (event) => require_dist.decodeOption(HexedEvent$1)(event.raw);
+const VersionSignalSyncUpdate$1 = { create: (version, highestEventId) => {
+	return {
+		_tag: "VersionSignal",
+		version,
+		highestEventId
+	};
+} };
+const WalletSyncUpdate$1 = { create: (updates, secretKey, timestamp) => {
+	return {
+		_tag: "Events",
+		updates,
+		secretKey,
+		timestamp
+	};
+} };
+const DustUtxoMap = { create: (generations) => require_dist.fromIterable(generations.map((u) => [u.dustNullifier, {
+	qdo: u.qdo,
+	transactionId: u.transactionId,
+	transactionHash: u.transactionHash,
+	genInfo: u.genInfo
+}])) };
+const DustProjectionsUpdate = require_dist.taggedEnum();
+const isProgressUpdate = DustProjectionsUpdate.$is("ProgressUpdate");
+const { $match: match, StateUpdate, ProgressUpdate } = DustProjectionsUpdate;
+/**
+* The block as the indexer sends it: `ledgerParameters` is still hex, and `protocolVersion` says which ledger version
+* produced that hex.
+*
+* @remarks
+*   The parameters deliberately stay undecoded here, the same way the shielded event payload keeps its `raw` string.
+*   Decoding on arrival means picking a ledger version before reading the one field that says which version to pick,
+*   which is how a block from the other side of a fork takes down the whole fetch.
+*/
+const WireBlockDataSchema = require_dist.Struct({
+	height: require_dist.Number$,
+	hash: require_dist.String$,
+	protocolVersion: require_dist.Number$,
+	ledgerParameters: require_dist.String$,
+	timestamp: require_dist.Number$,
+	zswapEndIndex: require_dist.Number$,
+	dustCommitmentEndIndex: require_dist.Number$,
+	dustGenerationEndIndex: require_dist.Number$,
+	dustCommitmentMerkleTreeRoot: require_dist.NullOr(require_dist.String$),
+	dustGenerationMerkleTreeRoot: require_dist.NullOr(require_dist.String$)
+});
+const BlockDataStructSchema = require_dist.typeSchema(require_dist.Struct({
+	height: require_dist.Number$,
+	hash: require_dist.String$,
+	protocolVersion: require_dist.Number$,
+	ledgerParameters: HexedLedgerParameters,
+	timestamp: require_dist.DateFromSelf,
+	zswapEndIndex: require_dist.Number$,
+	dustCommitmentEndIndex: require_dist.Number$,
+	dustGenerationEndIndex: require_dist.Number$,
+	dustCommitmentMerkleTreeRoot: require_dist.String$,
+	dustGenerationMerkleTreeRoot: require_dist.String$
+}));
+/**
+* The ledger parameters codecs this variant reads blocks with, unless it is told otherwise.
+*
+* @remarks
+*   Open-ended from the minimum supported version, so a wallet whose variant has not been given a narrower range keeps
+*   reading every block exactly as it did before this became routable. A two-variant dust wallet replaces this with a
+*   registry bounded by the range its variant is active over, and then a block from the other side of the boundary is
+*   refused by name instead of being deserialized.
+*/
+const defaultLedgerParametersCodecs$1 = require_dist.getOrThrow$1(require_dist.makeCodecs([{
+	sinceVersion: require_dist.MinSupportedVersion,
+	codec: require_dist.fromDeserializer((bytes) => _midnightntwrk_ledger_v9.LedgerParameters.deserialize(bytes))
+}]));
+/**
+* Builds the block-data schema that reads a block's ledger parameters with whichever codec claims the protocol version
+* the block was reported under.
+*
+* @param codecs The ledger parameters codecs this variant is willing to read with.
+* @returns A schema decoding the indexer's block into {@link BlockData}.
+*/
+const makeBlockDataSchema = (codecs) => require_dist.asSchema(require_dist.transformOrFail(WireBlockDataSchema, BlockDataStructSchema, {
+	strict: true,
+	decode: (wire, _options, ast) => require_dist.pipe(require_dist.decode(codecs, require_dist.ProtocolVersion(BigInt(wire.protocolVersion)), wire.ledgerParameters), require_dist.mapBoth({
+		onLeft: (error) => new require_dist.Type(ast, wire, error.message),
+		onRight: (ledgerParameters) => ({
+			height: wire.height,
+			hash: wire.hash,
+			protocolVersion: wire.protocolVersion,
+			ledgerParameters,
+			timestamp: new Date(wire.timestamp),
+			zswapEndIndex: wire.zswapEndIndex,
+			dustCommitmentEndIndex: wire.dustCommitmentEndIndex,
+			dustGenerationEndIndex: wire.dustGenerationEndIndex,
+			dustCommitmentMerkleTreeRoot: wire.dustCommitmentMerkleTreeRoot ?? "",
+			dustGenerationMerkleTreeRoot: wire.dustGenerationMerkleTreeRoot ?? ""
+		})
+	})),
+	encode: (domain, _options, ast) => require_dist.try_({
+		try: () => ({
+			height: domain.height,
+			hash: domain.hash,
+			protocolVersion: domain.protocolVersion,
+			ledgerParameters: require__polyfill_buffer_patch.import_buffer.Buffer.from(domain.ledgerParameters.serialize()).toString("hex"),
+			timestamp: domain.timestamp.getTime(),
+			zswapEndIndex: domain.zswapEndIndex,
+			dustCommitmentEndIndex: domain.dustCommitmentEndIndex,
+			dustGenerationEndIndex: domain.dustGenerationEndIndex,
+			dustCommitmentMerkleTreeRoot: domain.dustCommitmentMerkleTreeRoot === "" ? null : domain.dustCommitmentMerkleTreeRoot,
+			dustGenerationMerkleTreeRoot: domain.dustGenerationMerkleTreeRoot === "" ? null : domain.dustGenerationMerkleTreeRoot
+		}),
+		catch: (err) => new require_dist.Type(ast, domain, `Could not serialize Ledger Parameters: ${String(err)}`)
+	})
+}));
+makeBlockDataSchema(defaultLedgerParametersCodecs$1);
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v2/CoreWallet.js
+const PublicKey$1 = { fromSecretKey: (secretKey) => {
+	return { publicKey: secretKey.publicKey };
+} };
+const CoreWallet$1 = {
+	init(localState, secretKey, networkId) {
+		return CoreWallet$1.empty(localState, PublicKey$1.fromSecretKey(secretKey), networkId);
+	},
+	initEmpty(dustParameters, secretKey, networkId) {
+		return CoreWallet$1.empty(new _midnightntwrk_ledger_v9.DustLocalState(dustParameters), PublicKey$1.fromSecretKey(secretKey), networkId);
+	},
+	empty(localState, publicKey, networkId) {
+		return {
+			state: localState,
+			publicKey,
+			networkId,
+			pendingDust: [],
+			progress: require_dist.createSyncProgress(),
+			protocolVersion: require_dist.MinSupportedVersion
+		};
+	},
+	restore(localState, publicKey, pendingTokens, syncProgress, protocolVersion, networkId) {
+		return {
+			state: localState,
+			publicKey,
+			networkId,
+			pendingDust: pendingTokens,
+			progress: require_dist.createSyncProgress(syncProgress),
+			protocolVersion: require_dist.ProtocolVersion(protocolVersion)
+		};
+	},
+	withProtocolVersion(wallet, version) {
+		return version > wallet.protocolVersion ? {
+			...wallet,
+			protocolVersion: version
+		} : wallet;
+	},
+	fromPreviousVersion(previous) {
+		return {
+			state: new _midnightntwrk_ledger_v9.DustLocalState(previous.dustParameters),
+			publicKey: previous.publicKey,
+			networkId: previous.networkId,
+			pendingDust: [],
+			progress: require_dist.createSyncProgress({
+				...previous.progress,
+				isConnected: false
+			}),
+			protocolVersion: require_dist.ProtocolVersion(previous.protocolVersion)
+		};
+	},
+	applyEventsWithChanges(wallet, secretKey, events, currentTime) {
+		const stateWithChanges = wallet.state.replayEventsWithChanges(secretKey, events);
+		const updatedState = stateWithChanges.state.processTtls(currentTime);
+		const availableNonces = updatedState.utxos.map((utxo) => utxo.nonce);
+		return [{
+			...wallet,
+			state: updatedState,
+			pendingDust: wallet.pendingDust.filter((t) => availableNonces.includes(t.nonce))
+		}, stateWithChanges.changes];
+	},
+	applyDustGenerations(wallet, dustCollapsedGenTreeSnapshot, newGenerations, generationDtimeUpdates) {
+		const applySnapshotGap = (state, lastIndex, nextGenerationIndex) => dustCollapsedGenTreeSnapshot.filter(({ startIndex, endIndex }) => startIndex > lastIndex && (nextGenerationIndex === void 0 || endIndex < nextGenerationIndex)).reduce((current, update) => current.applyGenerationCollapsedUpdate(readCollapsedUpdate(update)), state);
+		const { state: stateWithGenerations, lastIndex } = newGenerations.reduce((acc, { generationMtIndex, genInfo, qdo }) => ({
+			state: applySnapshotGap(acc.state, acc.lastIndex, generationMtIndex).insertGenerationInfo(BigInt(generationMtIndex), genInfo, qdo.backingNight),
+			lastIndex: generationMtIndex
+		}), {
+			state: wallet.state,
+			lastIndex: -1
+		});
+		const updatedState = generationDtimeUpdates.reduce((state, update) => state.updateGenerationTreeFromEvidence(readGenerationTreeInsertionPath(update.treeInsertionPath)), applySnapshotGap(stateWithGenerations, lastIndex));
+		return {
+			...wallet,
+			state: updatedState
+		};
+	},
+	applyNewDustUtxos(wallet, newDustUtxos) {
+		const updatedState = [...newDustUtxos].toSorted((a, b) => Number(a[1].qdo.mtIndex - b[1].qdo.mtIndex)).reduce((state, [dustNullifier, utxoInfo]) => state.addUtxo(dustNullifier, utxoInfo.qdo), wallet.state);
+		return {
+			...wallet,
+			state: updatedState
+		};
+	},
+	applyDustCommitments(wallet, newDustUtxos, collapsedCommitments) {
+		const newUtxos = [...require_dist.values(newDustUtxos)].toSorted((a, b) => Number(a.qdo.mtIndex - b.qdo.mtIndex));
+		const insertCommitments = (state, utxos) => utxos.reduce((current, utxoInfo) => current.insertCommitment(utxoInfo.qdo.mtIndex, utxoInfo.qdo, true), state);
+		const stateAfterCollapsed = collapsedCommitments.reduce((state, collapsed) => {
+			return insertCommitments(state, newUtxos.filter((utxoInfo) => Number(utxoInfo.qdo.mtIndex) < collapsed.startIndex && utxoInfo.qdo.mtIndex >= state.commitmentTreeFirstFree)).applyCommitmentCollapsedUpdate(readCollapsedUpdate(collapsed));
+		}, wallet.state);
+		const lastCollapsedIndex = collapsedCommitments.at(-1);
+		const updatedState = insertCommitments(stateAfterCollapsed, lastCollapsedIndex !== void 0 ? newUtxos.filter((utxoInfo) => Number(utxoInfo.qdo.mtIndex) > lastCollapsedIndex.endIndex) : newUtxos);
+		return {
+			...wallet,
+			state: updatedState
+		};
+	},
+	applySpentNullifiers(wallet, spentNullifiers) {
+		const updatedState = spentNullifiers.reduce((state, nullifier) => state.removeUtxo(nullifier), wallet.state);
+		return {
+			...wallet,
+			pendingDust: wallet.pendingDust.filter((d) => !spentNullifiers.includes(d.nullifier)),
+			state: updatedState
+		};
+	},
+	applyFailed(wallet, tx) {
+		const pendingSpendsMap = CoreWallet$1.pendingDustToMap(wallet.pendingDust);
+		const [updatedState, removedNullifiers] = require_dist.pipe(require_dist.pipe([...tx.intents?.values() ?? []], require_dist.flatMap$2((intent) => {
+			const spendTime = intent.dustActions?.ctime;
+			return (intent.dustActions?.spends ?? []).map((spend) => ({
+				spend,
+				spendTime
+			}));
+		}), require_dist.filterMap$1(({ spend, spendTime }) => require_dist.pipe(require_dist.fromNullable(pendingSpendsMap.get(spend.oldNullifier)), require_dist.map$5(() => ({
+			spend,
+			spendTime
+		}))))), require_dist.reduce([wallet.state, []], ([state, removed], { spend, spendTime }) => [state.processTtls(require_dist.addSeconds(spendTime, wallet.state.params.dustGracePeriodSeconds)), require_dist.append(removed, spend.oldNullifier)]));
+		return {
+			...wallet,
+			state: updatedState,
+			pendingDust: wallet.pendingDust.filter((coin) => !removedNullifiers.includes(coin.nullifier))
+		};
+	},
+	revertTransaction(wallet, tx) {
+		return CoreWallet$1.applyFailed(wallet, tx);
+	},
+	updateProgress(wallet, { appliedIndex, highestRelevantWalletIndex, highestIndex, highestRelevantIndex, isConnected }) {
+		const updatedProgress = require_dist.createSyncProgress({
+			appliedIndex: appliedIndex ?? wallet.progress.appliedIndex,
+			highestRelevantWalletIndex: highestRelevantWalletIndex ?? wallet.progress.highestRelevantWalletIndex,
+			highestIndex: highestIndex ?? wallet.progress.highestIndex,
+			highestRelevantIndex: highestRelevantIndex ?? wallet.progress.highestRelevantIndex,
+			isConnected: isConnected ?? wallet.progress.isConnected
+		});
+		return {
+			...wallet,
+			progress: updatedProgress
+		};
+	},
+	spendCoins(wallet, secretKey, coins, currentTime) {
+		const [output, newState, newPending] = require_dist.pipe(coins, require_dist.reduce([
+			[],
+			wallet.state,
+			wallet.pendingDust
+		], ([spends, localState, pending], { token: coinToSpend, value: takeFee }) => {
+			const [newState, dustSpend] = localState.spend(secretKey, coinToSpend, takeFee, currentTime);
+			const newPending = [...pending, {
+				...coinToSpend,
+				nullifier: dustSpend.oldNullifier
+			}];
+			return [
+				require_dist.append(spends, dustSpend),
+				newState,
+				newPending
+			];
+		}));
+		return [output, {
+			...wallet,
+			state: newState,
+			pendingDust: newPending
+		}];
+	},
+	pendingDustToMap(coins) {
+		return new Map(coins.map(({ nullifier, ...coins }) => [nullifier, coins]));
+	}
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v2/Utils.js
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+const SignatureMarker$1 = {
+	signature: "signature",
+	signatureErased: "signature-erased"
+};
+const ProofMarker$1 = {
+	proof: "proof",
+	preProof: "pre-proof",
+	noProof: "no-proof"
+};
+const BindingMarker$1 = {
+	binding: "binding",
+	preBinding: "pre-binding",
+	noBinding: "no-binding"
+};
+const hashMapGroupBy = (arr, keyFn) => arr.reduce((map, v) => {
+	const key = keyFn(v);
+	return require_dist.set$1(map, key, require_dist.match$1(require_dist.get$2(map, key), {
+		onNone: () => [v],
+		onSome: (existing) => existing.concat(v)
+	}));
+}, require_dist.empty$1());
+const leBigintToHex = (n, dropLengthPrefix = false) => {
+	const encoded = require__polyfill_buffer_patch.import_buffer.Buffer.from(require_dist.ScaleBigInt.encode(n));
+	return (dropLengthPrefix ? encoded.subarray(1) : encoded).toString("hex");
+};
+const bigintToLeHex = (n, byteLength) => Array.from({ length: byteLength }, (_, i) => Number(n >> BigInt(8 * i) & 255n).toString(16).padStart(2, "0")).join("");
+const uniqueArray = (arr) => Array.from(require_dist.fromIterable$1(arr));
+/**
+* Length (in HEX CHARACTERS) of the nullifier prefix to query the indexer with so it returns an anonymity set of
+* ~2^anonymityLevel out of a population of `totalItems` commitments, per the ledger dust.md "Wallet recovery" math: a
+* prefix of (log2(N) - anonymityLevel) BITS leaves a set of 2^anonymityLevel.
+*
+* BIT -> BYTE -> HEX-CHAR conversion: the indexer decodes each prefix with const_hex::decode, which accepts WHOLE BYTES
+* only (8 bits/step, 4 bits per hex char, so 2 hex chars per byte). The returned value is consumed as `.substring(0,
+* n)` on a hex string, hence it is a hex-char count and must be even.
+*
+* Rounding favours privacy: floor(log2(N)) under-estimates the population's entropy and floor(prefixBits/8) truncates
+* the byte count DOWN, so the realized prefix is never LONGER than ideal — a shorter prefix yields a LARGER anonymity
+* set, never dropping below 2^anonymityLevel.
+*
+* BYTE-GRANULARITY LIMITATION: because prefixes must be whole bytes and non-empty (min 1 byte = 2 hex chars), the exact
+* 2^anonymityLevel target cannot always be hit. Where the min-1-byte floor is binding (small or low-entropy
+* populations) it forces an 8-bit prefix that can make the realized set SMALLER than 2^anonymityLevel (e.g. N=2^14,
+* n=7: ideal 7 bits, floor forces 8 bits -> set 2^6=64 < 128). This is an unavoidable protocol constraint (the indexer
+* rejects empty prefixes) and is accepted.
+*/
+const calculatePrefixLength = (anonymityLevel, totalItems, maxLength) => {
+	const populationBits = totalItems <= 1 ? 0 : Math.floor(Math.log2(totalItems));
+	const prefixBits = Math.max(0, populationBits - anonymityLevel);
+	const idealHexChars = Math.floor(prefixBits / 8) * 2;
+	return Math.min(maxLength, Math.max(2, idealHexChars));
+};
+const gapRanges = (lastAppliedIndex, maxIndex, skipIndexes) => [lastAppliedIndex, ...skipIndexes].map((boundary, i) => ({
+	start: boundary + 1,
+	end: (skipIndexes.at(i) ?? maxIndex + 1) - 1
+})).filter(({ start, end }) => start <= end);
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v2/Sync.js
+/**
+* Constructors and matchers for {@link BackgroundRepeat}.
+*
+* @example
+*   ```ts
+*   const service: SyncService<CoreWallet, DustSecretKey, WalletSyncUpdate> = {
+*     backgroundRepeat: BackgroundRepeat.Once(),
+*     updates: (state, secretKey) => subscribe(state, secretKey),
+*     blockData: () => latestBlock(),
+*   };
+*   ```;
+*/
+const BackgroundRepeat = require_dist.taggedEnum();
+/**
+* Splits a batch of version-tagged items at the end of a variant's activation range.
+*
+* @remarks
+*   The split is positional, not a filter: everything from the first out-of-range item onwards is deferred, even if a
+*   later item reports an in-range version again. A batch is a contiguous slice of one timeline, so applying past a
+*   boundary and then resuming behind it would leave a hole no cursor can describe.
+*
+*   An item whose version is `undefined` is treated as in-range and contributes no annotation: an absent value means "the
+*   indexer did not say", which must keep the un-versioned behaviour exactly, rather than being read as version zero
+*   and dragging the recorded version down.
+*
+*   This is the one place the boundary rule lives; the indexer capability (per event) and the simulator capability (per
+*   block) both go through it, so they cannot drift apart.
+* @param items The batch, in source order.
+* @param versionOf Reads the protocol version an item was reported at, or `undefined` if it carries none.
+* @param activeRange The variant's half-open activation range.
+* @returns The applied/deferred split and the version to record.
+*/
+const splitAtVersionBoundary = (items, versionOf, activeRange) => {
+	const [, end] = activeRange;
+	const boundary = items.findIndex((item) => {
+		const version = versionOf(item);
+		return version !== void 0 && BigInt(version) >= end;
+	});
+	const [applied, deferred] = boundary < 0 ? [items, []] : [items.slice(0, boundary), items.slice(boundary)];
+	const signalling = deferred.at(0) ?? [...applied].reverse().find((item) => versionOf(item) !== void 0);
+	const signalledVersion = signalling === void 0 ? void 0 : versionOf(signalling);
+	return {
+		applied,
+		deferred,
+		observedVersion: signalledVersion === void 0 ? require_dist.none() : require_dist.some(require_dist.ProtocolVersion(BigInt(signalledVersion)))
+	};
+};
+/** Records a batch's observed protocol version on the state, monotonically. A batch that observed none is a no-op. */
+const annotateVersion = (state, observedVersion) => require_dist.match$1(observedVersion, {
+	onNone: () => state,
+	onSome: (version) => CoreWallet$1.withProtocolVersion(state, version)
+});
+/** How often the chain is asked its version when the configuration does not say. */
+const DEFAULT_VERSION_WATCH_INTERVAL_MS$1 = 3e4;
+/**
+* How long one event-id probe is given to produce its single answer.
+*
+* @remarks
+*   Both a stall guard and, on a chain with no dust history at all, the ordinary way the tick ends. A wallet with a
+*   cursor subscribes at an event that provably exists, so there the answer arrives at once or the transport is broken;
+*   a wallet on a chain that has never produced a dust event subscribes to a timeline the indexer will keep open and
+*   never write to. Without a bound, either would leave the poll loop parked on a tick that never completes and the
+*   wallet would stop asking altogether. A bound turns both into a skipped tick.
+*/
+const EVENT_TIP_PROBE_TIMEOUT$1 = require_dist.seconds(10);
+/**
+* Asks the source how far its dust event timeline goes.
+*
+* @remarks
+*   Over the event subscription rather than a query, because the schema has no query that reaches a dust ledger event:
+*   `block`/`transactions` reach one only through a block that happens to contain dust events, which on a quiet chain
+*   is precisely the block that does not. `maxId` is a property of the whole dust timeline — the indexer computes it as
+*   the maximum id within the dust grouping — so any single event answers it: the first one delivered is taken and the
+*   subscription closed.
+*
+*   The cursor is the wallet's own. The event it last applied provably exists, so the source answers immediately and has
+*   the least backfill to abandon; a wallet that has applied nothing asks from the start, where the first event is —
+*   or, on a chain with no dust event at all, where nothing is, and the tick times out into silence.
+* @param config The sync configuration, carrying the keep-alive the source's subscriptions use.
+* @param resumeFrom The wallet's cursor; below zero means "from the very start".
+* @returns The highest dust event id, or nothing if the source did not answer.
+*/
+const highestEventId$1 = (config, resumeFrom) => require_dist.pipe(require_dist.DustLedgerEventTip.run({ id: resumeFrom < 0n ? null : Number(resumeFrom) }), require_dist.runHead, require_dist.map$2(require_dist.map$5((answer) => answer.dustLedgerEvents.maxId)), require_dist.scoped, require_dist.timeout(EVENT_TIP_PROBE_TIMEOUT$1));
+/**
+* One check of the chain's protocol version, gated on the wallet being caught up on the source's dust event ids.
+*
+* @remarks
+*   The order of the two questions is load-bearing. The tip is read **first**: a tip reported at a version means the
+*   source has indexed through the block that carries it, so every event below it is already counted in the `maxId`
+*   read afterwards. Asked the other way round, an event indexed between the two answers could be one of the version
+*   that preceded the tip — unread, uncounted, and exactly what the gate exists to catch.
+*
+*   The one short-circuit is an answer rather than a shortcut: a tip at or below the version the wallet already held is a
+*   signal that could only be a no-op, so no probe is opened and nothing is emitted — which is what keeps a settled
+*   wallet from polling a subscription for the rest of its life. There is deliberately no second short-circuit for a
+*   chain that provably holds no dust event, because no such proof is available from the tip; see
+*   {@link VersionSignalSyncUpdate}.
+*
+*   Everything else is swallowed. A tick that fails says nothing about the chain, so it must neither reach the state nor
+*   take the sync stream down with it; the next tick is the retry, and costs nothing to wait for.
+* @param config The sync configuration, for the indexer to ask.
+* @param resumeFrom The wallet's cursor, for the probe.
+* @param knownVersion The version the wallet already held when this stream opened — a lower bound on what it holds now.
+* @returns The signal, or nothing when there is nothing to say or nobody said it.
+*/
+const readVersionSignal$1 = (config, resumeFrom, knownVersion) => require_dist.pipe(require_dist.BlockHash.run({ offset: null }), require_dist.provide(require_dist.layer$1({ url: config.indexerClientConnection.indexerHttpUrl })), require_dist.scoped, require_dist.flatMap$1((answer) => require_dist.match$1(require_dist.fromNullable(answer.block), {
+	onNone: () => require_dist.succeedNone,
+	onSome: (tip) => BigInt(tip.protocolVersion) <= knownVersion ? require_dist.succeedNone : require_dist.pipe(highestEventId$1(config, resumeFrom), require_dist.map$2(require_dist.map$5((maxId) => VersionSignalSyncUpdate$1.create(tip.protocolVersion, maxId))))
+})), require_dist.catchAll(() => require_dist.succeedNone));
+/**
+* The chain's version, re-asked on a timer for as long as sync runs.
+*
+* @remarks
+*   Deliberately silent about ticks that say nothing: a tick that finds the chain where the wallet left it, or that
+*   cannot reach the chain at all, emits no element rather than an empty one, so nothing downstream has to know that
+*   polling is how the answer was arrived at.
+* @param config The sync configuration, carrying the interval.
+* @param resumeFrom The wallet's cursor, for the probe.
+* @param knownVersion The version the wallet held when this stream opened.
+* @returns The signals, or an empty stream when watching is turned off.
+*/
+const versionWatch$1 = (config, resumeFrom, knownVersion) => {
+	const intervalMs = config.versionWatch?.intervalMs ?? DEFAULT_VERSION_WATCH_INTERVAL_MS$1;
+	return intervalMs <= 0 ? require_dist.empty : require_dist.pipe(require_dist.fromSchedule(require_dist.spaced(require_dist.millis(intervalMs))), require_dist.mapEffect(() => readVersionSignal$1(config, resumeFrom, knownVersion)), require_dist.filterMap(require_dist.identity));
+};
+const SecretKeysResource = { create: (secretKey) => {
+	return (cb) => {
+		const result = cb(secretKey);
+		secretKey.clear();
+		return result;
+	};
+} };
+const makeDefaultSyncService = (config) => {
+	const indexerSyncService = makeIndexerSyncService(config);
+	return {
+		backgroundRepeat: BackgroundRepeat.Once(),
+		updates: (state, secretKey) => {
+			const batchSize = config.batchUpdates?.size ?? 10;
+			const batchTimeout = require_dist.millis(config.batchUpdates?.timeout ?? 1);
+			const batchSpacing = config.batchUpdates?.spacing ?? 4;
+			const timeline = require_dist.pipe(indexerSyncService.subscribeWallet(state), require_dist.groupedWithin(batchSize, batchTimeout), require_dist.map(require_dist.toArray), require_dist.map((data) => WalletSyncUpdate$1.create(data, secretKey, /* @__PURE__ */ new Date())), batchSpacing > 0 ? require_dist.schedule(require_dist.spaced(require_dist.millis(batchSpacing))) : (eventsStream) => eventsStream);
+			const resumeFrom = state.progress.appliedIndex - 1n;
+			return require_dist.pipe(require_dist.merge(timeline, versionWatch$1(config, resumeFrom, state.protocolVersion), { haltStrategy: "left" }), require_dist.provideSomeLayer(indexerSyncService.connectionLayer()));
+		},
+		blockData: (height) => {
+			return require_dist.pipe(indexerSyncService.blockData(height), require_dist.provide(indexerSyncService.queryClient()), require_dist.scoped);
+		}
+	};
+};
+const accumulateUtxoUpdates = (updates, initialUtxos, initialSpentUtxos) => updates.reduce(({ nextUtxos, nextSpentUtxos }, update) => {
+	const entry = {
+		qdo: update.qdo,
+		transactionId: update.transactionId,
+		transactionHash: update.transactionHash,
+		genInfo: update.genInfo
+	};
+	return update.isSpent ? {
+		nextUtxos,
+		nextSpentUtxos: require_dist.set$1(nextSpentUtxos, update.dustNullifier, entry)
+	} : {
+		nextUtxos: require_dist.set$1(nextUtxos, update.dustNullifier, entry),
+		nextSpentUtxos
+	};
+}, {
+	nextUtxos: initialUtxos,
+	nextSpentUtxos: initialSpentUtxos
+});
+const loadCollapsedCommitments = (lastAppliedIndex, maxIndex, newUtxos, indexerSyncService) => {
+	if (maxIndex < 0 || lastAppliedIndex === maxIndex) return require_dist.succeed([]);
+	return require_dist.pipe(gapRanges(lastAppliedIndex, maxIndex, [...newUtxos].toSorted((a, b) => Number(a[1].qdo.mtIndex - b[1].qdo.mtIndex)).map(([_, u]) => Number(u.qdo.mtIndex))).map(({ start, end }) => indexerSyncService.dustCommitmentMerkleTreeUpdate(start, end)), require_dist.all);
+};
+const NULLIFIER_BYTE_LENGTH = 32;
+const NULLIFIER_LENGTH = NULLIFIER_BYTE_LENGTH * 2;
+const nullifierPhaseProgress = (mtIndicesSum, totalNullifiers, freshCount, maxCommitmentEndIndex) => Math.min(Number(mtIndicesSum) + (totalNullifiers - freshCount) * maxCommitmentEndIndex, totalNullifiers * maxCommitmentEndIndex);
+/**
+* The applied index a mid-phase nullifier report carries, on the same basis as every other report in the pass.
+*
+* @remarks
+*   The nullifier term is the larger of two true statements about the same work. {@link nullifierPhaseProgress} measures
+*   this phase from zero, while the report that opened the phase already credited the nullifiers the wallet arrived
+*   holding; early in the phase the credit is the further along of the two, and reporting the measurement alone would
+*   take progress backwards.
+* @param basis The two terms this phase does not advance: commitment work, and nullifier work already credited.
+* @param generationWork The generation term, which is complete by the time this phase runs.
+* @param phaseProgress What {@link nullifierPhaseProgress} has measured so far.
+* @returns The applied index to report.
+*/
+const nullifierPhaseAppliedIndex = (basis, generationWork, phaseProgress) => generationWork + basis.commitmentWork + Math.max(basis.creditedNullifierWork, phaseProgress);
+const resolveNullifierSpends = (initialNullifiers, initialNewUtxos, pendingDust, dustState, secretKey, latestBlock, dustGenerationUpdates, indexerSyncService, anonymityLevel, ledgerParametersCodecs, progressBasis, emit) => {
+	const maxCommitmentEndIndex = latestBlock.dustCommitmentEndIndex - 1;
+	const initialSpentUtxos = require_dist.empty$1();
+	return require_dist.pipe(require_dist.unfoldEffect([
+		initialNullifiers,
+		initialNewUtxos,
+		initialSpentUtxos
+	], ([nullifiersToCheck, newUtxos, spentUtxos]) => {
+		if (nullifiersToCheck.length === 0) return require_dist.succeed(require_dist.none());
+		return require_dist.gen(function* () {
+			const prefixLength = calculatePrefixLength(anonymityLevel, maxCommitmentEndIndex, NULLIFIER_LENGTH);
+			const dustUtxoUpdates = yield* createDustUtxoUpdates(dustState, matchedDustSpends(yield* require_dist.pipe(indexerSyncService.subscribeDustNullifierTransactions(nullifiersToCheck, latestBlock.height, prefixLength), require_dist.runCollect, require_dist.map$2(require_dist.toArray))), secretKey, newUtxos, pendingDust, dustGenerationUpdates.generationDtimeUpdates, ledgerParametersCodecs);
+			const freshUtxos = dustUtxoUpdates.filter((u) => !u.isSpent);
+			if (freshUtxos.length > 0) {
+				const mtIndicesSum = freshUtxos.reduce((partialSum, a) => partialSum + a.qdo.mtIndex, 0n);
+				const generationEndIndex = latestBlock.dustGenerationEndIndex - 1;
+				const progress = nullifierPhaseProgress(mtIndicesSum, initialNullifiers.length, freshUtxos.length, maxCommitmentEndIndex);
+				yield* require_dist.promise(() => emit.single(ProgressUpdate({ appliedIndex: nullifierPhaseAppliedIndex(progressBasis, generationEndIndex, progress) })));
+			}
+			const { nextUtxos, nextSpentUtxos } = accumulateUtxoUpdates(dustUtxoUpdates, newUtxos, spentUtxos);
+			const nextNullifiersToCheck = dustUtxoUpdates.filter((u) => !u.isSpent).map((u) => u.dustNullifier);
+			return require_dist.some([{
+				nextUtxos,
+				nextSpentUtxos
+			}, [
+				nextNullifiersToCheck,
+				nextUtxos,
+				nextSpentUtxos
+			]]);
+		});
+	}), require_dist.runCollect, require_dist.map$2(require_dist.toArray), require_dist.map$2((results) => require_dist.pipe(require_dist.last(results), require_dist.getOrElse(() => ({
+		nextUtxos: initialNewUtxos,
+		nextSpentUtxos: require_dist.empty$1()
+	})))));
+};
+const doEventlessSync = (state, secretKey, anonymityLevel, indexerSyncService, ledgerParametersCodecs = defaultLedgerParametersCodecs$1) => {
+	return require_dist.asyncEffect((emit) => require_dist.gen(function* () {
+		const latestBlock = yield* indexerSyncService.blockData();
+		const maxCommitmentTreeIndex = latestBlock.dustCommitmentEndIndex - 1;
+		const maxGeneratingTreeIndex = latestBlock.dustGenerationEndIndex - 1;
+		const lastSyncedCommitmentIndex = state.state.commitmentTreeFirstFree - 1n;
+		const lastSyncedGenerationIndex = state.state.generatingTreeFirstFree - 1n;
+		const lastSyncedBlockHeight = state.progress.highestIndex;
+		const commitmentWork = Number(lastSyncedCommitmentIndex);
+		const creditedNullifierWork = state.state.nullifiers.size * maxCommitmentTreeIndex;
+		const highestInitialIndex = maxGeneratingTreeIndex + maxCommitmentTreeIndex + creditedNullifierWork;
+		const initialAppliedIndex = Number(lastSyncedGenerationIndex) + commitmentWork + creditedNullifierWork;
+		yield* require_dist.logDebug(`Projections sync resuming from block height ${lastSyncedBlockHeight}, generation index ${lastSyncedGenerationIndex}, commitment index ${lastSyncedCommitmentIndex}; chain at block ${latestBlock.height} with generation index ${maxGeneratingTreeIndex} and commitment index ${maxCommitmentTreeIndex}`);
+		yield* require_dist.promise(() => emit.single(ProgressUpdate({
+			highestRelevantIndex: highestInitialIndex,
+			appliedIndex: initialAppliedIndex
+		})));
+		const rawGenerations = yield* require_dist.pipe(indexerSyncService.subscribeDustGenerations(require_dist.DustAddress.encodePublicKey(state.networkId, secretKey.publicKey), Number(lastSyncedBlockHeight), maxGeneratingTreeIndex, latestBlock), require_dist.runCollect, require_dist.map$2(require_dist.toArray));
+		const dustGenerationUpdates = DustGenerationsSyncUpdate.create(rawGenerations, secretKey, state.publicKey, lastSyncedGenerationIndex);
+		const allNullifiers = dustGenerationUpdates.newGenerations.map((n) => n.dustNullifier).concat([...state.state.nullifiers.keys(), ...state.pendingDust.map((d) => d.nullifier)]);
+		const highestRelevantIndex = maxGeneratingTreeIndex + maxCommitmentTreeIndex + allNullifiers.length * maxCommitmentTreeIndex;
+		yield* require_dist.promise(() => emit.single(ProgressUpdate({
+			highestRelevantIndex,
+			appliedIndex: maxGeneratingTreeIndex + commitmentWork + creditedNullifierWork
+		})));
+		const { nextUtxos: finalUtxos, nextSpentUtxos: finalSpentUtxos } = yield* resolveNullifierSpends(allNullifiers, DustUtxoMap.create(dustGenerationUpdates.newGenerations), CoreWallet$1.pendingDustToMap(state.pendingDust), state.state, secretKey, latestBlock, dustGenerationUpdates, indexerSyncService, anonymityLevel, ledgerParametersCodecs, {
+			commitmentWork,
+			creditedNullifierWork
+		}, emit);
+		yield* require_dist.promise(() => emit.single(ProgressUpdate({ appliedIndex: maxGeneratingTreeIndex + commitmentWork + allNullifiers.length * maxCommitmentTreeIndex })));
+		const collapsedCommitments = yield* loadCollapsedCommitments(Number(lastSyncedCommitmentIndex), maxCommitmentTreeIndex, finalUtxos, indexerSyncService);
+		yield* require_dist.promise(() => emit.single(StateUpdate({
+			dustGenerations: dustGenerationUpdates,
+			spentUtxos: finalSpentUtxos,
+			newUtxos: finalUtxos,
+			collapsedCommitments,
+			latestBlock
+		})));
+		yield* require_dist.promise(() => emit.single(ProgressUpdate({ appliedIndex: highestRelevantIndex })));
+		yield* require_dist.promise(() => emit.end());
+	}), "unbounded");
+};
+const makeEventLessSyncService = (config) => {
+	const defaultSyncService = makeDefaultSyncService(config);
+	const indexerSyncService = makeIndexerSyncService(config);
+	const anonymityLevel = config.anonymityLevel ?? 7;
+	return {
+		backgroundRepeat: BackgroundRepeat.WithDelay({ delay: require_dist.millis(config.backgroundSyncInterval ?? 5e3) }),
+		updates: (state, secretKey) => require_dist.pipe(doEventlessSync(state, secretKey, anonymityLevel, indexerSyncService, config.ledgerParametersCodecs ?? defaultLedgerParametersCodecs$1), require_dist.provideSomeLayer(require_dist.merge$1(indexerSyncService.connectionLayer(), indexerSyncService.queryClient()))),
+		blockData: defaultSyncService.blockData
+	};
+};
+const makeIndexerSyncService = (config) => {
+	return {
+		queryClient() {
+			return require_dist.pipe(require_dist.layer$1({ url: config.indexerClientConnection.indexerHttpUrl }), require_dist.mapError$1((error) => new OtherWalletError$1(error)));
+		},
+		connectionLayer() {
+			const { indexerClientConnection } = config;
+			return require_dist.createWebSocketUrl(indexerClientConnection.indexerHttpUrl, indexerClientConnection.indexerWsUrl).pipe(require_dist.flatMap$4((url) => require_dist.make(url)), require_dist.match$2({
+				onLeft: (error) => require_dist.fail$1(error),
+				onRight: (url) => require_dist.layer({
+					url,
+					keepAlive: indexerClientConnection.keepAlive
+				})
+			}), require_dist.mapError$1((e) => new SyncWalletError$1({
+				message: "Failed to obtain correct indexer URLs",
+				cause: e
+			})));
+		},
+		subscribeWallet(state) {
+			const { appliedIndex } = state.progress;
+			const bufferSize = config.indexerClientConnection.bufferSize ?? 1e4;
+			const resumeThreshold = config.indexerClientConnection.resumeThreshold ?? 100;
+			const resumeFrom = appliedIndex - 1n;
+			return require_dist.pipe(require_dist.DustLedgerEvents.runWithBackpressure({
+				bufferSize,
+				resumeThreshold,
+				from: resumeFrom,
+				variables: (cursor) => ({ id: cursor < 0n ? null : Number(cursor) }),
+				key: (r) => BigInt(r.dustLedgerEvents.id)
+			}), require_dist.mapEffect((subscription) => require_dist.pipe(require_dist.decodeUnknownEither(SyncEventsUpdateSchema$1)(subscription.dustLedgerEvents), require_dist.mapLeft((err) => new SyncWalletError$1(err)), require_dist.toEffect)), require_dist.mapError((error) => new SyncWalletError$1(error)));
+		},
+		subscribeDustGenerations(dustAddress, lastSyncedBlockHeight, maxGeneratingTreeIndex, latestBlock) {
+			if (maxGeneratingTreeIndex < 0 || latestBlock.height === lastSyncedBlockHeight && lastSyncedBlockHeight !== 0) return require_dist.empty;
+			return require_dist.pipe(require_dist.DustGenerationEvents.run({
+				dustAddress,
+				blockHash: latestBlock.hash,
+				dtimeCutoffHeight: lastSyncedBlockHeight
+			}), require_dist.mapEffect((subscription) => {
+				return require_dist.pipe(require_dist.decodeUnknownEither(DustGenerationsSubscriptionSchema)(subscription.dustGenerations), require_dist.mapLeft((err) => new SyncWalletError$1(err)), require_dist.toEffect);
+			}), require_dist.mapError((error) => new SyncWalletError$1(error)));
+		},
+		subscribeDustNullifierTransactions(dustNullifiers, toBlock, prefixLength) {
+			const hexedNullifiers = require_dist.fromIterable$1(dustNullifiers.map((n) => bigintToLeHex(n, NULLIFIER_BYTE_LENGTH)));
+			return require_dist.pipe(require_dist.DustNullifierTransactions.run({
+				nullifierLeBytesPrefixes: uniqueArray([...hexedNullifiers].map((n) => n.substring(0, prefixLength))),
+				fromBlock: 0,
+				toBlock
+			}), require_dist.filter((subscription) => require_dist.has$1(hexedNullifiers, subscription.dustNullifierTransactions.nullifierLeBytes)), require_dist.mapEffect((subscription) => {
+				return require_dist.pipe(require_dist.decodeUnknownEither(DustNullifierTransactionSubscriptionSchema)(subscription.dustNullifierTransactions), require_dist.mapLeft((err) => new SyncWalletError$1(err)), require_dist.toEffect);
+			}), require_dist.mapError((error) => new SyncWalletError$1(error)));
+		},
+		dustCommitmentMerkleTreeUpdate(startIndex, endIndex) {
+			return require_dist.pipe(require_dist.DustCommitmentMerkleTreeUpdate.run({
+				startIndex,
+				endIndex
+			}), require_dist.flatMap$1((result) => {
+				return require_dist.pipe(require_dist.decodeUnknownEither(CollapsedMerkleTreeSchema)(result.dustCommitmentMerkleTreeUpdate), require_dist.mapLeft((err) => new SyncWalletError$1(err)), require_dist.toEffect);
+			}), require_dist.catchAll((err) => require_dist.fail$2(new OtherWalletError$1({
+				message: `Encountered unexpected error: ${err.message}`,
+				cause: err
+			}))));
+		},
+		blockData: (height) => {
+			return require_dist.pipe(require_dist.BlockHash.run({ offset: height !== void 0 ? { height } : null }), require_dist.mapError$2((err) => new OtherWalletError$1({
+				message: `Encountered unexpected error: ${err.message}`,
+				cause: err
+			})), require_dist.flatMap$1((result) => {
+				if (!result.block) return require_dist.fail$2(new OtherWalletError$1({ message: "Unable to fetch block data" }));
+				return require_dist.pipe(require_dist.decodeUnknownEither(makeBlockDataSchema(config.ledgerParametersCodecs ?? defaultLedgerParametersCodecs$1))(result.block), require_dist.mapLeft((err) => new SyncWalletError$1(err)), require_dist.toEffect);
+			}));
+		}
+	};
+};
+/** The result of an update that observed nothing of the chain. */
+const noChanges$1 = (state) => ({
+	changes: [],
+	protocolVersion: Number(state.protocolVersion)
+});
+/**
+* Folds what the chain said about its own version into the wallet state.
+*
+* @remarks
+*   The same recording the event path makes through {@link annotateVersion}, and nothing else: no cursor moves, no dust
+*   changes hands, no tree grows. 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: unread events below
+*   the source's tip mean the hand-over would park the cursor in front of history the next variant cannot read — and
+*   those events carry the version themselves, so nothing is lost by waiting for them. That is not an error: the next
+*   tick asks again.
+*
+*   A version at or below the one already recorded needs no guard of its own — {@link annotateVersion} never goes
+*   backwards — so a source briefly answering from a lagging replica cannot drag a wallet back over a boundary.
+* @param state The wallet to record on.
+* @param update What the chain said, and how far its dust event timeline goes.
+* @returns The wallet, annotated or untouched, and an empty result.
+*/
+const applyVersionSignal$1 = (state, update) => [BigInt(update.highestEventId) > state.progress.appliedIndex ? state : annotateVersion(state, require_dist.some(require_dist.ProtocolVersion(BigInt(update.version)))), noChanges$1(state)];
+/**
+* Checks that freshly delivered events arrive in strictly ascending id order.
+*
+* @remarks
+*   Order is all that can be checked, never contiguity: dust events share one id sequence with zswap and contract events
+*   in the indexer, so gaps in a dust stream are normal. A skipped commitment-inserting event is caught by the ledger's
+*   own insertion check instead. An empty batch is trivially ordered.
+* @param fresh The events left after the cursor filter, in source order.
+* @param appliedIndex The highest event id already applied; the first fresh id must exceed it.
+* @returns The batch unchanged, or the first id that fails to exceed its predecessor as an
+*   {@link OutOfOrderSyncUpdateError}.
+*/
+const expectAscending$1 = (fresh, appliedIndex) => require_dist.pipe(require_dist.zipWith(fresh, require_dist.prepend(require_dist.map$3(fresh, (item) => BigInt(item.id)), appliedIndex), (item, previous) => ({
+	item,
+	previous
+})), require_dist.findFirst(({ item, previous }) => BigInt(item.id) <= previous), require_dist.match$1({
+	onNone: () => require_dist.right(fresh),
+	onSome: ({ item, previous }) => require_dist.left(new OutOfOrderSyncUpdateError$1({
+		message: `Dust event ${item.id} delivered at or below its predecessor ${previous}; batch refused, applied index stays at ${appliedIndex}`,
+		expected: previous,
+		received: BigInt(item.id)
+	}))
+}));
+const makeDefaultSyncCapability = () => {
+	return { applyUpdate(state, wrappedUpdate, activeRange) {
+		if (wrappedUpdate._tag === "VersionSignal") return applyVersionSignal$1(state, wrappedUpdate);
+		const { updates, secretKey } = wrappedUpdate;
+		if (updates.length === 0) return [state, {
+			changes: [],
+			protocolVersion: Number(state.protocolVersion)
+		}];
+		const appliedIndex = state.progress.appliedIndex;
+		const freshUpdates = updates.filter((u) => BigInt(u.id) > appliedIndex);
+		const highestRelevantWalletIndex = BigInt(updates.at(-1).maxId);
+		const { applied, observedVersion } = splitAtVersionBoundary(require_dist.getOrThrowWith(expectAscending$1(freshUpdates, appliedIndex), require_dist.identity), (update) => update.protocolVersion, activeRange);
+		const [newState, changes] = applied.length === 0 ? [state, []] : CoreWallet$1.applyEventsWithChanges(state, secretKey, applied.map(readEvent$1), wrappedUpdate.timestamp);
+		return [CoreWallet$1.updateProgress(annotateVersion(newState, observedVersion), {
+			appliedIndex: applied.length === 0 ? appliedIndex : BigInt(applied.at(-1).id),
+			highestRelevantWalletIndex,
+			isConnected: true
+		}), {
+			changes,
+			protocolVersion: [...applied].reverse().find((u) => u.protocolVersion !== void 0)?.protocolVersion ?? Number(state.protocolVersion)
+		}];
+	} };
+};
+/**
+* The projections-based fast-sync capability.
+*
+* @remarks
+*   **This path does not implement the fork boundary, and cannot yet.** It takes `activeRange` for signature parity with
+*   the other capabilities and deliberately ignores it: a projections update is a folded snapshot of dust state —
+*   Merkle tree updates, new and spent UTXOs, a block header — not a sequence of version-tagged timeline items, so
+*   there is nothing in it to split and nothing that reports the protocol version a piece of it belongs to. `BlockData`
+*   carries height, hash, timestamp and ledger parameters, but no version.
+*
+*   A wallet syncing through this path therefore never annotates a version and never hands over. Closing that needs a
+*   version on the projections wire format, which is the same deferred indexer question as the one on
+*   `SyncEventsUpdateSchema` — recorded here rather than papered over with a boundary check that would silently do
+*   nothing.
+*
+*   The version watcher {@link makeDefaultSyncService} carries does not close it either, and is deliberately not fitted to
+*   {@link makeEventLessSyncService}: the watcher's gate is "the wallet is level with the source's dust event ids", and
+*   this path keeps no such cursor — its `appliedIndex` counts Merkle indices and nullifier scans, not events — so
+*   there is nothing here for the gate to compare against.
+*/
+const makeEventLessSyncCapability = () => {
+	return { applyUpdate(state, update, _activeRange) {
+		if (isProgressUpdate(update)) return [CoreWallet$1.updateProgress(state, {
+			appliedIndex: BigInt(update.appliedIndex ?? state.progress.appliedIndex),
+			highestRelevantWalletIndex: BigInt(update.highestRelevantIndex ?? state.progress.highestRelevantWalletIndex),
+			isConnected: true
+		}), {
+			changes: [],
+			protocolVersion: Number(state.protocolVersion)
+		}];
+		const { dustGenerations, spentUtxos, newUtxos, collapsedCommitments, latestBlock } = update;
+		const dustGenTreeUpdates = dustGenerations.rawUpdates.filter((u) => u.__typename === "DustGenerationsItem" || u.__typename === "DustGenerationsProgress").map((u) => u.collapsedMerkleTree).filter((update) => update !== null).toSorted((u1, u2) => u1.startIndex - u2.startIndex);
+		const walletWithAppliedUpdates = require_dist.pipe(CoreWallet$1.applyDustGenerations(state, dustGenTreeUpdates, dustGenerations.newGenerations, dustGenerations.generationDtimeUpdates), (wallet) => CoreWallet$1.applyNewDustUtxos(wallet, newUtxos), (wallet) => CoreWallet$1.applyDustCommitments(wallet, newUtxos, collapsedCommitments), (wallet) => CoreWallet$1.applySpentNullifiers(wallet, [...require_dist.keys(spentUtxos)]));
+		const groupedNewUtxos = hashMapGroupBy([...require_dist.values(newUtxos)], (u) => u.transactionId);
+		const groupedSpentUtxos = hashMapGroupBy([...require_dist.values(spentUtxos)], (u) => u.transactionId);
+		const changes = uniqueArray([...require_dist.keys(groupedNewUtxos), ...require_dist.keys(groupedSpentUtxos)]).toSorted().map((txId) => {
+			const received = require_dist.getOrElse(require_dist.get$2(groupedNewUtxos, txId), () => []);
+			const spent = require_dist.getOrElse(require_dist.get$2(groupedSpentUtxos, txId), () => []);
+			return new _midnightntwrk_ledger_v9.DustStateChanges(received.at(0)?.transactionHash || spent.at(0)?.transactionHash, received.map(({ qdo }) => qdo), spent.map(({ qdo }) => qdo));
+		});
+		const updatedDustState = walletWithAppliedUpdates.state.processTtls(latestBlock.timestamp);
+		updatedDustState.syncTime = latestBlock.timestamp;
+		const walletAtLatestBlock = {
+			...walletWithAppliedUpdates,
+			state: updatedDustState
+		};
+		const newCommitmentTreeRoot = walletAtLatestBlock.state.commitmentTreeRoot() !== void 0 ? leBigintToHex(walletAtLatestBlock.state.commitmentTreeRoot()) : "";
+		const newGeneratingTreeRoot = walletAtLatestBlock.state.generatingTreeRoot() !== void 0 ? leBigintToHex(walletAtLatestBlock.state.generatingTreeRoot()) : "";
+		if (newCommitmentTreeRoot !== update.latestBlock.dustCommitmentMerkleTreeRoot || newGeneratingTreeRoot !== update.latestBlock.dustGenerationMerkleTreeRoot) throw new OtherWalletError$1({ message: "Root hashes don`t match" });
+		return [CoreWallet$1.updateProgress(walletAtLatestBlock, { highestIndex: BigInt(update.latestBlock.height) }), {
+			changes,
+			protocolVersion: Number(state.protocolVersion)
+		}];
+	} };
+};
+const createUtxoUpdatesFromSpend = (dustState, secretKey, knownUtxos, pendingDust, generationDtimeUpdates, transaction, dustSpend, ledgerParametersCodecs) => require_dist.gen(function* () {
+	const { nullifier, vFee, commitmentIndex, declaredTime } = dustSpend;
+	const knownUtxo = require_dist.getOrUndefined(require_dist.get$2(knownUtxos, nullifier));
+	const qdo = knownUtxo?.qdo ?? pendingDust.get(nullifier) ?? dustState.findUtxoByNullifier(nullifier);
+	if (!qdo) {
+		yield* require_dist.logDebug(`Skipping dust spend of a nullifier not owned by this wallet: ${nullifier}`);
+		return require_dist.none();
+	}
+	const genInfo = knownUtxo?.genInfo ?? dustState.generationInfo(qdo);
+	if (!genInfo) return yield* new SyncWalletError$1({ message: `Failed to find generation info for: ${qdo.backingNight}` });
+	const dtimeUpdate = generationDtimeUpdates.find((upd) => upd.nightUtxoHash === genInfo.nonce);
+	const updatedGenInfo = dtimeUpdate !== void 0 ? {
+		...genInfo,
+		dtime: dtimeUpdate.newDtime
+	} : genInfo;
+	const txMeta = {
+		transactionId: transaction.id,
+		transactionHash: transaction.hash,
+		genInfo: updatedGenInfo
+	};
+	const spentUtxoUpdate = {
+		dustNullifier: nullifier,
+		qdo,
+		isSpent: true,
+		...txMeta
+	};
+	const successorUtxo = (0, _midnightntwrk_ledger_v9.successorDustUtxo)(qdo, declaredTime, vFee, commitmentIndex, updatedGenInfo, secretKey, (yield* require_dist.pipe(readNullifierBlockParameters(transaction.block, ledgerParametersCodecs), require_dist.mapLeft((error) => new SyncWalletError$1({
+		message: error.message,
+		cause: error
+	})), require_dist.toEffect)).dust);
+	const newUtxoUpdate = {
+		dustNullifier: (0, _midnightntwrk_ledger_v9.dustNullifier)(successorUtxo, secretKey),
+		qdo: successorUtxo,
+		isSpent: false,
+		...txMeta
+	};
+	return require_dist.some([spentUtxoUpdate, newUtxoUpdate]);
+});
+/**
+* Reads the dust spends out of the transactions a nullifier lookup matched.
+*
+* @remarks
+*   Separate from resolving them, because this is the step that touches bytes. The lookup matches on a nullifier _prefix_
+*   and searches from block zero, so it deliberately over-delivers: most of what it returns belongs to other parties,
+*   and on a chain that has forked some of it belongs to the previous ledger version. An event this ledger version
+*   cannot read is therefore by construction not one of this wallet's spends, and is skipped rather than failing the
+*   whole lookup — which would take every dust spend this wallet ever made down with it.
+* @param nullifierTransactions The transactions the lookup matched.
+* @returns The dust spends among them, in source order.
+*/
+const matchedDustSpends = (nullifierTransactions) => require_dist.pipe(nullifierTransactions, require_dist.filterMap$1(({ transaction }) => transaction.__typename === "RegularTransaction" ? require_dist.some(transaction) : require_dist.none()), require_dist.dedupeAdjacentWith((a, b) => a.id === b.id), require_dist.flatMap$2((transaction) => require_dist.filterMap$1(transaction.dustLedgerEvents, (event) => require_dist.pipe(tryReadEvent(event), require_dist.flatMap$3((decoded) => decoded.content.tag === "dustSpendProcessed" ? require_dist.some({
+	transaction,
+	dustSpend: decoded.content
+}) : require_dist.none())))));
+const createDustUtxoUpdates = (dustState, spends, secretKey, knownUtxos, pendingDust, generationDtimeUpdates, ledgerParametersCodecs = defaultLedgerParametersCodecs$1) => require_dist.pipe(spends, require_dist.map$3(({ transaction, dustSpend }) => createUtxoUpdatesFromSpend(dustState, secretKey, knownUtxos, pendingDust, generationDtimeUpdates, transaction, dustSpend, ledgerParametersCodecs)), require_dist.all, require_dist.map$2(require_dist.getSomes), require_dist.map$2(require_dist.flatten));
+const makeSimulatorSyncService = (config) => {
+	return {
+		backgroundRepeat: BackgroundRepeat.Once(),
+		updates: (_state, secretKey) => {
+			let lastSeenBlockNumber;
+			return require_dist.pipe(require_dist.fromEffect(config.simulator.getLatestState()), require_dist.concat(config.simulator.state$), require_dist.filter((state) => {
+				const lastBlock = require_dist.getLastBlock(state);
+				if (lastBlock === void 0) return false;
+				const blockNumber = lastBlock.number;
+				if (lastSeenBlockNumber !== void 0 && blockNumber <= lastSeenBlockNumber) return false;
+				lastSeenBlockNumber = blockNumber;
+				return true;
+			}), require_dist.map((state) => ({
+				update: state,
+				secretKey
+			})));
+		},
+		blockData: () => {
+			return require_dist.gen(function* () {
+				const state = yield* config.simulator.getLatestState();
+				const lastBlock = require_dist.getLastBlock(state);
+				return {
+					hash: lastBlock.hash,
+					height: Number(lastBlock.number),
+					protocolVersion: Number(lastBlock.protocolVersion),
+					ledgerParameters: state.ledger.parameters,
+					timestamp: state.currentTime,
+					zswapEndIndex: 1,
+					dustCommitmentEndIndex: 1,
+					dustGenerationEndIndex: 1,
+					dustCommitmentMerkleTreeRoot: "",
+					dustGenerationMerkleTreeRoot: ""
+				};
+			});
+		}
+	};
+};
+const makeSimulatorSyncCapability = () => {
+	return { applyUpdate: (state, update, activeRange) => {
+		if (require_dist.getLastBlock(update.update) === void 0) return [state, {
+			changes: [],
+			protocolVersion: Number(state.protocolVersion)
+		}];
+		const { applied, observedVersion } = splitAtVersionBoundary(update.update.blocks.filter((block) => block.number >= state.progress.appliedIndex), (block) => Number(block.protocolVersion), activeRange);
+		const events = applied.flatMap((block) => block.transactions.flatMap((tx) => tx.result.events));
+		const lastAppliedBlock = applied.at(-1);
+		const [newState, changes] = applied.length === 0 ? [state, []] : CoreWallet$1.applyEventsWithChanges(state, update.secretKey, events, lastAppliedBlock.timestamp);
+		return [CoreWallet$1.updateProgress(annotateVersion(newState, observedVersion), { appliedIndex: lastAppliedBlock === void 0 ? state.progress.appliedIndex : lastAppliedBlock.number + 1n }), {
+			changes,
+			protocolVersion: lastAppliedBlock === void 0 ? Number(state.protocolVersion) : Number(lastAppliedBlock.protocolVersion)
+		}];
+	} };
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v2/RunningV2Variant.js
+const progress$1 = (state) => {
+	const appliedIndex = state.progress?.appliedIndex ?? 0n;
+	const highestRelevantWalletIndex = state.progress?.highestRelevantWalletIndex ?? 0n;
+	const sourceGap = (state.progress?.highestIndex ?? 0n) - (state.progress?.highestRelevantIndex ?? 0n);
+	const applyGap = highestRelevantWalletIndex - appliedIndex;
+	return [require_dist.ProgressUpdate({
+		sourceGap,
+		applyGap
+	})];
+};
+/**
+* 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");
+/**
+* How a failing synchronization pass is retried.
+*
+* @remarks
+*   Exported so the delays it actually produces can be asserted. A schedule reads as though its combinators apply to the
+*   delay, and for some of them they do not — which is worth pinning in a test rather than trusting by eye.
+*/
+const syncRetrySchedule$1 = require_dist.pipe(require_dist.exponential(require_dist.seconds(1), 2), require_dist.jittered, require_dist.union(require_dist.spaced(require_dist.minutes(2))));
+var RunningV2Variant = class {
+	__polyTag__ = V2Tag;
+	#scope;
+	#context;
+	#v2Context;
+	#txHistoryPermits = require_dist.makeSemaphore(8).pipe(require_dist.runSync);
+	state;
+	#syncLock;
+	/**
+	* Whether a background synchronization worker is already running.
+	*
+	* @remarks
+	*   Distinct from {@link #syncLock}, which is released at the end of every pass and so says nothing about the worker
+	*   that runs them. Held for the worker's whole lifetime — polling delays and retries included — and released as it
+	*   exits, so a wallet started again while it is already synchronizing keeps the worker it has instead of gaining a
+	*   second one that polls alongside it until the wallet stops.
+	*
+	*   The guard asks only whether a worker is running, not what it was started with, so a second start is ignored even
+	*   when it carries different key material. Starting a running wallet on a second key is not a supported way to
+	*   change keys: stop it first. Two workers would be no better — they would apply two keys' updates to one state.
+	*/
+	#backgroundWorkerLock;
+	constructor(scope, context, v2Context) {
+		this.#scope = scope;
+		this.#context = context;
+		this.#v2Context = v2Context;
+		this.#syncLock = require_dist.runSync(require_dist.make$2(false));
+		this.#backgroundWorkerLock = require_dist.runSync(require_dist.make$2(false));
+		this.state = require_dist.fromEffect(context.stateRef.get).pipe(require_dist.flatMap((initialState) => context.stateRef.changes.pipe(require_dist.mapAccum({
+			previous: initialState,
+			isInitial: true
+		}, (seen, current) => [{
+			previous: current,
+			isInitial: false
+		}, [
+			seen.previous,
+			current,
+			seen.isInitial
+		]]))), require_dist.mapConcat(([previous, current, isInitial]) => {
+			return [
+				require_dist.State({ state: current }),
+				...progress$1(current),
+				...protocolVersionChange$1(previous, current, isInitial, context.activationRange)
+			];
+		}));
+	}
+	startSyncInBackground(startAux) {
+		const attempt = this.startSync(startAux).pipe(require_dist.runScoped(require_dist.drain), require_dist.scoped).pipe(require_dist.retry$1(syncRetrySchedule$1));
+		const worker = BackgroundRepeat.$match(this.#v2Context.syncService.backgroundRepeat, {
+			Once: () => attempt,
+			WithDelay: ({ delay }) => require_dist.repeat(attempt, require_dist.spaced(delay)).pipe(require_dist.asVoid)
+		});
+		return require_dist.modify(this.#backgroundWorkerLock, (isRunning) => [!isRunning, true]).pipe(require_dist.flatMap$1((acquired) => acquired ? worker.pipe(require_dist.ensuring$1(require_dist.set(this.#backgroundWorkerLock, false)), require_dist.forkScoped, require_dist.asVoid) : require_dist._void), require_dist.provideService(require_dist.Scope, this.#scope));
+	}
+	sync(startAux) {
+		return this.startSync(startAux).pipe(require_dist.runScoped(require_dist.drain), require_dist.scoped);
+	}
+	startSync(startAux) {
+		return require_dist.pipe(require_dist.modify(this.#syncLock, (isLocked) => [!isLocked, true]), require_dist.fromEffect, require_dist.flatMap((acquired) => {
+			if (!acquired) return require_dist.empty;
+			return require_dist.pipe(require_dist.get(this.#context.stateRef), require_dist.fromEffect, require_dist.flatMap((state) => this.#v2Context.syncService.updates(state, startAux)), require_dist.mapEffect((update) => require_dist.modifyEffect(this.#context.stateRef, (state) => require_dist.try_({
+				try: () => {
+					const [newState, changesResult] = this.#v2Context.syncCapability.applyUpdate(state, update, this.#context.activationRange);
+					return [changesResult, newState];
+				},
+				catch: (err) => new OtherWalletError$1({
+					message: "Error while applying sync update",
+					cause: err
+				})
+			})).pipe(require_dist.flatMap$1(({ changes, protocolVersion }) => changes.length === 0 ? require_dist._void : require_dist.pipe(require_dist.forEach(changes, (change) => require_dist.pipe(this.#txHistoryPermits.withPermits(1)(require_dist.pipe(this.#v2Context.transactionHistoryService.getTransactionDetails(change.source), require_dist.flatMap$1((metadata) => this.#v2Context.transactionHistoryService.put(change, metadata, protocolVersion)))), require_dist.catchAllCause((cause) => require_dist.logError(cause, `Failed to record dust tx-history section for ${change.source}`))), {
+				discard: true,
+				concurrency: 8
+			}), require_dist.forkScoped)), require_dist.provideService(require_dist.Scope, this.#scope))), require_dist.tapError((error$2) => require_dist.error(error$2)), require_dist.ensuring(require_dist.set(this.#syncLock, false)));
+		}));
+	}
+	createDustGenerationTransaction(currentTime, ttl, nightUtxos, nightVerifyingKey, dustReceiverAddress) {
+		if (nightUtxos.some((utxo) => utxo.type !== require_dist.Token.night)) return require_dist.fail$2(new OtherWalletError$1({ message: "Token of a non-Night type received" }));
+		return require_dist.Do.pipe(require_dist.bind("currentState", () => require_dist.get(this.#context.stateRef)), require_dist.bind("blockData", () => this.#v2Context.syncService.blockData()), require_dist.let_("resolvedTime", ({ blockData }) => currentTime ?? blockData.timestamp), require_dist.let_("utxosWithDustValue", ({ currentState, resolvedTime }) => {
+			return this.#v2Context.coinsAndBalancesCapability.estimateDustGeneration(currentState, nightUtxos, resolvedTime);
+		}), require_dist.flatMap$1(({ utxosWithDustValue, resolvedTime }) => {
+			return this.#v2Context.transactingCapability.createDustGenerationTransaction(resolvedTime, ttl, utxosWithDustValue, nightVerifyingKey, dustReceiverAddress).pipe(require_dist.toEffect);
+		}));
+	}
+	splitNightUtxosForDustRegistration(currentTime, nightUtxos, isRegistration) {
+		if (nightUtxos.some((utxo) => utxo.type !== require_dist.Token.night)) return require_dist.fail$2(new OtherWalletError$1({ message: "Token of a non-Night type received" }));
+		return require_dist.gen(this, function* () {
+			const currentState = yield* require_dist.get(this.#context.stateRef);
+			const utxosWithDustValue = this.#v2Context.coinsAndBalancesCapability.estimateDustGeneration(currentState, nightUtxos, currentTime);
+			return this.#v2Context.transactingCapability.splitNightUtxosForDustRegistration(utxosWithDustValue, isRegistration);
+		});
+	}
+	attachDustRegistration(transaction, currentTime, nightVerifyingKey, dustReceiverAddress, feePayment) {
+		return this.#v2Context.transactingCapability.attachDustRegistration(transaction, currentTime, nightVerifyingKey, dustReceiverAddress, feePayment).pipe(require_dist.toEffect);
+	}
+	addDustGenerationSignature(transaction, signature) {
+		return this.#v2Context.transactingCapability.addDustGenerationSignature(transaction, signature).pipe(require_dist.toEffect);
+	}
+	addDustRegistrationSignature(transaction, signature) {
+		return this.#v2Context.transactingCapability.addDustRegistrationSignature(transaction, signature).pipe(require_dist.toEffect);
+	}
+	calculateFee(transactions) {
+		return require_dist.pipe(this.#v2Context.syncService.blockData(), require_dist.map$2((blockData) => require_dist.pipe(transactions, require_dist.map$3((transaction) => this.#v2Context.transactingCapability.calculateFee(transaction, blockData.ledgerParameters)), require_dist.sumBigInt)));
+	}
+	estimateFee(secretKey, transactions, ttl, currentTime) {
+		return require_dist.pipe(require_dist.all([require_dist.get(this.#context.stateRef), this.#v2Context.syncService.blockData()]), require_dist.flatMap$1(([state, blockData]) => require_dist.pipe(this.#v2Context.transactingCapability.estimateFee(secretKey, state, transactions, ttl, currentTime ?? blockData.timestamp, blockData.ledgerParameters), require_dist.toEffect)));
+	}
+	balanceTransactions(secretKey, transactions, ttl, currentTime) {
+		return require_dist.pipe(this.#v2Context.syncService.blockData(), require_dist.flatMap$1((blockData) => require_dist.pipe(require_dist.modifyEffect(this.#context.stateRef, (state) => this.#v2Context.transactingCapability.balanceTransactions(secretKey, state, transactions, ttl, currentTime ?? blockData.timestamp, blockData.ledgerParameters)), require_dist.map$2((transaction) => ({
+			transaction,
+			blockData
+		})))));
+	}
+	revertTransaction(transaction) {
+		return require_dist.updateEffect(this.#context.stateRef, (state) => {
+			return require_dist.pipe(this.#v2Context.transactingCapability.revertTransaction(state, transaction), require_dist.toEffect);
+		});
+	}
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/SingleVariantDustWallet.js
+/**
+* A dust wallet composed from a single variant, which answers for the whole protocol timeline.
+*
+* @remarks
+*   The building block for a composition the package's default does not ship: a variant builder of the caller's own — a
+*   simulator sync in tests, or the projections-based fast sync, which exists on ledger-v9 only and would defeat its
+*   own purpose behind a V1 variant. Its one variant is registered from the minimum supported version, so it stamps
+*   every transaction at that floor and accepts one of any version; the price is that it cannot cross a protocol
+*   boundary. The wallet that can is `DustWallet`, in `DustWallet.ts`.
+*/
+function CustomDustWallet(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);
+	/** 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);
+	/** 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));
+	return class CustomDustWalletImplementation extends BaseWallet {
+		static startWithSeed(seed, dustParameters = _midnightntwrk_ledger_v9.LedgerParameters.initialParameters().dust) {
+			const dustSecretKey = _midnightntwrk_ledger_v9.DustSecretKey.fromSeed(seed);
+			return CustomDustWalletImplementation.startFirst(CustomDustWalletImplementation, CoreWallet$1.initEmpty(dustParameters, dustSecretKey, CustomDustWalletImplementation.configuration.networkId));
+		}
+		static startWithSecretKey(secretKey, dustParameters = _midnightntwrk_ledger_v9.LedgerParameters.initialParameters().dust) {
+			return CustomDustWalletImplementation.startFirst(CustomDustWalletImplementation, CoreWallet$1.initEmpty(dustParameters, secretKey, CustomDustWalletImplementation.configuration.networkId));
+		}
+		static restore(serializedState) {
+			const deserialized = CustomDustWalletImplementation.allVariantsRecord()[V2Tag].variant.deserializeState(serializedState).pipe(require_dist.getOrThrow$1);
+			return CustomDustWalletImplementation.startFirst(CustomDustWalletImplementation, deserialized);
+		}
+		state;
+		/**
+		* The start-aux the wallet was last started with.
+		*
+		* @remarks
+		*   Sync needs the dust secret key, and a migration starts a fresh variant whose sync has never been started. The key
+		*   cannot come from the state — it is deliberately absent from anything serialized — and it does not exist yet
+		*   when the wallet is first constructed, so it is held here, in memory, for the lifetime of the wallet. Cleared by
+		*   {@link stop} so a stopped wallet cannot be silently resurrected by a late activation.
+		*/
+		#retainedAux = require_dist.unsafeMake(require_dist.none());
+		/**
+		* Whether the activation watcher has been registered.
+		*
+		* @remarks
+		*   Registration is per wallet, not per `start`: watchers accumulate, so registering on every call would restart sync
+		*   once per historical `start` on the next activation. Flipped with `getAndSet` so concurrent `start` calls cannot
+		*   both observe it unset.
+		*/
+		#watcherRegistered = require_dist.unsafeMake(false);
+		constructor(runtime, scope) {
+			super(runtime, scope);
+			this.state = this.rawState.pipe(rxjs.map((emission) => DustWalletState.fromVariant(CustomDustWalletImplementation.allVariantsRecord()[V2Tag].variant, emission)), rxjs.shareReplay({
+				refCount: true,
+				bufferSize: 1
+			}));
+		}
+		start(secretKey) {
+			return require_dist.gen(this, function* () {
+				yield* require_dist.set(this.#retainedAux, require_dist.some(secretKey));
+				if (!(yield* require_dist.getAndSet(this.#watcherRegistered, true))) yield* this.runtime.onVariantActivation({ [V2Tag]: (v2) => require_dist.get$1(this.#retainedAux).pipe(require_dist.flatMap$1(require_dist.match$1({
+					onNone: () => require_dist._void,
+					onSome: (retained) => v2.startSyncInBackground(retained)
+				}))) });
+				yield* this.runtime.dispatch({ [V2Tag]: (v2) => v2.startSyncInBackground(secretKey) });
+			}).pipe(require_dist.runPromise$1);
+		}
+		async stop() {
+			require_dist.set(this.#retainedAux, require_dist.none()).pipe(require_dist.runSync);
+			await super.stop();
+		}
+		stepSync(secretKey) {
+			return this.runtime.dispatch({ [V2Tag]: (v2) => v2.sync(secretKey) }).pipe(require_dist.runPromise$1);
+		}
+		/**
+		* The key material this wallet's one variant uses, from what it was started with.
+		*
+		* @remarks
+		*   Fee payment selects dust the wallet owns, so it needs the same secret synchronization does.
+		*/
+		#requireAux() {
+			return require_dist.get$1(this.#retainedAux).pipe(require_dist.flatMap$1(require_dist.match$1({
+				onNone: () => require_dist.fail$2(new require_dist.MissingStartAuxError({
+					message: "This wallet holds no key material: it has not been started, or it has been stopped. Start it before asking it to pay a fee.",
+					variantTag: V2Tag
+				})),
+				onSome: (aux) => require_dist.succeed(aux)
+			})));
+		}
+		async createDustGenerationTransaction(currentTime, ttl, nightUtxos, nightVerifyingKey, dustReceiverAddress) {
+			return this.runtime.dispatch({ [V2Tag]: (v2) => v2.createDustGenerationTransaction(currentTime, ttl, nightUtxos, nightVerifyingKey, dustReceiverAddress).pipe(require_dist.map$2(seal)) }).pipe(require_dist.runPromise$1);
+		}
+		async splitNightUtxosForDustRegistration(currentTime, nightUtxos, isRegistration) {
+			return this.runtime.dispatch({ [V2Tag]: (v2) => v2.splitNightUtxosForDustRegistration(currentTime, nightUtxos, isRegistration) }).pipe(require_dist.runPromise$1);
+		}
+		async attachDustRegistration(transaction, currentTime, nightVerifyingKey, dustReceiverAddress, feePayment) {
+			return this.runtime.dispatch({ [V2Tag]: (v2) => carried(transaction).pipe(require_dist.flatMap$1((tx) => v2.attachDustRegistration(tx, currentTime, nightVerifyingKey, dustReceiverAddress, feePayment)), require_dist.map$2(seal)) }).pipe(require_dist.runPromise$1);
+		}
+		addDustGenerationSignature(transaction, signature) {
+			return this.runtime.dispatch({ [V2Tag]: (v2) => carried(transaction).pipe(require_dist.flatMap$1((tx) => v2.addDustGenerationSignature(tx, signature)), require_dist.map$2(seal)) }).pipe(require_dist.runPromise$1);
+		}
+		addDustRegistrationSignature(transaction, signature) {
+			return this.runtime.dispatch({ [V2Tag]: (v2) => carried(transaction).pipe(require_dist.flatMap$1((tx) => v2.addDustRegistrationSignature(tx, signature)), require_dist.map$2(seal)) }).pipe(require_dist.runPromise$1);
+		}
+		calculateFee(transactions) {
+			return this.runtime.dispatch({ [V2Tag]: (v2) => require_dist.forEach(transactions, carried).pipe(require_dist.flatMap$1((txs) => v2.calculateFee(txs))) }).pipe(require_dist.runPromise$1);
+		}
+		estimateFee(transactions, ttl, currentTime) {
+			const effectiveTtl = ttl ?? new Date(Date.now() + 3600 * 1e3);
+			return this.runtime.dispatch({ [V2Tag]: (v2) => require_dist.all([this.#requireAux(), require_dist.forEach(transactions, carried)]).pipe(require_dist.flatMap$1(([key, txs]) => v2.estimateFee(key, txs, effectiveTtl, currentTime))) }).pipe(require_dist.runPromise$1);
+		}
+		balanceTransactions(transactions, ttl, currentTime) {
+			return this.runtime.dispatch({ [V2Tag]: (v2) => require_dist.all([this.#requireAux(), require_dist.forEach(transactions, carried)]).pipe(require_dist.flatMap$1(([key, txs]) => v2.balanceTransactions(key, txs, ttl, currentTime)), require_dist.map$2(({ transaction, blockData }) => ({
+				transaction: seal(transaction),
+				blockData
+			}))) }).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: (tx) => v2.revertTransaction(tx)
+			}) }).pipe(require_dist.runPromise$1);
+		}
+		waitForSyncedState(allowedGap = 0n) {
+			return rxjs.firstValueFrom(this.state.pipe(rxjs.filter((state) => state.state.progress.isCompleteWithin(allowedGap))));
+		}
+		async waitForGeneratedDust(nightUtxos, requiredAmount, clock, opts) {
+			if (nightUtxos.length === 0) throw Error("At least one Night UTXO is required.");
+			if (requiredAmount <= 0n) return;
+			const timeoutMs = opts?.timeoutMs ?? 3e5;
+			await rxjs.firstValueFrom(rxjs.combineLatest([this.state, rxjs.timer(0, 1e3)]).pipe(rxjs.filter(([dustState]) => claimableFeePayment(dustState, nightUtxos, clock.now()) >= requiredAmount), rxjs.timeout({ first: timeoutMs })));
+		}
+		serializeState() {
+			return rxjs.firstValueFrom(this.state).then((state) => state.serialize());
+		}
+		getAddress() {
+			return rxjs.firstValueFrom(this.state).then((state) => state.address);
+		}
+	};
+}
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/Restore.js
+/**
+* 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-dust-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 dust 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 dust 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 dust wallet snapshots of protocol version ${protocolVersion}.`,
+		protocolVersion
+	}))
+});
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v1/CoreWallet.js
+const PublicKey = { fromSecretKey: (secretKey) => {
+	return { publicKey: secretKey.publicKey };
+} };
+const CoreWallet = {
+	init(localState, secretKey, networkId) {
+		return CoreWallet.empty(localState, PublicKey.fromSecretKey(secretKey), networkId);
+	},
+	initEmpty(dustParameters, secretKey, networkId) {
+		return CoreWallet.empty(new _midnight_ntwrk_ledger_v8.DustLocalState(dustParameters), PublicKey.fromSecretKey(secretKey), networkId);
+	},
+	empty(localState, publicKey, networkId) {
+		return {
+			state: localState,
+			publicKey,
+			networkId,
+			pendingDust: [],
+			progress: require_dist.createSyncProgress(),
+			protocolVersion: require_dist.MinSupportedVersion
+		};
+	},
+	restore(localState, publicKey, pendingTokens, syncProgress, protocolVersion, networkId) {
+		return {
+			state: localState,
+			publicKey,
+			networkId,
+			pendingDust: pendingTokens,
+			progress: require_dist.createSyncProgress(syncProgress),
+			protocolVersion: require_dist.ProtocolVersion(protocolVersion)
+		};
+	},
+	withProtocolVersion(wallet, version) {
+		return version > wallet.protocolVersion ? {
+			...wallet,
+			protocolVersion: version
+		} : wallet;
+	},
+	fromPreviousVersion(previous) {
+		return {
+			state: new _midnight_ntwrk_ledger_v8.DustLocalState(previous.dustParameters),
+			publicKey: previous.publicKey,
+			networkId: previous.networkId,
+			pendingDust: [],
+			progress: require_dist.createSyncProgress({
+				...previous.progress,
+				isConnected: false
+			}),
+			protocolVersion: require_dist.ProtocolVersion(previous.protocolVersion)
+		};
+	},
+	applyEventsWithChanges(wallet, secretKey, events, currentTime) {
+		const stateWithChanges = wallet.state.replayEventsWithChanges(secretKey, events);
+		const updatedState = stateWithChanges.state.processTtls(currentTime);
+		const availableNonces = updatedState.utxos.map((utxo) => utxo.nonce);
+		return [{
+			...wallet,
+			state: updatedState,
+			pendingDust: wallet.pendingDust.filter((t) => availableNonces.includes(t.nonce))
+		}, stateWithChanges.changes];
+	},
+	applyFailed(wallet, tx) {
+		const pendingSpendsMap = CoreWallet.pendingDustToMap(wallet.pendingDust);
+		const [updatedState, removedNullifiers] = require_dist.pipe(require_dist.pipe([...tx.intents?.values() ?? []], require_dist.flatMap$2((intent) => {
+			const spendTime = intent.dustActions?.ctime;
+			return (intent.dustActions?.spends ?? []).map((spend) => ({
+				spend,
+				spendTime
+			}));
+		}), require_dist.filterMap$1(({ spend, spendTime }) => require_dist.pipe(require_dist.fromNullable(pendingSpendsMap.get(spend.oldNullifier)), require_dist.map$5(() => ({
+			spend,
+			spendTime
+		}))))), require_dist.reduce([wallet.state, []], ([state, removed], { spend, spendTime }) => [state.processTtls(require_dist.addSeconds(spendTime, wallet.state.params.dustGracePeriodSeconds)), require_dist.append(removed, spend.oldNullifier)]));
+		return {
+			...wallet,
+			state: updatedState,
+			pendingDust: wallet.pendingDust.filter((coin) => !removedNullifiers.includes(coin.nullifier))
+		};
+	},
+	revertTransaction(wallet, tx) {
+		return CoreWallet.applyFailed(wallet, tx);
+	},
+	updateProgress(wallet, { appliedIndex, highestRelevantWalletIndex, highestIndex, highestRelevantIndex, isConnected }) {
+		const updatedProgress = require_dist.createSyncProgress({
+			appliedIndex: appliedIndex ?? wallet.progress.appliedIndex,
+			highestRelevantWalletIndex: highestRelevantWalletIndex ?? wallet.progress.highestRelevantWalletIndex,
+			highestIndex: highestIndex ?? wallet.progress.highestIndex,
+			highestRelevantIndex: highestRelevantIndex ?? wallet.progress.highestRelevantIndex,
+			isConnected: isConnected ?? wallet.progress.isConnected
+		});
+		return {
+			...wallet,
+			progress: updatedProgress
+		};
+	},
+	spendCoins(wallet, secretKey, coins, currentTime) {
+		const [output, newState, newPending] = require_dist.pipe(coins, require_dist.reduce([
+			[],
+			wallet.state,
+			wallet.pendingDust
+		], ([spends, localState, pending], { token: coinToSpend, value: takeFee }) => {
+			const [newState, dustSpend] = localState.spend(secretKey, coinToSpend, takeFee, currentTime);
+			const newPending = [...pending, {
+				...coinToSpend,
+				nullifier: dustSpend.oldNullifier
+			}];
+			return [
+				require_dist.append(spends, dustSpend),
+				newState,
+				newPending
+			];
+		}));
+		return [output, {
+			...wallet,
+			state: newState,
+			pendingDust: newPending
+		}];
+	},
+	pendingDustToMap(coins) {
+		return new Map(coins.map(({ nullifier, ...coins }) => [nullifier, coins]));
+	}
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v1/Keys.js
+const makeDefaultKeysCapability$1 = () => {
+	return {
+		getPublicKey: (state) => {
+			return state.publicKey.publicKey;
+		},
+		getAddress: (state) => {
+			return new require_dist.DustAddress(state.publicKey.publicKey);
+		}
+	};
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-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 holds no
+*   dust and has 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 pay fees with.
+* @example
+*   ```typescript
+*   const builder = new V1Builder().withDefaults().withMigration(makeEmptyWalletMigration({ networkId, dustParameters }));
+*   ```;
+*
+* @param configuration Supplies the network the scaffold state claims to be on, and the dust parameters it uses.
+* @returns A migration from `null`.
+*/
+const makeEmptyWalletMigration$1 = (configuration) => ({ migrate: () => {
+	const seed = require_dist.fromString("0000000000000000000000000000000000000000000000000000000000000001");
+	return require_dist.succeed(CoreWallet.initEmpty(configuration.dustParameters, _midnight_ntwrk_ledger_v8.DustSecretKey.fromSeed(seed), configuration.networkId));
+} });
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v1/WalletError.js
+var OtherWalletError = class extends require_dist.TaggedError("Wallet.Other") {};
+var SyncWalletError = class extends require_dist.TaggedError("Wallet.Sync") {};
+var TransactingError = class extends require_dist.TaggedError("Wallet.Transacting") {};
+var InsufficientFundsError = class extends require_dist.TaggedError("Wallet.InsufficientFunds") {};
+var TransactionHistoryError = class extends require_dist.TaggedError("Wallet.TransactionHistory") {};
+/**
+* A batch of dust ledger events was not in ascending id order: an event arrived at or below the one before it, or at or
+* below the applied cursor.
+*
+* @remarks
+*   Order is all the wallet can check: dust events share one id sequence with zswap and contract events in the indexer,
+*   so gaps in the stream are normal and a skipped event is only ever caught by the ledger's own insertion check. The
+*   whole batch is refused, nothing is applied and the cursor stays, so the running variant retries from the same
+*   place.
+* @example
+*   ```ts
+*   if (error._tag === 'Wallet.OutOfOrderSyncUpdate') console.warn(`expected above ${error.expected}, got ${error.received}`);
+*   ```
+*/
+var OutOfOrderSyncUpdateError = class extends require_dist.TaggedError("Wallet.OutOfOrderSyncUpdate") {};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v1/Serialization.js
+const StateSchema = require_dist.declare((input) => input instanceof _midnight_ntwrk_ledger_v8.DustLocalState).annotations({ identifier: "ledger.DustLocalState" });
+const Uint8ArraySchema = require_dist.declare((input) => input instanceof Uint8Array).annotations({ identifier: "Uint8Array" });
+const StateFromUInt8Array = require_dist.asSchema(require_dist.transformOrFail(Uint8ArraySchema, StateSchema, {
+	encode: (state) => {
+		return require_dist.try_({
+			try: () => {
+				return state.serialize();
+			},
+			catch: (err) => {
+				return new require_dist.Unexpected(err, "Could not serialize local state");
+			}
+		});
+	},
+	decode: (bytes) => require_dist.try_({
+		try: () => _midnight_ntwrk_ledger_v8.DustLocalState.deserialize(bytes),
+		catch: (err) => {
+			return new require_dist.Unexpected(err, "Could not deserialize local state");
+		}
+	})
+}));
+const HexedState = require_dist.pipe(require_dist.Uint8ArrayFromHex, require_dist.compose(StateFromUInt8Array));
+const SnapshotSchema = require_dist.Struct({
+	publicKey: require_dist.Struct({ publicKey: require_dist.BigInt$ }),
+	state: HexedState,
+	protocolVersion: require_dist.BigInt$,
+	networkId: require_dist.String$,
+	offset: require_dist.optional(require_dist.BigInt$)
+});
+const makeDefaultV1SerializationCapability = () => {
+	return {
+		serialize: (wallet) => {
+			const buildSnapshot = (w) => ({
+				publicKey: w.publicKey,
+				state: w.state,
+				protocolVersion: w.protocolVersion,
+				networkId: w.networkId,
+				offset: w.progress?.appliedIndex
+			});
+			return require_dist.pipe(wallet, buildSnapshot, require_dist.encodeSync(SnapshotSchema), JSON.stringify);
+		},
+		deserialize: (aux, serialized) => {
+			return require_dist.pipe(serialized, require_dist.decodeUnknownEither(require_dist.parseJson(SnapshotSchema)), require_dist.mapLeft((err) => new OtherWalletError({
+				message: "Error while deserializing snapshot",
+				cause: err
+			})), require_dist.flatMap$4((snapshot) => require_dist.try_$1({
+				try: () => CoreWallet.restore(snapshot.state, snapshot.publicKey, [], {
+					appliedIndex: snapshot.offset ?? 0n,
+					highestRelevantWalletIndex: 0n,
+					highestIndex: 0n,
+					highestRelevantIndex: 0n
+				}, snapshot.protocolVersion, snapshot.networkId),
+				catch: (err) => new OtherWalletError({
+					message: "Error while restoring core wallet",
+					cause: err
+				})
+			})));
+		}
+	};
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v1/Sync.js
+/**
+* Constructors and matchers for {@link BackgroundRepeat}.
+*
+* @example
+*   ```ts
+*   const service: SyncService<CoreWallet, DustSecretKey, WalletSyncUpdate> = {
+*     backgroundRepeat: BackgroundRepeat.Once(),
+*     updates: (state, secretKey) => subscribe(state, secretKey),
+*     blockData: () => latestBlock(),
+*   };
+*   ```;
+*/
+const BackgroundRepeat$1 = require_dist.taggedEnum();
+/**
+* The ledger parameters codecs this variant reads blocks with, unless it is told otherwise.
+*
+* @remarks
+*   Open-ended from the minimum supported version, so a wallet whose variant has not been given a narrower range keeps
+*   reading every block exactly as it did before this became routable. A two-variant dust wallet replaces this with a
+*   registry bounded by the range its variant is active over, and then a block from the other side of the boundary is
+*   refused by name instead of being deserialized.
+*/
+const defaultLedgerParametersCodecs = require_dist.getOrThrow$1(require_dist.makeCodecs([{
+	sinceVersion: require_dist.MinSupportedVersion,
+	codec: require_dist.fromDeserializer((bytes) => _midnight_ntwrk_ledger_v8.LedgerParameters.deserialize(bytes))
+}]));
+/**
+* Splits a batch of version-tagged items at the end of a variant's activation range.
+*
+* @remarks
+*   The split is positional, not a filter: everything from the first out-of-range item onwards is deferred, even if a
+*   later item reports an in-range version again. A batch is a contiguous slice of one timeline, so applying past a
+*   boundary and then resuming behind it would leave a hole no cursor can describe.
+*
+*   An item whose version is `undefined` is treated as in-range and contributes no annotation: an absent value means "the
+*   indexer did not say", which must keep the un-versioned behaviour exactly, rather than being read as version zero
+*   and dragging the recorded version down.
+*
+*   This is the one place the boundary rule lives; the indexer capability (per event) and the simulator capability (per
+*   block) both go through it, so they cannot drift apart.
+* @param items The batch, in source order.
+* @param versionOf Reads the protocol version an item was reported at, or `undefined` if it carries none.
+* @param activeRange The variant's half-open activation range.
+* @returns The applied/deferred split and the version to record.
+*/
+const splitAtVersionBoundary$1 = (items, versionOf, activeRange) => {
+	const [, end] = activeRange;
+	const boundary = items.findIndex((item) => {
+		const version = versionOf(item);
+		return version !== void 0 && BigInt(version) >= end;
+	});
+	const [applied, deferred] = boundary < 0 ? [items, []] : [items.slice(0, boundary), items.slice(boundary)];
+	const signalling = deferred.at(0) ?? [...applied].reverse().find((item) => versionOf(item) !== void 0);
+	const signalledVersion = signalling === void 0 ? void 0 : versionOf(signalling);
+	return {
+		applied,
+		deferred,
+		observedVersion: signalledVersion === void 0 ? require_dist.none() : require_dist.some(require_dist.ProtocolVersion(BigInt(signalledVersion)))
+	};
+};
+/** Records a batch's observed protocol version on the state, monotonically. A batch that observed none is a no-op. */
+const annotateVersion$1 = (state, observedVersion) => require_dist.match$1(observedVersion, {
+	onNone: () => state,
+	onSome: (version) => CoreWallet.withProtocolVersion(state, version)
+});
+const LedgerEventSchema = require_dist.declare((input) => input instanceof _midnight_ntwrk_ledger_v8.Event).annotations({ identifier: "ledger.Event" });
+const LedgerEventFromUInt8Array = require_dist.asSchema(require_dist.transformOrFail(Uint8ArraySchema, LedgerEventSchema, {
+	encode: (e) => require_dist.try_({
+		try: () => e.serialize(),
+		catch: (err) => new require_dist.Unexpected(err, "Could not serialize Ledger Event")
+	}),
+	decode: (bytes) => require_dist.try_({
+		try: () => _midnight_ntwrk_ledger_v8.Event.deserialize(bytes),
+		catch: (err) => new require_dist.Unexpected(err, "Could not deserialize Ledger Event")
+	})
+}));
+const HexedEvent = require_dist.pipe(require_dist.Uint8ArrayFromHex, require_dist.compose(LedgerEventFromUInt8Array));
+const SyncEventsUpdateSchema = require_dist.Struct({
+	id: require_dist.Number$,
+	raw: require_dist.String$,
+	maxId: require_dist.Number$,
+	protocolVersion: require_dist.optional(require_dist.Number$)
+});
+/**
+* Reads an event this variant is going to apply.
+*
+* @remarks
+*   The counterpart of {@link SyncEventsUpdateSchema} carrying its event encoded: a capability calls this on the batch
+*   prefix it owns, and never on what it defers. Failure here is a genuine one — an event this variant claimed and
+*   cannot read — and is raised rather than returned, because `SyncCapability.applyUpdate` is total in its own domain
+*   and the variant already turns a throw from it into a typed synchronization error.
+* @param event The event-carrying item to read.
+* @returns The event it carries.
+* @throws ParseError if the bytes are not an event this ledger version can deserialize.
+*/
+const readEvent = (event) => require_dist.decodeSync(HexedEvent)(event.raw);
+const VersionSignalSyncUpdate = { create: (version, highestEventId) => {
+	return {
+		_tag: "VersionSignal",
+		version,
+		highestEventId
+	};
+} };
+const WalletSyncUpdate = { create: (updates, secretKey, timestamp) => {
+	return {
+		_tag: "Events",
+		updates,
+		secretKey,
+		timestamp
+	};
+} };
+/** How often the chain is asked its version when the configuration does not say. */
+const DEFAULT_VERSION_WATCH_INTERVAL_MS = 3e4;
+/**
+* How long one event-id probe is given to produce its single answer.
+*
+* @remarks
+*   Both a stall guard and, on a chain with no dust history at all, the ordinary way the tick ends. A wallet with a
+*   cursor subscribes at an event that provably exists, so there the answer arrives at once or the transport is broken;
+*   a wallet on a chain that has never produced a dust event subscribes to a timeline the indexer will keep open and
+*   never write to. Without a bound, either would leave the poll loop parked on a tick that never completes and the
+*   wallet would stop asking altogether. A bound turns both into a skipped tick.
+*/
+const EVENT_TIP_PROBE_TIMEOUT = require_dist.seconds(10);
+/**
+* Asks the source how far its dust event timeline goes.
+*
+* @remarks
+*   Over the event subscription rather than a query, because the schema has no query that reaches a dust ledger event:
+*   `block`/`transactions` reach one only through a block that happens to contain dust events, which on a quiet chain
+*   is precisely the block that does not. `maxId` is a property of the whole dust timeline — the indexer computes it as
+*   the maximum id within the dust grouping — so any single event answers it: the first one delivered is taken and the
+*   subscription closed.
+*
+*   The cursor is the wallet's own. The event it last applied provably exists, so the source answers immediately and has
+*   the least backfill to abandon; a wallet that has applied nothing asks from the start, where the first event is —
+*   or, on a chain with no dust event at all, where nothing is, and the tick times out into silence.
+* @param config The sync configuration, carrying the keep-alive the source's subscriptions use.
+* @param resumeFrom The wallet's cursor; below zero means "from the very start".
+* @returns The highest dust event id, or nothing if the source did not answer.
+*/
+const highestEventId = (config, resumeFrom) => require_dist.pipe(require_dist.DustLedgerEventTip.run({ id: resumeFrom < 0n ? null : Number(resumeFrom) }), require_dist.runHead, require_dist.map$2(require_dist.map$5((answer) => answer.dustLedgerEvents.maxId)), require_dist.scoped, require_dist.timeout(EVENT_TIP_PROBE_TIMEOUT));
+/**
+* One check of the chain's protocol version, gated on the wallet being caught up on the source's dust event ids.
+*
+* @remarks
+*   The order of the two questions is load-bearing. The tip is read **first**: a tip reported at a version means the
+*   source has indexed through the block that carries it, so every event below it is already counted in the `maxId`
+*   read afterwards. Asked the other way round, an event indexed between the two answers could be one of the version
+*   that preceded the tip — unread, uncounted, and exactly what the gate exists to catch.
+*
+*   The one short-circuit is an answer rather than a shortcut: a tip at or below the version the wallet already held is a
+*   signal that could only be a no-op, so no probe is opened and nothing is emitted — which is what keeps a settled
+*   wallet from polling a subscription for the rest of its life. There is deliberately no second short-circuit for a
+*   chain that provably holds no dust event, because no such proof is available from the tip; see
+*   {@link VersionSignalSyncUpdate}.
+*
+*   Everything else is swallowed. A tick that fails says nothing about the chain, so it must neither reach the state nor
+*   take the sync stream down with it; the next tick is the retry, and costs nothing to wait for.
+* @param config The sync configuration, for the indexer to ask.
+* @param resumeFrom The wallet's cursor, for the probe.
+* @param knownVersion The version the wallet already held when this stream opened — a lower bound on what it holds now.
+* @returns The signal, or nothing when there is nothing to say or nobody said it.
+*/
+const readVersionSignal = (config, resumeFrom, knownVersion) => require_dist.pipe(require_dist.BlockHash.run({ offset: null }), require_dist.provide(require_dist.layer$1({ url: config.indexerClientConnection.indexerHttpUrl })), require_dist.scoped, require_dist.flatMap$1((answer) => require_dist.match$1(require_dist.fromNullable(answer.block), {
+	onNone: () => require_dist.succeedNone,
+	onSome: (tip) => BigInt(tip.protocolVersion) <= knownVersion ? require_dist.succeedNone : require_dist.pipe(highestEventId(config, resumeFrom), require_dist.map$2(require_dist.map$5((maxId) => VersionSignalSyncUpdate.create(tip.protocolVersion, maxId))))
+})), require_dist.catchAll(() => require_dist.succeedNone));
+/**
+* The chain's version, re-asked on a timer for as long as sync runs.
+*
+* @remarks
+*   Deliberately silent about ticks that say nothing: a tick that finds the chain where the wallet left it, or that
+*   cannot reach the chain at all, emits no element rather than an empty one, so nothing downstream has to know that
+*   polling is how the answer was arrived at.
+* @param config The sync configuration, carrying the interval.
+* @param resumeFrom The wallet's cursor, for the probe.
+* @param knownVersion The version the wallet held when this stream opened.
+* @returns The signals, or an empty stream when watching is turned off.
+*/
+const versionWatch = (config, resumeFrom, knownVersion) => {
+	const intervalMs = config.versionWatch?.intervalMs ?? DEFAULT_VERSION_WATCH_INTERVAL_MS;
+	return intervalMs <= 0 ? require_dist.empty : require_dist.pipe(require_dist.fromSchedule(require_dist.spaced(require_dist.millis(intervalMs))), require_dist.mapEffect(() => readVersionSignal(config, resumeFrom, knownVersion)), require_dist.filterMap(require_dist.identity));
+};
+const makeDefaultSyncService$1 = (config) => {
+	const indexerSyncService = makeIndexerSyncService$1(config);
+	return {
+		backgroundRepeat: BackgroundRepeat$1.Once(),
+		updates: (state, secretKey) => {
+			const batchSize = config.batchUpdates?.size ?? 10;
+			const batchTimeout = require_dist.millis(config.batchUpdates?.timeout ?? 1);
+			const batchSpacing = config.batchUpdates?.spacing ?? 4;
+			const timeline = require_dist.pipe(indexerSyncService.subscribeWallet(state), require_dist.groupedWithin(batchSize, batchTimeout), require_dist.map(require_dist.toArray), require_dist.map((data) => WalletSyncUpdate.create(data, secretKey, /* @__PURE__ */ new Date())), batchSpacing > 0 ? require_dist.schedule(require_dist.spaced(require_dist.millis(batchSpacing))) : (eventsStream) => eventsStream);
+			const resumeFrom = state.progress.appliedIndex - 1n;
+			return require_dist.pipe(require_dist.merge(timeline, versionWatch(config, resumeFrom, state.protocolVersion), { haltStrategy: "left" }), require_dist.provideSomeLayer(indexerSyncService.connectionLayer()));
+		},
+		blockData: () => {
+			return require_dist.gen(function* () {
+				return (yield* (yield* require_dist.BlockHash)({ offset: null })).block;
+			}).pipe(require_dist.provide(indexerSyncService.queryClient()), require_dist.scoped, require_dist.catchAll((err) => require_dist.fail$2(new OtherWalletError({
+				message: `Encountered unexpected error: ${err.message}`,
+				cause: err
+			}))), require_dist.flatMap$1((blockData) => {
+				if (!blockData) return require_dist.fail$2(new OtherWalletError({ message: "Unable to fetch block data" }));
+				return require_dist.pipe(require_dist.decode(config.ledgerParametersCodecs ?? defaultLedgerParametersCodecs, require_dist.ProtocolVersion(BigInt(blockData.protocolVersion)), blockData.ledgerParameters), require_dist.map$6((ledgerParameters) => ({
+					hash: blockData.hash,
+					height: blockData.height,
+					protocolVersion: blockData.protocolVersion,
+					ledgerParameters,
+					timestamp: new Date(blockData.timestamp)
+				})), require_dist.mapLeft((error) => new SyncWalletError({
+					message: error.message,
+					cause: error
+				})), require_dist.toEffect);
+			}));
+		}
+	};
+};
+const makeIndexerSyncService$1 = (config) => {
+	return {
+		queryClient() {
+			return require_dist.pipe(require_dist.layer$1({ url: config.indexerClientConnection.indexerHttpUrl }), require_dist.mapError$1((error) => new OtherWalletError(error)));
+		},
+		connectionLayer() {
+			const { indexerClientConnection } = config;
+			return require_dist.createWebSocketUrl(indexerClientConnection.indexerHttpUrl, indexerClientConnection.indexerWsUrl).pipe(require_dist.flatMap$4((url) => require_dist.make(url)), require_dist.match$2({
+				onLeft: (error) => require_dist.fail$1(error),
+				onRight: (url) => require_dist.layer({
+					url,
+					keepAlive: indexerClientConnection.keepAlive
+				})
+			}), require_dist.mapError$1((e) => new SyncWalletError({
+				message: "Failed to obtain correct indexer URLs",
+				cause: e
+			})));
+		},
+		subscribeWallet(state) {
+			const { appliedIndex } = state.progress;
+			const bufferSize = config.indexerClientConnection.bufferSize ?? 1e4;
+			const resumeThreshold = config.indexerClientConnection.resumeThreshold ?? 100;
+			const resumeFrom = appliedIndex - 1n;
+			return require_dist.pipe(require_dist.DustLedgerEvents.runWithBackpressure({
+				bufferSize,
+				resumeThreshold,
+				from: resumeFrom,
+				variables: (cursor) => ({ id: cursor < 0n ? null : Number(cursor) }),
+				key: (r) => BigInt(r.dustLedgerEvents.id)
+			}), require_dist.mapEffect((subscription) => require_dist.pipe(require_dist.decodeUnknownEither(SyncEventsUpdateSchema)(subscription.dustLedgerEvents), require_dist.mapLeft((err) => new SyncWalletError(err)), require_dist.toEffect)), require_dist.mapError((error) => new SyncWalletError(error)));
+		}
+	};
+};
+/** The result of an update that observed nothing of the chain. */
+const noChanges = (state) => ({
+	changes: [],
+	protocolVersion: Number(state.protocolVersion)
+});
+/**
+* Folds what the chain said about its own version into the wallet state.
+*
+* @remarks
+*   The same recording the event path makes through {@link annotateVersion}, and nothing else: no cursor moves, no dust
+*   changes hands, no tree grows. 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: unread events below
+*   the source's tip mean the hand-over would park the cursor in front of history the next variant cannot read — and
+*   those events carry the version themselves, so nothing is lost by waiting for them. That is not an error: the next
+*   tick asks again.
+*
+*   A version at or below the one already recorded needs no guard of its own — {@link annotateVersion} never goes
+*   backwards — so a source briefly answering from a lagging replica cannot drag a wallet back over a boundary.
+* @param state The wallet to record on.
+* @param update What the chain said, and how far its dust event timeline goes.
+* @returns The wallet, annotated or untouched, and an empty result.
+*/
+const applyVersionSignal = (state, update) => [BigInt(update.highestEventId) > state.progress.appliedIndex ? state : annotateVersion$1(state, require_dist.some(require_dist.ProtocolVersion(BigInt(update.version)))), noChanges(state)];
+/**
+* Checks that freshly delivered events arrive in strictly ascending id order.
+*
+* @remarks
+*   Order is all that can be checked, never contiguity: dust events share one id sequence with zswap and contract events
+*   in the indexer, so gaps in a dust stream are normal. A skipped commitment-inserting event is caught by the ledger's
+*   own insertion check instead. An empty batch is trivially ordered.
+* @param fresh The events left after the cursor filter, in source order.
+* @param appliedIndex The highest event id already applied; the first fresh id must exceed it.
+* @returns The batch unchanged, or the first id that fails to exceed its predecessor as an
+*   {@link OutOfOrderSyncUpdateError}.
+*/
+const expectAscending = (fresh, appliedIndex) => require_dist.pipe(require_dist.zipWith(fresh, require_dist.prepend(require_dist.map$3(fresh, (item) => BigInt(item.id)), appliedIndex), (item, previous) => ({
+	item,
+	previous
+})), require_dist.findFirst(({ item, previous }) => BigInt(item.id) <= previous), require_dist.match$1({
+	onNone: () => require_dist.right(fresh),
+	onSome: ({ item, previous }) => require_dist.left(new OutOfOrderSyncUpdateError({
+		message: `Dust event ${item.id} delivered at or below its predecessor ${previous}; batch refused, applied index stays at ${appliedIndex}`,
+		expected: previous,
+		received: BigInt(item.id)
+	}))
+}));
+const makeDefaultSyncCapability$1 = () => {
+	return { applyUpdate(state, wrappedUpdate, activeRange) {
+		if (wrappedUpdate._tag === "VersionSignal") return applyVersionSignal(state, wrappedUpdate);
+		const { updates, secretKey } = wrappedUpdate;
+		if (updates.length === 0) return [state, {
+			changes: [],
+			protocolVersion: Number(state.protocolVersion)
+		}];
+		const appliedIndex = state.progress.appliedIndex;
+		const freshUpdates = updates.filter((u) => BigInt(u.id) > appliedIndex);
+		const highestRelevantWalletIndex = BigInt(updates.at(-1).maxId);
+		const { applied, observedVersion } = splitAtVersionBoundary$1(require_dist.getOrThrowWith(expectAscending(freshUpdates, appliedIndex), require_dist.identity), (update) => update.protocolVersion, activeRange);
+		const [newState, changes] = applied.length === 0 ? [state, []] : CoreWallet.applyEventsWithChanges(state, secretKey, applied.map(readEvent), wrappedUpdate.timestamp);
+		return [CoreWallet.updateProgress(annotateVersion$1(newState, observedVersion), {
+			appliedIndex: applied.length === 0 ? appliedIndex : BigInt(applied.at(-1).id),
+			highestRelevantWalletIndex,
+			isConnected: true
+		}), {
+			changes,
+			protocolVersion: [...applied].reverse().find((u) => u.protocolVersion !== void 0)?.protocolVersion ?? Number(state.protocolVersion)
+		}];
+	} };
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v1/Utils.js
+const SignatureMarker = {
+	signature: "signature",
+	signatureErased: "signature-erased"
+};
+const ProofMarker = {
+	proof: "proof",
+	preProof: "pre-proof",
+	noProof: "no-proof"
+};
+const BindingMarker = {
+	binding: "binding",
+	preBinding: "pre-binding",
+	noBinding: "no-binding"
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v1/Transacting.js
+const makeDefaultTransactingCapability$1 = (config, getContext) => {
+	return new TransactingCapabilityImplementation$1(config.networkId, config.costParameters, () => getContext().coinSelection, () => getContext().coinsAndBalancesCapability, () => getContext().keysCapability);
+};
+/**
+* Distributes the fee across multiple inputs, draining smaller inputs first when the fee exceeds any single input's
+* value. Finds the next available intent segment id in a transaction.
+*
+* Fallible intent segments occupy the range `[1, 65535]`; segment `0` is reserved for the guaranteed section and is
+* never returned.
+*
+* @param transaction - Transaction whose intent map is inspected.
+* @returns `Some(segmentId)` with the lowest unused id, or `None` if all 65535 fallible segments are taken.
+*/
+const findAvailableSegmentId$1 = (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)));
+};
+/**
+* Distributes the fee across multiple inputs, draining smaller inputs first when the fee exceeds any single input's
+* value.
+*/
+const distributeFeeAcrossInputs$1 = (inputs, fee) => inputs.reduce(({ result, remaining }, input) => {
+	const deduction = remaining >= input.value ? input.value : remaining;
+	return {
+		result: [...result, {
+			...input,
+			value: deduction
+		}],
+		remaining: remaining - deduction
+	};
+}, {
+	result: [],
+	remaining: fee
+}).result;
+var TransactingCapabilityImplementation$1 = class TransactingCapabilityImplementation$1 {
+	networkId;
+	costParams;
+	getCoinSelection;
+	getCoins;
+	getKeys;
+	constructor(networkId, costParams, getCoinSelection, getCoins, getKeys) {
+		this.getCoins = getCoins;
+		this.networkId = networkId;
+		this.costParams = costParams;
+		this.getCoinSelection = getCoinSelection;
+		this.getKeys = getKeys;
+	}
+	createDustGenerationTransaction(currentTime, ttl, nightUtxos, nightVerifyingKey, dustReceiverAddress) {
+		const makeOffer = (utxos) => {
+			if (utxos.length === 0) return require_dist.none();
+			const totalValue = require_dist.pipe(utxos, require_dist.map$4((coin) => coin.utxo.value), require_dist.sumAll);
+			const inputs = utxos.map(({ utxo }) => ({
+				...utxo,
+				owner: nightVerifyingKey
+			}));
+			const output = {
+				owner: (0, _midnight_ntwrk_ledger_v8.addressFromKey)(nightVerifyingKey),
+				type: require_dist.Token.night,
+				value: totalValue
+			};
+			return require_dist.some(_midnight_ntwrk_ledger_v8.UnshieldedOffer.new(inputs, [output], []));
+		};
+		return require_dist.gen$1(this, function* () {
+			const receiver = dustReceiverAddress ? dustReceiverAddress.data : void 0;
+			return yield* require_dist.ledgerTry(() => {
+				const network = this.networkId;
+				const splitResult = this.getCoins().splitNightUtxos(nightUtxos);
+				const feePayment = receiver ? require_dist.pipe(splitResult.guaranteed, require_dist.filter$2((coin) => !coin.utxo.registeredForDustGeneration), require_dist.map$4((coin) => coin.dust.generatedNow), require_dist.sumAll) : 0n;
+				const maybeGuaranteedOffer = makeOffer(splitResult.guaranteed);
+				const maybeFallibleOffer = makeOffer(splitResult.fallible);
+				const dustRegistration = new _midnight_ntwrk_ledger_v8.DustRegistration(SignatureMarker.signature, nightVerifyingKey, receiver, feePayment);
+				const dustActions = new _midnight_ntwrk_ledger_v8.DustActions(SignatureMarker.signature, ProofMarker.preProof, currentTime, [], [dustRegistration]);
+				const intent = require_dist.pipe(_midnight_ntwrk_ledger_v8.Intent.new(ttl), (intent) => require_dist.match$1(maybeGuaranteedOffer, {
+					onNone: () => intent,
+					onSome: (guaranteedOffer) => {
+						intent.guaranteedUnshieldedOffer = guaranteedOffer;
+						return intent;
+					}
+				}), (intent) => require_dist.match$1(maybeFallibleOffer, {
+					onNone: () => intent,
+					onSome: (fallibleOffer) => {
+						intent.fallibleUnshieldedOffer = fallibleOffer;
+						return intent;
+					}
+				}), (intent) => {
+					intent.dustActions = dustActions;
+					return intent;
+				});
+				return _midnight_ntwrk_ledger_v8.Transaction.fromParts(network, void 0, void 0, intent);
+			});
+		});
+	}
+	splitNightUtxosForDustRegistration(utxosWithDustValue, isRegistration) {
+		const splitResult = this.getCoins().splitNightUtxos(utxosWithDustValue);
+		const feePayment = isRegistration ? require_dist.pipe(splitResult.guaranteed, require_dist.filter$2((coin) => !coin.utxo.registeredForDustGeneration), require_dist.map$4((coin) => coin.dust.generatedNow), require_dist.sumAll) : 0n;
+		return {
+			guaranteedUtxos: splitResult.guaranteed,
+			fallibleUtxos: splitResult.fallible,
+			feePayment
+		};
+	}
+	attachDustRegistration(transaction, currentTime, nightVerifyingKey, dustReceiverAddress, feePayment) {
+		return require_dist.gen$1(this, function* () {
+			const intent = transaction.intents?.get(1);
+			if (!intent) return yield* require_dist.left(new TransactingError({ message: "No intent found at segment 1; expected an intent built by rotateUtxos" }));
+			if (intent.dustActions !== void 0 && intent.dustActions.registrations.length > 0) return yield* require_dist.left(new TransactingError({ message: "Intent at segment 1 already has a dust registration attached" }));
+			return yield* require_dist.ledgerTry(() => {
+				const receiver = dustReceiverAddress ? dustReceiverAddress.data : void 0;
+				const dustRegistration = new _midnight_ntwrk_ledger_v8.DustRegistration(SignatureMarker.signature, nightVerifyingKey, receiver, feePayment);
+				const dustActions = new _midnight_ntwrk_ledger_v8.DustActions(SignatureMarker.signature, ProofMarker.preProof, currentTime, [], [dustRegistration]);
+				const newIntent = _midnight_ntwrk_ledger_v8.Intent.deserialize(SignatureMarker.signature, ProofMarker.preProof, BindingMarker.preBinding, intent.serialize());
+				newIntent.dustActions = dustActions;
+				const newTransaction = _midnight_ntwrk_ledger_v8.Transaction.deserialize(SignatureMarker.signature, ProofMarker.preProof, BindingMarker.preBinding, transaction.serialize());
+				newTransaction.intents = newTransaction.intents.set(1, newIntent);
+				return newTransaction;
+			});
+		});
+	}
+	addDustRegistrationSignature(transaction, signatureData) {
+		return require_dist.gen$1(this, function* () {
+			const intent = transaction.intents?.get(1);
+			if (!intent) return yield* require_dist.left(new TransactingError({ message: "No intent found in the transaction intents with segment = 1" }));
+			const { dustActions } = intent;
+			if (!dustActions) return yield* require_dist.left(new TransactingError({ message: "No dustActions found in intent" }));
+			const [registration, ...restRegistrations] = dustActions.registrations;
+			if (!registration) return yield* require_dist.left(new TransactingError({ message: "No registrations found in dustActions" }));
+			return yield* require_dist.ledgerTry(() => {
+				const signature = new _midnight_ntwrk_ledger_v8.SignatureEnabled(signatureData);
+				const registrationWithSignature = new _midnight_ntwrk_ledger_v8.DustRegistration(signature.instance, registration.nightKey, registration.dustAddress, registration.allowFeePayment, signature);
+				const newDustActions = new _midnight_ntwrk_ledger_v8.DustActions(signature.instance, ProofMarker.preProof, dustActions.ctime, dustActions.spends, [registrationWithSignature, ...restRegistrations]);
+				const newIntent = _midnight_ntwrk_ledger_v8.Intent.deserialize(signature.instance, ProofMarker.preProof, BindingMarker.preBinding, intent.serialize());
+				newIntent.dustActions = newDustActions;
+				const newTransaction = _midnight_ntwrk_ledger_v8.Transaction.deserialize(signature.instance, ProofMarker.preProof, BindingMarker.preBinding, transaction.serialize());
+				newTransaction.intents = newTransaction.intents.set(1, newIntent);
+				return newTransaction;
+			});
+		});
+	}
+	addDustGenerationSignature(transaction, signatureData) {
+		return require_dist.gen$1(this, function* () {
+			const intent = transaction.intents?.get(1);
+			if (!intent) return yield* require_dist.left(new TransactingError({ message: "No intent found in the transaction intents with segment = 1" }));
+			const { dustActions, guaranteedUnshieldedOffer, fallibleUnshieldedOffer } = intent;
+			if (!dustActions) return yield* require_dist.left(new TransactingError({ message: "No dustActions found in intent" }));
+			if (!guaranteedUnshieldedOffer) return yield* require_dist.left(new TransactingError({ message: "No guaranteedUnshieldedOffer found in intent" }));
+			const [registration, ...restRegistrations] = dustActions.registrations;
+			if (!registration) return yield* require_dist.left(new TransactingError({ message: "No registrations found in dustActions" }));
+			return yield* require_dist.ledgerTry(() => {
+				const signature = new _midnight_ntwrk_ledger_v8.SignatureEnabled(signatureData);
+				const registrationWithSignature = new _midnight_ntwrk_ledger_v8.DustRegistration(signature.instance, registration.nightKey, registration.dustAddress, registration.allowFeePayment, signature);
+				const newDustActions = new _midnight_ntwrk_ledger_v8.DustActions(signature.instance, ProofMarker.preProof, dustActions.ctime, dustActions.spends, [registrationWithSignature, ...restRegistrations]);
+				const newIntent = _midnight_ntwrk_ledger_v8.Intent.deserialize(signature.instance, ProofMarker.preProof, BindingMarker.preBinding, intent.serialize());
+				newIntent.dustActions = newDustActions;
+				const guaranteedSignatures = Array.from({ length: guaranteedUnshieldedOffer.inputs.length }, (_, i) => guaranteedUnshieldedOffer.signatures.at(i) ?? signatureData);
+				newIntent.guaranteedUnshieldedOffer = guaranteedUnshieldedOffer.addSignatures(guaranteedSignatures);
+				if (fallibleUnshieldedOffer) {
+					const fallibleSignatures = Array.from({ length: fallibleUnshieldedOffer.inputs.length }, (_, i) => fallibleUnshieldedOffer.signatures.at(i) ?? signatureData);
+					newIntent.fallibleUnshieldedOffer = fallibleUnshieldedOffer.addSignatures(fallibleSignatures);
+				}
+				const newTransaction = _midnight_ntwrk_ledger_v8.Transaction.deserialize(signature.instance, ProofMarker.preProof, BindingMarker.preBinding, transaction.serialize());
+				newTransaction.intents = newTransaction.intents.set(1, newIntent);
+				return newTransaction;
+			});
+		});
+	}
+	calculateFee(transaction, ledgerParams) {
+		return transaction.feesWithMargin(ledgerParams, this.costParams.feeBlocksMargin) + (this.costParams.additionalFeeOverhead ?? 0n);
+	}
+	dryRunFee(recipeInputs, transactions, secretKey, state, ttl, currentTime, ledgerParams) {
+		const network = this.networkId;
+		const [spends] = CoreWallet.spendCoins(state, secretKey, recipeInputs, currentTime);
+		const intent = _midnight_ntwrk_ledger_v8.Intent.new(ttl);
+		intent.dustActions = new _midnight_ntwrk_ledger_v8.DustActions(SignatureMarker.signature, ProofMarker.preProof, currentTime, [...spends], []);
+		const [first, ...rest] = transactions.map((tx) => tx.eraseProofs());
+		const mergedExisting = first ? rest.reduce((acc, tx) => acc.merge(tx), first) : void 0;
+		const segmentId = mergedExisting ? require_dist.getOrElse(findAvailableSegmentId$1(mergedExisting), () => 1) : 1;
+		const erasedBalancing = _midnight_ntwrk_ledger_v8.Transaction.fromParts(network).addIntent({
+			tag: "specific",
+			value: segmentId
+		}, intent).eraseProofs();
+		const mergedTx = mergedExisting ? mergedExisting.merge(erasedBalancing) : erasedBalancing;
+		return this.calculateFee(mergedTx, ledgerParams);
+	}
+	static feeImbalance(transaction, totalFee) {
+		const [_, imbalance] = transaction.imbalances(0, totalFee).entries().find(([tt, _]) => tt.tag === "dust") ?? [];
+		return imbalance ?? 0n;
+	}
+	computeBalancingRecipe(secretKey, state, transactions, ttl, currentTime, ledgerParams) {
+		const initialFees = transactions.reduce((total, transaction) => total + TransactingCapabilityImplementation$1.feeImbalance(transaction, this.calculateFee(transaction, ledgerParams)), 0n);
+		const dust = this.getCoins().getAvailableCoinsWithGeneratedDust(state, currentTime);
+		return require_dist.pipe(require_dist.iterate({
+			currentFee: initialFees,
+			recipeInputs: [],
+			converged: false
+		}, {
+			while: (s) => !s.converged,
+			body: ({ currentFee }) => require_dist.try_({
+				try: () => {
+					const recipeInputs = require_dist.getBalanceRecipe({
+						coins: dust.map((coin) => ({
+							type: "dust",
+							value: coin.value,
+							token: coin.token
+						})),
+						initialImbalances: require_dist.Imbalances.fromEntry("dust", currentFee),
+						feeTokenType: "dust",
+						coinSelection: this.getCoinSelection(),
+						transactionCostModel: {
+							inputFeeOverhead: 0n,
+							outputFeeOverhead: 0n
+						},
+						createOutput: (coin) => coin,
+						isCoinEqual: (a, b) => a.token.nonce === b.token.nonce
+					}).inputs.map(({ token, value }) => ({
+						token,
+						value
+					}));
+					const newFee = this.dryRunFee(recipeInputs, transactions, secretKey, state, ttl, currentTime, ledgerParams);
+					return {
+						currentFee: newFee,
+						recipeInputs,
+						converged: newFee <= recipeInputs.reduce((sum, input) => sum + input.value, 0n)
+					};
+				},
+				catch: (err) => {
+					if (err instanceof require_dist.InsufficientFundsError) return new InsufficientFundsError({
+						message: err.message,
+						tokenType: err.tokenType
+					});
+					else return new OtherWalletError({
+						message: err instanceof Error ? err.message : "Dust balancing failed",
+						cause: err
+					});
+				}
+			})
+		}), require_dist.either$1, require_dist.runSync, require_dist.map$6(({ currentFee, recipeInputs }) => ({
+			fee: currentFee,
+			recipeInputs: distributeFeeAcrossInputs$1(recipeInputs, currentFee)
+		})));
+	}
+	estimateFee(secretKey, state, transactions, ttl, currentTime, ledgerParams) {
+		return require_dist.pipe(this.computeBalancingRecipe(secretKey, state, transactions, ttl, currentTime, ledgerParams), require_dist.map$6(({ fee }) => fee));
+	}
+	balanceTransactions(secretKey, state, transactions, ttl, currentTime, ledgerParams) {
+		const networkId = this.networkId;
+		return require_dist.pipe(this.computeBalancingRecipe(secretKey, state, transactions, ttl, currentTime, ledgerParams), require_dist.flatMap$4(({ recipeInputs }) => {
+			return require_dist.ledgerTry(() => {
+				const intent = _midnight_ntwrk_ledger_v8.Intent.new(ttl);
+				const [spends, updatedState] = CoreWallet.spendCoins(state, secretKey, recipeInputs, currentTime);
+				intent.dustActions = new _midnight_ntwrk_ledger_v8.DustActions(SignatureMarker.signature, ProofMarker.preProof, currentTime, [...spends], []);
+				const [first, ...rest] = transactions.map((tx) => tx.eraseProofs());
+				const mergedExisting = first ? rest.reduce((acc, tx) => acc.merge(tx), first) : void 0;
+				const segmentId = mergedExisting ? require_dist.getOrElse(findAvailableSegmentId$1(mergedExisting), () => 1) : 1;
+				return [_midnight_ntwrk_ledger_v8.Transaction.fromParts(networkId).addIntent({
+					tag: "specific",
+					value: segmentId
+				}, intent), updatedState];
+			});
+		}));
+	}
+	revertTransaction(state, transaction) {
+		return require_dist.try_$1({
+			try: () => CoreWallet.revertTransaction(state, transaction),
+			catch: (err) => {
+				return new OtherWalletError({
+					message: `Error while reverting transaction ${transaction.identifiers().at(0)}`,
+					cause: err
+				});
+			}
+		});
+	}
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v1/RunningV1Variant.js
+const progress = (state) => {
+	const appliedIndex = state.progress?.appliedIndex ?? 0n;
+	const highestRelevantWalletIndex = state.progress?.highestRelevantWalletIndex ?? 0n;
+	const sourceGap = (state.progress?.highestIndex ?? 0n) - (state.progress?.highestRelevantIndex ?? 0n);
+	const applyGap = highestRelevantWalletIndex - appliedIndex;
+	return [require_dist.ProgressUpdate({
+		sourceGap,
+		applyGap
+	})];
+};
+/**
+* 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");
+/**
+* How a failing synchronization pass is retried.
+*
+* @remarks
+*   Exported so the delays it actually produces can be asserted. A schedule reads as though its combinators apply to the
+*   delay, and for some of them they do not — which is worth pinning in a test rather than trusting by eye.
+*/
+const syncRetrySchedule = require_dist.pipe(require_dist.exponential(require_dist.seconds(1), 2), require_dist.jittered, require_dist.union(require_dist.spaced(require_dist.minutes(2))));
+var RunningV1Variant = class {
+	__polyTag__ = V1Tag;
+	#scope;
+	#context;
+	#v1Context;
+	#txHistoryPermits = require_dist.makeSemaphore(8).pipe(require_dist.runSync);
+	state;
+	#syncLock;
+	/**
+	* Whether a background synchronization worker is already running.
+	*
+	* @remarks
+	*   Distinct from {@link #syncLock}, which is released at the end of every pass and so says nothing about the worker
+	*   that runs them. Held for the worker's whole lifetime — polling delays and retries included — and released as it
+	*   exits, so a wallet started again while it is already synchronizing keeps the worker it has instead of gaining a
+	*   second one that polls alongside it until the wallet stops.
+	*
+	*   The guard asks only whether a worker is running, not what it was started with, so a second start is ignored even
+	*   when it carries different key material. Starting a running wallet on a second key is not a supported way to
+	*   change keys: stop it first. Two workers would be no better — they would apply two keys' updates to one state.
+	*/
+	#backgroundWorkerLock;
+	constructor(scope, context, v1Context) {
+		this.#scope = scope;
+		this.#context = context;
+		this.#v1Context = v1Context;
+		this.#syncLock = require_dist.runSync(require_dist.make$2(false));
+		this.#backgroundWorkerLock = require_dist.runSync(require_dist.make$2(false));
+		this.state = require_dist.fromEffect(context.stateRef.get).pipe(require_dist.flatMap((initialState) => context.stateRef.changes.pipe(require_dist.mapAccum({
+			previous: initialState,
+			isInitial: true
+		}, (seen, current) => [{
+			previous: current,
+			isInitial: false
+		}, [
+			seen.previous,
+			current,
+			seen.isInitial
+		]]))), require_dist.mapConcat(([previous, current, isInitial]) => {
+			return [
+				require_dist.State({ state: current }),
+				...progress(current),
+				...protocolVersionChange(previous, current, isInitial, context.activationRange)
+			];
+		}));
+	}
+	startSyncInBackground(startAux) {
+		const attempt = this.startSync(startAux).pipe(require_dist.runScoped(require_dist.drain), require_dist.scoped).pipe(require_dist.retry$1(syncRetrySchedule));
+		const worker = BackgroundRepeat$1.$match(this.#v1Context.syncService.backgroundRepeat, {
+			Once: () => attempt,
+			WithDelay: ({ delay }) => require_dist.repeat(attempt, require_dist.spaced(delay)).pipe(require_dist.asVoid)
+		});
+		return require_dist.modify(this.#backgroundWorkerLock, (isRunning) => [!isRunning, true]).pipe(require_dist.flatMap$1((acquired) => acquired ? worker.pipe(require_dist.ensuring$1(require_dist.set(this.#backgroundWorkerLock, false)), require_dist.forkScoped, require_dist.asVoid) : require_dist._void), require_dist.provideService(require_dist.Scope, this.#scope));
+	}
+	/**
+	* Runs one sync pass to completion, rather than forking it into the background.
+	*
+	* @remarks
+	*   Only meaningful with a sync service whose stream terminates. The indexer-event service this variant defaults to is
+	*   an open subscription, so use {@link startSyncInBackground} with it; this entry point exists for a finite service
+	*   supplied through the builder's `withSync`. It shares {@link startSync}'s lock, so a pass started while a
+	*   background sync is running returns immediately without touching the state.
+	*/
+	sync(startAux) {
+		return this.startSync(startAux).pipe(require_dist.runScoped(require_dist.drain), require_dist.scoped);
+	}
+	startSync(startAux) {
+		return require_dist.pipe(require_dist.modify(this.#syncLock, (isLocked) => [!isLocked, true]), require_dist.fromEffect, require_dist.flatMap((acquired) => {
+			if (!acquired) return require_dist.empty;
+			return require_dist.pipe(require_dist.get(this.#context.stateRef), require_dist.fromEffect, require_dist.flatMap((state) => this.#v1Context.syncService.updates(state, startAux)), require_dist.mapEffect((update) => require_dist.modifyEffect(this.#context.stateRef, (state) => require_dist.try_({
+				try: () => {
+					const [newState, changesResult] = this.#v1Context.syncCapability.applyUpdate(state, update, this.#context.activationRange);
+					return [changesResult, newState];
+				},
+				catch: (err) => new OtherWalletError({
+					message: "Error while applying sync update",
+					cause: err
+				})
+			})).pipe(require_dist.flatMap$1(({ changes, protocolVersion }) => changes.length === 0 ? require_dist._void : require_dist.pipe(require_dist.forEach(changes, (change) => require_dist.pipe(this.#txHistoryPermits.withPermits(1)(require_dist.pipe(this.#v1Context.transactionHistoryService.getTransactionDetails(change.source), require_dist.flatMap$1((metadata) => this.#v1Context.transactionHistoryService.put(change, metadata, protocolVersion)))), require_dist.catchAllCause((cause) => require_dist.logError(cause, `Failed to record dust tx-history section for ${change.source}`))), {
+				discard: true,
+				concurrency: 8
+			}), require_dist.forkScoped)), require_dist.provideService(require_dist.Scope, this.#scope))), require_dist.tapError((error$1) => require_dist.error(error$1)), require_dist.ensuring(require_dist.set(this.#syncLock, false)));
+		}));
+	}
+	createDustGenerationTransaction(currentTime, ttl, nightUtxos, nightVerifyingKey, dustReceiverAddress) {
+		if (nightUtxos.some((utxo) => utxo.type !== require_dist.Token.night)) return require_dist.fail$2(new OtherWalletError({ message: "Token of a non-Night type received" }));
+		return require_dist.Do.pipe(require_dist.bind("currentState", () => require_dist.get(this.#context.stateRef)), require_dist.bind("blockData", () => this.#v1Context.syncService.blockData()), require_dist.let_("resolvedTime", ({ blockData }) => currentTime ?? blockData.timestamp), require_dist.let_("utxosWithDustValue", ({ currentState, resolvedTime }) => {
+			return this.#v1Context.coinsAndBalancesCapability.estimateDustGeneration(currentState, nightUtxos, resolvedTime);
+		}), require_dist.flatMap$1(({ utxosWithDustValue, resolvedTime }) => {
+			return this.#v1Context.transactingCapability.createDustGenerationTransaction(resolvedTime, ttl, utxosWithDustValue, nightVerifyingKey, dustReceiverAddress).pipe(require_dist.toEffect);
+		}));
+	}
+	splitNightUtxosForDustRegistration(currentTime, nightUtxos, isRegistration) {
+		if (nightUtxos.some((utxo) => utxo.type !== require_dist.Token.night)) return require_dist.fail$2(new OtherWalletError({ message: "Token of a non-Night type received" }));
+		return require_dist.gen(this, function* () {
+			const currentState = yield* require_dist.get(this.#context.stateRef);
+			const utxosWithDustValue = this.#v1Context.coinsAndBalancesCapability.estimateDustGeneration(currentState, nightUtxos, currentTime);
+			return this.#v1Context.transactingCapability.splitNightUtxosForDustRegistration(utxosWithDustValue, isRegistration);
+		});
+	}
+	attachDustRegistration(transaction, currentTime, nightVerifyingKey, dustReceiverAddress, feePayment) {
+		return this.#v1Context.transactingCapability.attachDustRegistration(transaction, currentTime, nightVerifyingKey, dustReceiverAddress, feePayment).pipe(require_dist.toEffect);
+	}
+	addDustGenerationSignature(transaction, signature) {
+		return this.#v1Context.transactingCapability.addDustGenerationSignature(transaction, signature).pipe(require_dist.toEffect);
+	}
+	addDustRegistrationSignature(transaction, signature) {
+		return this.#v1Context.transactingCapability.addDustRegistrationSignature(transaction, signature).pipe(require_dist.toEffect);
+	}
+	calculateFee(transactions) {
+		return require_dist.pipe(this.#v1Context.syncService.blockData(), require_dist.map$2((blockData) => require_dist.pipe(transactions, require_dist.map$3((transaction) => this.#v1Context.transactingCapability.calculateFee(transaction, blockData.ledgerParameters)), require_dist.sumBigInt)));
+	}
+	estimateFee(secretKey, transactions, ttl, currentTime) {
+		return require_dist.pipe(require_dist.all([require_dist.get(this.#context.stateRef), this.#v1Context.syncService.blockData()]), require_dist.flatMap$1(([state, blockData]) => require_dist.pipe(this.#v1Context.transactingCapability.estimateFee(secretKey, state, transactions, ttl, currentTime ?? blockData.timestamp, blockData.ledgerParameters), require_dist.toEffect)));
+	}
+	balanceTransactions(secretKey, transactions, ttl, currentTime) {
+		return require_dist.pipe(this.#v1Context.syncService.blockData(), require_dist.flatMap$1((blockData) => require_dist.pipe(require_dist.modifyEffect(this.#context.stateRef, (state) => this.#v1Context.transactingCapability.balanceTransactions(secretKey, state, transactions, ttl, currentTime ?? blockData.timestamp, blockData.ledgerParameters)), require_dist.map$2((transaction) => ({
+			transaction,
+			blockData
+		})))));
+	}
+	revertTransaction(transaction) {
+		return require_dist.updateEffect(this.#context.stateRef, (state) => {
+			return require_dist.pipe(this.#v1Context.transactingCapability.revertTransaction(state, transaction), require_dist.toEffect);
+		});
+	}
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v1/TransactionHistory.js
+const DustUtxoInfoSchema$1 = require_dist.Struct({
+	initialValue: require_dist.BigInt$,
+	nonce: require_dist.BigInt$,
+	seq: require_dist.Number$,
+	backingNight: require_dist.String$,
+	mtIndex: require_dist.BigInt$
+});
+const DustSectionSchema$1 = require_dist.Struct({
+	receivedUtxos: require_dist.Array$(DustUtxoInfoSchema$1),
+	spentUtxos: require_dist.Array$(DustUtxoInfoSchema$1)
+});
+require_dist.extendEntrySchema({ dust: require_dist.optional(DustSectionSchema$1) });
+require_dist.equivalence(DustUtxoInfoSchema$1);
+const convertQualifiedDustOutput$1 = (utxo) => ({
+	initialValue: utxo.initialValue,
+	nonce: utxo.nonce,
+	seq: utxo.seq,
+	backingNight: utxo.backingNight,
+	mtIndex: utxo.mtIndex
+});
+const convertUpdateToFinalizedInput$1 = (changes, metadata, protocolVersion) => ({
+	hash: changes.source,
+	protocolVersion,
+	status: metadata.status,
+	identifiers: metadata.identifiers,
+	fees: metadata.fees,
+	finalizedBlock: {
+		hash: metadata.block.hash,
+		height: metadata.block.height,
+		timestamp: new Date(metadata.block.timestamp)
+	},
+	dust: {
+		receivedUtxos: changes.receivedUtxos.map(convertQualifiedDustOutput$1),
+		spentUtxos: changes.spentUtxos.map(convertQualifiedDustOutput$1)
+	}
+});
+const gotFinalizedDust$1 = (txHistoryStorage, input) => require_dist.tryPromise({
+	try: () => txHistoryStorage.gotFinalized(input),
+	catch: (e) => new TransactionHistoryError({
+		message: `Failed to record finalized history entry for ${input.hash}`,
+		cause: e
+	})
+});
+const makeDefaultTransactionHistoryService$1 = (config, _getContext) => {
+	const txHistoryStorage = config.txHistoryStorage;
+	const queryClientLayer = require_dist.layer$1({ url: config.indexerClientConnection.indexerHttpUrl });
+	const retryWindow = config.transactionDetailsRetryWindow ?? require_dist.minutes(2);
+	return {
+		put: (changes, metadata, protocolVersion) => gotFinalizedDust$1(txHistoryStorage, convertUpdateToFinalizedInput$1(changes, metadata, protocolVersion)),
+		getTransactionDetails: (hash) => require_dist.gen(function* () {
+			const result = yield* (yield* require_dist.TransactionHistoryDetail)({ transactionHash: hash });
+			const tx = yield* require_dist.head$1(result.transactions).pipe(require_dist.orElseFail(() => new TransactionHistoryError({ message: `Indexer has not yet indexed transaction ${hash}` })));
+			const rawStatus = tx.__typename === "RegularTransaction" ? tx.transactionResult.status : void 0;
+			const status = rawStatus === "FAILURE" || rawStatus === "PARTIAL_SUCCESS" ? rawStatus : "SUCCESS";
+			const identifiers = tx.__typename === "RegularTransaction" ? tx.identifiers : [];
+			const fees = tx.__typename === "RegularTransaction" ? BigInt(tx.fees.paidFees) : null;
+			return {
+				hash: tx.hash,
+				block: {
+					hash: tx.block.hash,
+					height: tx.block.height,
+					timestamp: tx.block.timestamp
+				},
+				status,
+				identifiers,
+				fees
+			};
+		}).pipe(require_dist.provide(queryClientLayer), require_dist.scoped, require_dist.retry$1({
+			schedule: require_dist.exponential(require_dist.seconds(1)).pipe(require_dist.either(require_dist.spaced(require_dist.seconds(10))), require_dist.jittered, require_dist.upTo(retryWindow)),
+			while: (error) => error instanceof TransactionHistoryError
+		}), require_dist.mapError$2((error) => error instanceof TransactionHistoryError ? error : new TransactionHistoryError({
+			message: `Failed to fetch transaction metadata for ${hash}`,
+			cause: error
+		})))
+	};
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v1/CoinsAndBalances.js
+const chooseCoin$1 = (coins) => coins.filter((coin) => coin.value > 0n).toSorted((a, b) => Number(a.value - b.value)).at(0);
+const FAKE_NONCE$1 = "0".repeat(64);
+const makeDefaultCoinsAndBalancesCapability$1 = (_config, getContext) => {
+	const getWalletBalance = (state, time) => {
+		return state.state.walletBalance(time);
+	};
+	const getGenerationInfo = (state, coin) => {
+		const info = state.state.generationInfo(coin);
+		return info && info.dtime ? {
+			...info,
+			dtime: /* @__PURE__ */ new Date(+info.dtime)
+		} : info;
+	};
+	const resolveTime = (state, time) => time ?? state.state.syncTime;
+	const toFullInfo = (state, coins, time) => coins.flatMap((coin) => {
+		const genInfo = getGenerationInfo(state, coin);
+		return genInfo ? [{
+			token: coin,
+			...getFullDustInfo(state.state.params, genInfo, coin, time)
+		}] : [];
+	});
+	const availableDustTokens = (state) => {
+		const pendingSpends = new Set([...state.pendingDust.values()].map((coin) => coin.nonce));
+		return require_dist.pipe(state.state.utxos, require_dist.filter$1((coin) => !pendingSpends.has(coin.nonce)));
+	};
+	const getAvailableCoins = (state, time) => toFullInfo(state, availableDustTokens(state), resolveTime(state, time));
+	const getPendingCoins = (state, time) => toFullInfo(state, state.pendingDust, resolveTime(state, time));
+	const getTotalCoins = (state, time) => {
+		const effectiveTime = resolveTime(state, time);
+		return [...getAvailableCoins(state, effectiveTime), ...getPendingCoins(state, effectiveTime)];
+	};
+	const getAvailableCoinsWithGeneratedDust = (state, currentTime) => getAvailableCoins(state, currentTime).map((info) => ({
+		token: info.token,
+		value: info.generatedNow
+	}));
+	const getFullDustInfo = (parameters, genInfo, coin, currentTime) => {
+		const generatedValue = _midnight_ntwrk_ledger_v8.updatedValue(coin.ctime, coin.initialValue, genInfo, currentTime, parameters);
+		return {
+			dtime: genInfo.dtime,
+			maxCap: genInfo.value * parameters.nightDustRatio,
+			maxCapReachedAt: require_dist.addSeconds(coin.ctime, parameters.timeToCapSeconds),
+			generatedNow: generatedValue,
+			rate: genInfo.value * parameters.generationDecayRate
+		};
+	};
+	const estimateDustGeneration = (state, nightUtxos, currentTime) => {
+		const dustPublicKey = getContext().keysCapability.getPublicKey(state);
+		return require_dist.pipe(nightUtxos, require_dist.map$3((utxo) => {
+			const genInfo = fakeGenerationInfo(utxo, dustPublicKey);
+			const fakeDustCoin = fakeDustToken(dustPublicKey, utxo);
+			return {
+				utxo,
+				dust: getFullDustInfo(state.state.params, genInfo, fakeDustCoin, currentTime)
+			};
+		}));
+	};
+	/** Create a fake generation info for a given Utxo. It allows to estimate the Dust generation from it */
+	const fakeGenerationInfo = (utxo, dustPublicKey) => {
+		return {
+			value: utxo.value,
+			owner: dustPublicKey,
+			nonce: FAKE_NONCE$1,
+			dtime: void 0
+		};
+	};
+	/** Create a fake dust coin for a given Utxo. It allows to estimate full details of the Dust generation from it */
+	const fakeDustToken = (dustPublicKey, utxo) => ({
+		initialValue: 0n,
+		owner: dustPublicKey,
+		nonce: 0n,
+		seq: 0,
+		ctime: utxo.ctime,
+		backingNight: "",
+		mtIndex: 0n
+	});
+	const splitNightUtxos = (utxos) => {
+		const [guaranteed, fallible] = require_dist.pipe(utxos, require_dist.sort(require_dist.pipe(require_dist.bigint, require_dist.reverse, require_dist.mapInput((coin) => coin.dust.generatedNow))), require_dist.splitAt(1));
+		return {
+			guaranteed,
+			fallible
+		};
+	};
+	return {
+		getWalletBalance,
+		getAvailableCoins,
+		getPendingCoins,
+		getTotalCoins,
+		getAvailableCoinsWithGeneratedDust,
+		getGenerationInfo,
+		estimateDustGeneration,
+		splitNightUtxos
+	};
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v1/V1Builder.js
+/**
+* Completes a builder configuration into the one the empty-wallet migration asks for.
+*
+* @remarks
+*   The dust parameters are optional on the builder and required on the migration, and this is the single place that gap
+*   is closed, so the fallback the unconfigured `build` takes and the one {@link V1Builder.withMigrationDefaults} states
+*   explicitly cannot drift apart.
+*/
+const emptyWalletMigrationConfiguration$1 = (configuration) => ({
+	networkId: configuration.networkId,
+	dustParameters: configuration.dustParameters ?? _midnight_ntwrk_ledger_v8.LedgerParameters.initialParameters().dust
+});
+var V1Builder = class V1Builder {
+	#buildState;
+	constructor(buildState = {}) {
+		this.#buildState = buildState;
+	}
+	withDefaults() {
+		return this.withDefaultTransactionType().withSyncDefaults().withSerializationDefaults().withTransactingDefaults().withCoinsAndBalancesDefaults().withTransactionHistoryDefaults().withKeysDefaults().withStartAuxDefaults().withCoinSelectionDefaults();
+	}
+	withTransactionType() {
+		return new V1Builder({
+			...this.#buildState,
+			transactingCapability: void 0
+		});
+	}
+	withDefaultTransactionType() {
+		return this.withTransactionType();
+	}
+	withSyncDefaults() {
+		return this.withSync(makeDefaultSyncService$1, makeDefaultSyncCapability$1);
+	}
+	withSync(syncService, syncCapability) {
+		return new V1Builder({
+			...this.#buildState,
+			syncService,
+			syncCapability,
+			startAux: void 0
+		});
+	}
+	withSerializationDefaults() {
+		return this.withSerialization(makeDefaultV1SerializationCapability);
+	}
+	withSerialization(serializationCapability) {
+		return new V1Builder({
+			...this.#buildState,
+			serializationCapability
+		});
+	}
+	withTransactingDefaults() {
+		return this.withTransacting(makeDefaultTransactingCapability$1);
+	}
+	withTransacting(transactingCapability) {
+		return new V1Builder({
+			...this.#buildState,
+			transactingCapability
+		});
+	}
+	withCoinSelection(coinSelection) {
+		return new V1Builder({
+			...this.#buildState,
+			coinSelection
+		});
+	}
+	withCoinSelectionDefaults() {
+		return this.withCoinSelection(() => chooseCoin$1);
+	}
+	withCoinsAndBalancesDefaults() {
+		return this.withCoinsAndBalances(makeDefaultCoinsAndBalancesCapability$1);
+	}
+	withCoinsAndBalances(coinsAndBalancesCapability) {
+		return new V1Builder({
+			...this.#buildState,
+			coinsAndBalancesCapability
+		});
+	}
+	withTransactionHistoryDefaults() {
+		return this.withTransactionHistory(makeDefaultTransactionHistoryService$1);
+	}
+	withTransactionHistory(transactionHistoryService) {
+		return new V1Builder({
+			...this.#buildState,
+			transactionHistoryService
+		});
+	}
+	withKeysDefaults() {
+		return this.withKeys(makeDefaultKeysCapability$1);
+	}
+	withKeys(keysCapability) {
+		return new V1Builder({
+			...this.#buildState,
+			keysCapability
+		});
+	}
+	/**
+	* Uses the default migration: an empty wallet built from nothing.
+	*
+	* @remarks
+	*   This is what an unconfigured builder already does, so calling it changes no behaviour — it states the choice rather
+	*   than inheriting it. Registering this variant as the target of a real fork means calling
+	*   {@link V1Builder.withMigration} with {@link makeCrossLedgerMigration} instead.
+	*
+	*   The parameters the empty dust state is valued against come from the builder configuration when it names them, and
+	*   from the ledger's initial parameters when it does not.
+	*/
+	withMigrationDefaults() {
+		return this.withMigration((configuration) => makeEmptyWalletMigration$1(emptyWalletMigrationConfiguration$1(configuration)));
+	}
+	/**
+	* Chooses how this variant produces its first state from the state that preceded it.
+	*
+	* @remarks
+	*   The strategy's input type becomes the variant's `TPreviousState`, which is what the runtime type-checks a
+	*   registration against: a variant declaring it migrates from a ledger-v8 dust wallet cannot be registered after one
+	*   that produces something else.
+	*
+	*   The context the factory reads is a type parameter of the method, exactly as it is for every other capability here,
+	*   rather than the builder's own `TContext`. Naming `TContext` in an argument position would make the builder
+	*   invariant in it, and a chain that has not yet configured every capability — which is how the simulator-backed
+	*   variants are assembled — could then no longer be handed to {@link V1Builder.build}.
+	* @example
+	*   ```typescript
+	*   const forkTarget = new V1Builder().withDefaults().withMigration(makeCrossLedgerMigration);
+	*   ```;
+	*
+	* @param migration Builds the migration from the configuration and the sibling capabilities.
+	*/
+	withMigration(migration) {
+		const capabilities = this.#buildState;
+		return new V1Builder({
+			...capabilities,
+			migration
+		});
+	}
+	build(configuration) {
+		const v1Context = this.#buildContextFromBuildState(configuration);
+		const migration = this.#resolveMigration(configuration, () => v1Context);
+		return {
+			__polyTag__: V1Tag,
+			coinsAndBalances: v1Context.coinsAndBalancesCapability,
+			keys: v1Context.keysCapability,
+			serialization: v1Context.serializationCapability,
+			transactionHistory: v1Context.transactionHistoryService,
+			startAux: this.#resolveStartAux(),
+			start(context) {
+				return require_dist.gen(function* () {
+					return new RunningV1Variant(yield* require_dist.Scope, context, v1Context);
+				});
+			},
+			migrateState: (previousState) => migration.migrate(previousState).pipe(require_dist.mapError$2((error) => new require_dist.WalletRuntimeError({
+				message: "Failed to migrate dust wallet state into this variant",
+				cause: error
+			}))),
+			deserializeState: (serialized) => {
+				return v1Context.serializationCapability.deserialize(null, serialized);
+			}
+		};
+	}
+	/**
+	* Uses the default derivation: this ledger version's own dust secret key, built from the seed.
+	*
+	* @remarks
+	*   Constrained to a builder whose sync is started with a `DustSecretKey`, because that is the only start-aux this
+	*   derivation can produce. A builder whose sync expects something else has to say how that is derived, or say
+	*   nothing and be refused at `build`.
+	* @returns A builder that produces a variant able to start sync from a seed alone.
+	*/
+	withStartAuxDefaults() {
+		return this.withStartAux({ fromSeed: (seed) => _midnight_ntwrk_ledger_v8.DustSecretKey.fromSeed(seed) });
+	}
+	/**
+	* Chooses how this variant derives the key material its synchronization is started with from a seed.
+	*
+	* @param startAux The derivation.
+	* @returns A builder that produces a variant able to start sync from a seed alone.
+	*/
+	withStartAux(startAux) {
+		return new V1Builder({
+			...this.#buildState,
+			startAux
+		});
+	}
+	/**
+	* Resolves the configured derivation, refusing a builder that never stated one.
+	*
+	* @remarks
+	*   Kept out of the structural completeness check because it is typed rather than merely present: a builder whose sync
+	*   expects one kind of key material and whose derivation produces another is a wallet that would be silently handed
+	*   key objects of the wrong shape at the first migration.
+	*/
+	#resolveStartAux() {
+		const configured = this.#buildState.startAux;
+		if (configured === void 0) throw new Error("Not all components are configured in V1Builder: startAux");
+		return configured;
+	}
+	/**
+	* Resolves the configured migration, or the empty-wallet fallback when none was configured.
+	*
+	* @remarks
+	*   The fallback is written as a nullary function on purpose. It ignores whatever preceded it — it builds an empty
+	*   wallet from nothing — which makes it a valid migration from _any_ previous state, but a `StateMigration<null>`
+	*   value could only be widened to `StateMigration<TPreviousState>` through a cast. Declaring no parameter says the
+	*   same thing to the type system without one.
+	*/
+	#resolveMigration(configuration, getContext) {
+		const configured = this.#buildState.migration;
+		return configured === void 0 ? { migrate: () => makeEmptyWalletMigration$1(emptyWalletMigrationConfiguration$1(configuration)).migrate(null) } : configured(configuration, getContext);
+	}
+	#buildContextFromBuildState(configuration) {
+		if (!isBuildStateFull$1(this.#buildState)) throw new Error("Not all components are configured in V1 Builder");
+		const { syncCapability, syncService, transactingCapability, serializationCapability, coinSelection, coinsAndBalancesCapability, keysCapability, transactionHistoryService } = this.#buildState;
+		const getContext = () => context;
+		const context = {
+			serializationCapability: serializationCapability(configuration, getContext),
+			syncCapability: syncCapability(configuration, getContext),
+			syncService: syncService(configuration, getContext),
+			transactingCapability: transactingCapability(configuration, getContext),
+			coinsAndBalancesCapability: coinsAndBalancesCapability(configuration, getContext),
+			keysCapability: keysCapability(configuration, getContext),
+			coinSelection: coinSelection(configuration, getContext),
+			transactionHistoryService: transactionHistoryService(configuration, getContext)
+		};
+		return context;
+	}
+};
+const isBuildStateFull$1 = (buildState) => {
+	return [
+		"syncService",
+		"syncCapability",
+		"transactingCapability",
+		"coinSelection",
+		"serializationCapability",
+		"coinsAndBalancesCapability",
+		"keysCapability",
+		"transactionHistoryService"
+	].every((key) => typeof buildState[key] == "function");
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v2/Keys.js
+const makeDefaultKeysCapability = () => {
+	return {
+		getPublicKey: (state) => {
+			return state.publicKey.publicKey;
+		},
+		getAddress: (state) => {
+			return new require_dist.DustAddress(state.publicKey.publicKey);
+		}
+	};
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-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 holds no
+*   dust and has 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 pay fees with.
+* @example
+*   ```typescript
+*   const builder = new V2Builder().withDefaults().withMigration(makeEmptyWalletMigration({ networkId, dustParameters }));
+*   ```;
+*
+* @param configuration Supplies the network the scaffold state claims to be on, and the dust parameters it uses.
+* @returns A migration from `null`.
+*/
+const makeEmptyWalletMigration = (configuration) => ({ migrate: () => {
+	const seed = require_dist.fromString("0000000000000000000000000000000000000000000000000000000000000001");
+	return require_dist.succeed(CoreWallet$1.initEmpty(configuration.dustParameters, _midnightntwrk_ledger_v9.DustSecretKey.fromSeed(seed), configuration.networkId));
+} });
+/**
+* The migration across a ledger-version boundary: a dustless state of this version, carrying identity and position.
+*
+* @remarks
+*   The indexer replays the timeline after the hard fork, re-emitting the wallet's history as events of ledger-v9
+*   version. A migrated wallet therefore does not need — and must not attempt — to carry its dust: exactly the same
+*   dust is generated again by ordinary sync, from the replayed registration events, and valued against this version's
+*   parameters. Carrying it across as well would double-count what the replay is about to deliver, on top of requiring
+*   generation and commitment trees that this ledger's WASM module cannot read.
+*
+*   So what crosses is the dust public key, the network, the protocol version that triggered the hand-over, and the
+*   cursor. Sync progress is **parked at the fork** rather than rewound: the indexer numbers the replayed events
+*   onwards from whatever id it had reached when the fork happened, never from zero, so the inherited cursor is exactly
+*   where the replay begins. A wallet that rewound to zero would wait on a stretch of the timeline this ledger
+*   version's events do not occupy.
+*
+*   If the ledger team ships a byte-level translation for wallet local state, it replaces this instance without touching
+*   anything around it — that is the point of the {@link StateMigration} seam.
+* @param configuration Supplies this ledger version's dust parameters for the fresh state.
+* @returns A migration from a previous-ledger-version wallet.
+*/
+const makeCrossLedgerMigration = (configuration) => ({ migrate: (previousState) => require_dist.succeed(CoreWallet$1.fromPreviousVersion({
+	publicKey: { publicKey: previousState.publicKey.publicKey },
+	networkId: previousState.networkId,
+	protocolVersion: previousState.protocolVersion,
+	progress: previousState.progress,
+	dustParameters: configuration.dustParameters
+})) });
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v2/Transacting.js
+const makeDefaultTransactingCapability = (config, getContext) => {
+	return new TransactingCapabilityImplementation(config.networkId, config.costParameters, () => getContext().coinSelection, () => getContext().coinsAndBalancesCapability, () => getContext().keysCapability);
+};
+/**
+* Distributes the fee across multiple inputs, draining smaller inputs first when the fee exceeds any single input's
+* value. Finds the next available intent segment id in a transaction.
+*
+* Fallible intent segments occupy the range `[1, 65535]`; segment `0` is reserved for the guaranteed section and is
+* never returned.
+*
+* @param transaction - Transaction whose intent map is inspected.
+* @returns `Some(segmentId)` with the lowest unused id, or `None` if all 65535 fallible segments are taken.
+*/
+const findAvailableSegmentId = (transaction) => {
+	const used = new Set(transaction.intents?.keys() ?? []);
+	return require_dist.pipe(require_dist.range(1, 65535), require_dist.findFirst$1((segmentId) => !used.has(segmentId)));
+};
+/**
+* Distributes the fee across multiple inputs, draining smaller inputs first when the fee exceeds any single input's
+* value.
+*/
+const distributeFeeAcrossInputs = (inputs, fee) => inputs.reduce(({ result, remaining }, input) => {
+	const deduction = remaining >= input.value ? input.value : remaining;
+	return {
+		result: [...result, {
+			...input,
+			value: deduction
+		}],
+		remaining: remaining - deduction
+	};
+}, {
+	result: [],
+	remaining: fee
+}).result;
+var TransactingCapabilityImplementation = class TransactingCapabilityImplementation {
+	networkId;
+	costParams;
+	getCoinSelection;
+	getCoins;
+	getKeys;
+	constructor(networkId, costParams, getCoinSelection, getCoins, getKeys) {
+		this.getCoins = getCoins;
+		this.networkId = networkId;
+		this.costParams = costParams;
+		this.getCoinSelection = getCoinSelection;
+		this.getKeys = getKeys;
+	}
+	createDustGenerationTransaction(currentTime, ttl, nightUtxos, nightVerifyingKey, dustReceiverAddress) {
+		const makeOffer = (utxos) => {
+			if (utxos.length === 0) return require_dist.none();
+			const totalValue = require_dist.pipe(utxos, require_dist.map$4((coin) => coin.utxo.value), require_dist.sumAll);
+			const inputs = utxos.map(({ utxo }) => ({
+				...utxo,
+				owner: nightVerifyingKey
+			}));
+			const output = {
+				owner: (0, _midnightntwrk_ledger_v9.addressFromKey)(nightVerifyingKey),
+				type: require_dist.Token.night,
+				value: totalValue
+			};
+			return require_dist.some(_midnightntwrk_ledger_v9.UnshieldedOffer.new(inputs, [output], []));
+		};
+		return require_dist.gen$1(this, function* () {
+			const receiver = dustReceiverAddress ? dustReceiverAddress.data : void 0;
+			return yield* require_dist.ledgerTry(() => {
+				const network = this.networkId;
+				const splitResult = this.getCoins().splitNightUtxos(nightUtxos);
+				const feePayment = receiver ? require_dist.pipe(splitResult.guaranteed, require_dist.filter$2((coin) => !coin.utxo.registeredForDustGeneration), require_dist.map$4((coin) => coin.dust.generatedNow), require_dist.sumAll) : 0n;
+				const maybeGuaranteedOffer = makeOffer(splitResult.guaranteed);
+				const maybeFallibleOffer = makeOffer(splitResult.fallible);
+				const dustRegistration = new _midnightntwrk_ledger_v9.DustRegistration(SignatureMarker$1.signature, nightVerifyingKey, receiver, feePayment);
+				const dustActions = new _midnightntwrk_ledger_v9.DustActions(SignatureMarker$1.signature, ProofMarker$1.preProof, currentTime, [], [dustRegistration]);
+				const intent = require_dist.pipe(_midnightntwrk_ledger_v9.Intent.new(ttl), (intent) => require_dist.match$1(maybeGuaranteedOffer, {
+					onNone: () => intent,
+					onSome: (guaranteedOffer) => {
+						intent.guaranteedUnshieldedOffer = guaranteedOffer;
+						return intent;
+					}
+				}), (intent) => require_dist.match$1(maybeFallibleOffer, {
+					onNone: () => intent,
+					onSome: (fallibleOffer) => {
+						intent.fallibleUnshieldedOffer = fallibleOffer;
+						return intent;
+					}
+				}), (intent) => {
+					intent.dustActions = dustActions;
+					return intent;
+				});
+				return _midnightntwrk_ledger_v9.Transaction.fromParts(network, void 0, void 0, intent);
+			});
+		});
+	}
+	splitNightUtxosForDustRegistration(utxosWithDustValue, isRegistration) {
+		const splitResult = this.getCoins().splitNightUtxos(utxosWithDustValue);
+		const feePayment = isRegistration ? require_dist.pipe(splitResult.guaranteed, require_dist.filter$2((coin) => !coin.utxo.registeredForDustGeneration), require_dist.map$4((coin) => coin.dust.generatedNow), require_dist.sumAll) : 0n;
+		return {
+			guaranteedUtxos: splitResult.guaranteed,
+			fallibleUtxos: splitResult.fallible,
+			feePayment
+		};
+	}
+	attachDustRegistration(transaction, currentTime, nightVerifyingKey, dustReceiverAddress, feePayment) {
+		return require_dist.gen$1(this, function* () {
+			const intent = transaction.intents?.get(1);
+			if (!intent) return yield* require_dist.left(new TransactingError$1({ message: "No intent found at segment 1; expected an intent built by rotateUtxos" }));
+			if (intent.dustActions !== void 0 && intent.dustActions.registrations.length > 0) return yield* require_dist.left(new TransactingError$1({ message: "Intent at segment 1 already has a dust registration attached" }));
+			return yield* require_dist.ledgerTry(() => {
+				const receiver = dustReceiverAddress ? dustReceiverAddress.data : void 0;
+				const dustRegistration = new _midnightntwrk_ledger_v9.DustRegistration(SignatureMarker$1.signature, nightVerifyingKey, receiver, feePayment);
+				const dustActions = new _midnightntwrk_ledger_v9.DustActions(SignatureMarker$1.signature, ProofMarker$1.preProof, currentTime, [], [dustRegistration]);
+				const newIntent = _midnightntwrk_ledger_v9.Intent.deserialize(SignatureMarker$1.signature, ProofMarker$1.preProof, BindingMarker$1.preBinding, intent.serialize());
+				newIntent.dustActions = dustActions;
+				const newTransaction = _midnightntwrk_ledger_v9.Transaction.deserialize(SignatureMarker$1.signature, ProofMarker$1.preProof, BindingMarker$1.preBinding, transaction.serialize());
+				newTransaction.intents = newTransaction.intents.set(1, newIntent);
+				return newTransaction;
+			});
+		});
+	}
+	addDustRegistrationSignature(transaction, signatureData) {
+		return require_dist.gen$1(this, function* () {
+			const intent = transaction.intents?.get(1);
+			if (!intent) return yield* require_dist.left(new TransactingError$1({ message: "No intent found in the transaction intents with segment = 1" }));
+			const { dustActions } = intent;
+			if (!dustActions) return yield* require_dist.left(new TransactingError$1({ message: "No dustActions found in intent" }));
+			const [registration, ...restRegistrations] = dustActions.registrations;
+			if (!registration) return yield* require_dist.left(new TransactingError$1({ message: "No registrations found in dustActions" }));
+			return yield* require_dist.ledgerTry(() => {
+				const signature = new _midnightntwrk_ledger_v9.SignatureEnabled(signatureData);
+				const registrationWithSignature = new _midnightntwrk_ledger_v9.DustRegistration(signature.instance, registration.nightKey, registration.dustAddress, registration.allowFeePayment, signature);
+				const newDustActions = new _midnightntwrk_ledger_v9.DustActions(signature.instance, ProofMarker$1.preProof, dustActions.ctime, dustActions.spends, [registrationWithSignature, ...restRegistrations]);
+				const newIntent = _midnightntwrk_ledger_v9.Intent.deserialize(signature.instance, ProofMarker$1.preProof, BindingMarker$1.preBinding, intent.serialize());
+				newIntent.dustActions = newDustActions;
+				const newTransaction = _midnightntwrk_ledger_v9.Transaction.deserialize(signature.instance, ProofMarker$1.preProof, BindingMarker$1.preBinding, transaction.serialize());
+				newTransaction.intents = newTransaction.intents.set(1, newIntent);
+				return newTransaction;
+			});
+		});
+	}
+	addDustGenerationSignature(transaction, signatureData) {
+		return require_dist.gen$1(this, function* () {
+			const intent = transaction.intents?.get(1);
+			if (!intent) return yield* require_dist.left(new TransactingError$1({ message: "No intent found in the transaction intents with segment = 1" }));
+			const { dustActions, guaranteedUnshieldedOffer, fallibleUnshieldedOffer } = intent;
+			if (!dustActions) return yield* require_dist.left(new TransactingError$1({ message: "No dustActions found in intent" }));
+			if (!guaranteedUnshieldedOffer) return yield* require_dist.left(new TransactingError$1({ message: "No guaranteedUnshieldedOffer found in intent" }));
+			const [registration, ...restRegistrations] = dustActions.registrations;
+			if (!registration) return yield* require_dist.left(new TransactingError$1({ message: "No registrations found in dustActions" }));
+			return yield* require_dist.ledgerTry(() => {
+				const signature = new _midnightntwrk_ledger_v9.SignatureEnabled(signatureData);
+				const registrationWithSignature = new _midnightntwrk_ledger_v9.DustRegistration(signature.instance, registration.nightKey, registration.dustAddress, registration.allowFeePayment, signature);
+				const newDustActions = new _midnightntwrk_ledger_v9.DustActions(signature.instance, ProofMarker$1.preProof, dustActions.ctime, dustActions.spends, [registrationWithSignature, ...restRegistrations]);
+				const newIntent = _midnightntwrk_ledger_v9.Intent.deserialize(signature.instance, ProofMarker$1.preProof, BindingMarker$1.preBinding, intent.serialize());
+				newIntent.dustActions = newDustActions;
+				const guaranteedSignatures = Array.from({ length: guaranteedUnshieldedOffer.inputs.length }, (_, i) => guaranteedUnshieldedOffer.signatures.at(i) ?? signature);
+				newIntent.guaranteedUnshieldedOffer = guaranteedUnshieldedOffer.addSignatures(guaranteedSignatures);
+				if (fallibleUnshieldedOffer) {
+					const fallibleSignatures = Array.from({ length: fallibleUnshieldedOffer.inputs.length }, (_, i) => fallibleUnshieldedOffer.signatures.at(i) ?? signature);
+					newIntent.fallibleUnshieldedOffer = fallibleUnshieldedOffer.addSignatures(fallibleSignatures);
+				}
+				const newTransaction = _midnightntwrk_ledger_v9.Transaction.deserialize(signature.instance, ProofMarker$1.preProof, BindingMarker$1.preBinding, transaction.serialize());
+				newTransaction.intents = newTransaction.intents.set(1, newIntent);
+				return newTransaction;
+			});
+		});
+	}
+	calculateFee(transaction, ledgerParams) {
+		return transaction.feesWithMargin(ledgerParams, this.costParams.feeBlocksMargin) + (this.costParams.additionalFeeOverhead ?? 0n);
+	}
+	dryRunFee(recipeInputs, transactions, secretKey, state, ttl, currentTime, ledgerParams) {
+		const network = this.networkId;
+		const [spends] = CoreWallet$1.spendCoins(state, secretKey, recipeInputs, currentTime);
+		const intent = _midnightntwrk_ledger_v9.Intent.new(ttl);
+		intent.dustActions = new _midnightntwrk_ledger_v9.DustActions(SignatureMarker$1.signature, ProofMarker$1.preProof, currentTime, [...spends], []);
+		const [first, ...rest] = transactions.map((tx) => tx.eraseProofs());
+		const mergedExisting = first ? rest.reduce((acc, tx) => acc.merge(tx), first) : void 0;
+		const segmentId = mergedExisting ? require_dist.getOrElse(findAvailableSegmentId(mergedExisting), () => 1) : 1;
+		const erasedBalancing = _midnightntwrk_ledger_v9.Transaction.fromParts(network).addIntent({
+			tag: "specific",
+			value: segmentId
+		}, intent).eraseProofs();
+		const mergedTx = mergedExisting ? mergedExisting.merge(erasedBalancing) : erasedBalancing;
+		return this.calculateFee(mergedTx, ledgerParams);
+	}
+	static feeImbalance(transaction, totalFee) {
+		const [_, imbalance] = transaction.imbalances(0, totalFee).entries().find(([tt, _]) => tt.tag === "dust") ?? [];
+		return imbalance ?? 0n;
+	}
+	computeBalancingRecipe(secretKey, state, transactions, ttl, currentTime, ledgerParams) {
+		const initialFees = transactions.reduce((total, transaction) => total + TransactingCapabilityImplementation.feeImbalance(transaction, this.calculateFee(transaction, ledgerParams)), 0n);
+		const dust = this.getCoins().getAvailableCoinsWithGeneratedDust(state, currentTime);
+		return require_dist.pipe(require_dist.iterate({
+			currentFee: initialFees,
+			recipeInputs: [],
+			converged: false
+		}, {
+			while: (s) => !s.converged,
+			body: ({ currentFee }) => require_dist.try_({
+				try: () => {
+					const recipeInputs = require_dist.getBalanceRecipe({
+						coins: dust.map((coin) => ({
+							type: "dust",
+							value: coin.value,
+							token: coin.token
+						})),
+						initialImbalances: require_dist.Imbalances.fromEntry("dust", currentFee),
+						feeTokenType: "dust",
+						coinSelection: this.getCoinSelection(),
+						transactionCostModel: {
+							inputFeeOverhead: 0n,
+							outputFeeOverhead: 0n
+						},
+						createOutput: (coin) => coin,
+						isCoinEqual: (a, b) => a.token.nonce === b.token.nonce
+					}).inputs.map(({ token, value }) => ({
+						token,
+						value
+					}));
+					const newFee = this.dryRunFee(recipeInputs, transactions, secretKey, state, ttl, currentTime, ledgerParams);
+					return {
+						currentFee: newFee,
+						recipeInputs,
+						converged: newFee <= recipeInputs.reduce((sum, input) => sum + input.value, 0n)
+					};
+				},
+				catch: (err) => {
+					if (err instanceof require_dist.InsufficientFundsError) return new InsufficientFundsError$1({
+						message: err.message,
+						tokenType: err.tokenType
+					});
+					else return new OtherWalletError$1({
+						message: err instanceof Error ? err.message : "Dust balancing failed",
+						cause: err
+					});
+				}
+			})
+		}), require_dist.either$1, require_dist.runSync, require_dist.map$6(({ currentFee, recipeInputs }) => ({
+			fee: currentFee,
+			recipeInputs: distributeFeeAcrossInputs(recipeInputs, currentFee)
+		})));
+	}
+	estimateFee(secretKey, state, transactions, ttl, currentTime, ledgerParams) {
+		return require_dist.pipe(this.computeBalancingRecipe(secretKey, state, transactions, ttl, currentTime, ledgerParams), require_dist.map$6(({ fee }) => fee));
+	}
+	balanceTransactions(secretKey, state, transactions, ttl, currentTime, ledgerParams) {
+		const networkId = this.networkId;
+		return require_dist.pipe(this.computeBalancingRecipe(secretKey, state, transactions, ttl, currentTime, ledgerParams), require_dist.flatMap$4(({ recipeInputs }) => {
+			return require_dist.ledgerTry(() => {
+				const intent = _midnightntwrk_ledger_v9.Intent.new(ttl);
+				const [spends, updatedState] = CoreWallet$1.spendCoins(state, secretKey, recipeInputs, currentTime);
+				intent.dustActions = new _midnightntwrk_ledger_v9.DustActions(SignatureMarker$1.signature, ProofMarker$1.preProof, currentTime, [...spends], []);
+				const [first, ...rest] = transactions.map((tx) => tx.eraseProofs());
+				const mergedExisting = first ? rest.reduce((acc, tx) => acc.merge(tx), first) : void 0;
+				const segmentId = mergedExisting ? require_dist.getOrElse(findAvailableSegmentId(mergedExisting), () => 1) : 1;
+				return [_midnightntwrk_ledger_v9.Transaction.fromParts(networkId).addIntent({
+					tag: "specific",
+					value: segmentId
+				}, intent), updatedState];
+			});
+		}));
+	}
+	revertTransaction(state, transaction) {
+		return require_dist.try_$1({
+			try: () => CoreWallet$1.revertTransaction(state, transaction),
+			catch: (err) => {
+				return new OtherWalletError$1({
+					message: `Error while reverting transaction ${transaction.identifiers().at(0)}`,
+					cause: err
+				});
+			}
+		});
+	}
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v2/TransactionHistory.js
+const DustUtxoInfoSchema = require_dist.Struct({
+	initialValue: require_dist.BigInt$,
+	nonce: require_dist.BigInt$,
+	seq: require_dist.Number$,
+	backingNight: require_dist.String$,
+	mtIndex: require_dist.BigInt$
+});
+const DustSectionSchema = require_dist.Struct({
+	receivedUtxos: require_dist.Array$(DustUtxoInfoSchema),
+	spentUtxos: require_dist.Array$(DustUtxoInfoSchema)
+});
+require_dist.extendEntrySchema({ dust: require_dist.optional(DustSectionSchema) });
+const utxoEquals = require_dist.equivalence(DustUtxoInfoSchema);
+const mergeDustSections = (existing, incoming) => ({
+	receivedUtxos: require_dist.unionWith(existing.receivedUtxos, incoming.receivedUtxos, utxoEquals),
+	spentUtxos: require_dist.unionWith(existing.spentUtxos, incoming.spentUtxos, utxoEquals)
+});
+const convertQualifiedDustOutput = (utxo) => ({
+	initialValue: utxo.initialValue,
+	nonce: utxo.nonce,
+	seq: utxo.seq,
+	backingNight: utxo.backingNight,
+	mtIndex: utxo.mtIndex
+});
+const convertUpdateToFinalizedInput = (changes, metadata, protocolVersion) => ({
+	hash: changes.source,
+	protocolVersion,
+	status: metadata.status,
+	identifiers: metadata.identifiers,
+	fees: metadata.fees,
+	finalizedBlock: {
+		hash: metadata.block.hash,
+		height: metadata.block.height,
+		timestamp: new Date(metadata.block.timestamp)
+	},
+	dust: {
+		receivedUtxos: changes.receivedUtxos.map(convertQualifiedDustOutput),
+		spentUtxos: changes.spentUtxos.map(convertQualifiedDustOutput)
+	}
+});
+const gotFinalizedDust = (txHistoryStorage, input) => require_dist.tryPromise({
+	try: () => txHistoryStorage.gotFinalized(input),
+	catch: (e) => new TransactionHistoryError$1({
+		message: `Failed to record finalized history entry for ${input.hash}`,
+		cause: e
+	})
+});
+const makeDefaultTransactionHistoryService = (config, _getContext) => {
+	const txHistoryStorage = config.txHistoryStorage;
+	const queryClientLayer = require_dist.layer$1({ url: config.indexerClientConnection.indexerHttpUrl });
+	const retryWindow = config.transactionDetailsRetryWindow ?? require_dist.minutes(2);
+	return {
+		put: (changes, metadata, protocolVersion) => gotFinalizedDust(txHistoryStorage, convertUpdateToFinalizedInput(changes, metadata, protocolVersion)),
+		getTransactionDetails: (hash) => require_dist.gen(function* () {
+			const result = yield* (yield* require_dist.TransactionHistoryDetail)({ transactionHash: hash });
+			const tx = yield* require_dist.head$1(result.transactions).pipe(require_dist.orElseFail(() => new TransactionHistoryError$1({ message: `Indexer has not yet indexed transaction ${hash}` })));
+			const rawStatus = tx.__typename === "RegularTransaction" ? tx.transactionResult.status : void 0;
+			const status = rawStatus === "FAILURE" || rawStatus === "PARTIAL_SUCCESS" ? rawStatus : "SUCCESS";
+			const identifiers = tx.__typename === "RegularTransaction" ? tx.identifiers : [];
+			const fees = tx.__typename === "RegularTransaction" ? BigInt(tx.fees.paidFees) : null;
+			return {
+				hash: tx.hash,
+				block: {
+					hash: tx.block.hash,
+					height: tx.block.height,
+					timestamp: tx.block.timestamp
+				},
+				status,
+				identifiers,
+				fees
+			};
+		}).pipe(require_dist.provide(queryClientLayer), require_dist.scoped, require_dist.retry$1({
+			schedule: require_dist.exponential(require_dist.seconds(1)).pipe(require_dist.either(require_dist.spaced(require_dist.seconds(10))), require_dist.jittered, require_dist.upTo(retryWindow)),
+			while: (error) => error instanceof TransactionHistoryError$1
+		}), require_dist.mapError$2((error) => error instanceof TransactionHistoryError$1 ? error : new TransactionHistoryError$1({
+			message: `Failed to fetch transaction metadata for ${hash}`,
+			cause: error
+		})))
+	};
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v2/CoinsAndBalances.js
+const chooseCoin = (coins) => coins.filter((coin) => coin.value > 0n).toSorted((a, b) => Number(a.value - b.value)).at(0);
+const FAKE_NONCE = "0".repeat(64);
+const makeDefaultCoinsAndBalancesCapability = (_config, getContext) => {
+	const getWalletBalance = (state, time) => {
+		return state.state.walletBalance(time);
+	};
+	const getGenerationInfo = (state, coin) => {
+		const info = state.state.generationInfo(coin);
+		return info && info.dtime ? {
+			...info,
+			dtime: /* @__PURE__ */ new Date(+info.dtime)
+		} : info;
+	};
+	const resolveTime = (state, time) => time ?? state.state.syncTime;
+	const toFullInfo = (state, coins, time) => coins.flatMap((coin) => {
+		const genInfo = getGenerationInfo(state, coin);
+		return genInfo ? [{
+			token: coin,
+			...getFullDustInfo(state.state.params, genInfo, coin, time)
+		}] : [];
+	});
+	const availableDustTokens = (state) => {
+		const pendingSpends = new Set([...state.pendingDust.values()].map((coin) => coin.nonce));
+		return require_dist.pipe(state.state.utxos, require_dist.filter$1((coin) => !pendingSpends.has(coin.nonce)));
+	};
+	const getAvailableCoins = (state, time) => toFullInfo(state, availableDustTokens(state), resolveTime(state, time));
+	const getPendingCoins = (state, time) => toFullInfo(state, state.pendingDust, resolveTime(state, time));
+	const getTotalCoins = (state, time) => {
+		const effectiveTime = resolveTime(state, time);
+		return [...getAvailableCoins(state, effectiveTime), ...getPendingCoins(state, effectiveTime)];
+	};
+	const getAvailableCoinsWithGeneratedDust = (state, currentTime) => getAvailableCoins(state, currentTime).map((info) => ({
+		token: info.token,
+		value: info.generatedNow
+	}));
+	const getFullDustInfo = (parameters, genInfo, coin, currentTime) => {
+		const generatedValue = _midnightntwrk_ledger_v9.updatedValue(coin.ctime, coin.initialValue, genInfo, currentTime, parameters);
+		return {
+			dtime: genInfo.dtime,
+			maxCap: genInfo.value * parameters.nightDustRatio,
+			maxCapReachedAt: require_dist.addSeconds(coin.ctime, parameters.timeToCapSeconds),
+			generatedNow: generatedValue,
+			rate: genInfo.value * parameters.generationDecayRate
+		};
+	};
+	const estimateDustGeneration = (state, nightUtxos, currentTime) => {
+		const dustPublicKey = getContext().keysCapability.getPublicKey(state);
+		return require_dist.pipe(nightUtxos, require_dist.map$3((utxo) => {
+			const genInfo = fakeGenerationInfo(utxo, dustPublicKey);
+			const fakeDustCoin = fakeDustToken(dustPublicKey, utxo);
+			return {
+				utxo,
+				dust: getFullDustInfo(state.state.params, genInfo, fakeDustCoin, currentTime)
+			};
+		}));
+	};
+	/** Create a fake generation info for a given Utxo. It allows to estimate the Dust generation from it */
+	const fakeGenerationInfo = (utxo, dustPublicKey) => {
+		return {
+			value: utxo.value,
+			owner: dustPublicKey,
+			nonce: FAKE_NONCE,
+			dtime: void 0
+		};
+	};
+	/** Create a fake dust coin for a given Utxo. It allows to estimate full details of the Dust generation from it */
+	const fakeDustToken = (dustPublicKey, utxo) => ({
+		initialValue: 0n,
+		owner: dustPublicKey,
+		nonce: 0n,
+		seq: 0,
+		ctime: utxo.ctime,
+		backingNight: "",
+		mtIndex: 0n
+	});
+	const splitNightUtxos = (utxos) => {
+		const [guaranteed, fallible] = require_dist.pipe(utxos, require_dist.sort(require_dist.pipe(require_dist.bigint, require_dist.reverse, require_dist.mapInput((coin) => coin.dust.generatedNow))), require_dist.splitAt(1));
+		return {
+			guaranteed,
+			fallible
+		};
+	};
+	return {
+		getWalletBalance,
+		getAvailableCoins,
+		getPendingCoins,
+		getTotalCoins,
+		getAvailableCoinsWithGeneratedDust,
+		getGenerationInfo,
+		estimateDustGeneration,
+		splitNightUtxos
+	};
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/v2/V2Builder.js
+/**
+* Completes a builder configuration into the one the empty-wallet migration asks for.
+*
+* @remarks
+*   The dust parameters are optional on the builder and required on the migration, and this is the single place that gap
+*   is closed, so the fallback the unconfigured `build` takes and the one {@link V2Builder.withMigrationDefaults} states
+*   explicitly cannot drift apart.
+*/
+const emptyWalletMigrationConfiguration = (configuration) => ({
+	networkId: configuration.networkId,
+	dustParameters: configuration.dustParameters ?? _midnightntwrk_ledger_v9.LedgerParameters.initialParameters().dust
+});
+var V2Builder = class V2Builder {
+	#buildState;
+	constructor(buildState = {}) {
+		this.#buildState = buildState;
+	}
+	withDefaults() {
+		return this.withDefaultTransactionType().withSyncDefaults().withSerializationDefaults().withTransactingDefaults().withCoinsAndBalancesDefaults().withTransactionHistoryDefaults().withKeysDefaults().withStartAuxDefaults().withCoinSelectionDefaults();
+	}
+	withTransactionType() {
+		return new V2Builder({
+			...this.#buildState,
+			transactingCapability: void 0
+		});
+	}
+	withDefaultTransactionType() {
+		return this.withTransactionType();
+	}
+	withSyncDefaults() {
+		return this.withSync(makeDefaultSyncService, makeDefaultSyncCapability);
+	}
+	withSync(syncService, syncCapability) {
+		return new V2Builder({
+			...this.#buildState,
+			syncService,
+			syncCapability,
+			startAux: void 0
+		});
+	}
+	withSerializationDefaults() {
+		return this.withSerialization(makeDefaultV2SerializationCapability);
+	}
+	withSerialization(serializationCapability) {
+		return new V2Builder({
+			...this.#buildState,
+			serializationCapability
+		});
+	}
+	withTransactingDefaults() {
+		return this.withTransacting(makeDefaultTransactingCapability);
+	}
+	withTransacting(transactingCapability) {
+		return new V2Builder({
+			...this.#buildState,
+			transactingCapability
+		});
+	}
+	withCoinSelection(coinSelection) {
+		return new V2Builder({
+			...this.#buildState,
+			coinSelection
+		});
+	}
+	withCoinSelectionDefaults() {
+		return this.withCoinSelection(() => chooseCoin);
+	}
+	withCoinsAndBalancesDefaults() {
+		return this.withCoinsAndBalances(makeDefaultCoinsAndBalancesCapability);
+	}
+	withCoinsAndBalances(coinsAndBalancesCapability) {
+		return new V2Builder({
+			...this.#buildState,
+			coinsAndBalancesCapability
+		});
+	}
+	withTransactionHistoryDefaults() {
+		return this.withTransactionHistory(makeDefaultTransactionHistoryService);
+	}
+	withTransactionHistory(transactionHistoryService) {
+		return new V2Builder({
+			...this.#buildState,
+			transactionHistoryService
+		});
+	}
+	withKeysDefaults() {
+		return this.withKeys(makeDefaultKeysCapability);
+	}
+	withKeys(keysCapability) {
+		return new V2Builder({
+			...this.#buildState,
+			keysCapability
+		});
+	}
+	/**
+	* Uses the default migration: an empty wallet built from nothing.
+	*
+	* @remarks
+	*   This is what an unconfigured builder already does, so calling it changes no behaviour — it states the choice rather
+	*   than inheriting it. Registering this variant as the target of a real fork means calling
+	*   {@link V2Builder.withMigration} with {@link makeCrossLedgerMigration} instead.
+	*
+	*   The parameters the empty dust state is valued against come from the builder configuration when it names them, and
+	*   from the ledger's initial parameters when it does not.
+	*/
+	withMigrationDefaults() {
+		return this.withMigration((configuration) => makeEmptyWalletMigration(emptyWalletMigrationConfiguration(configuration)));
+	}
+	/**
+	* Chooses how this variant produces its first state from the state that preceded it.
+	*
+	* @remarks
+	*   The strategy's input type becomes the variant's `TPreviousState`, which is what the runtime type-checks a
+	*   registration against: a variant declaring it migrates from a ledger-v8 dust wallet cannot be registered after one
+	*   that produces something else.
+	*
+	*   The context the factory reads is a type parameter of the method, exactly as it is for every other capability here,
+	*   rather than the builder's own `TContext`. Naming `TContext` in an argument position would make the builder
+	*   invariant in it, and a chain that has not yet configured every capability — which is how the simulator-backed
+	*   variants are assembled — could then no longer be handed to {@link V2Builder.build}.
+	* @example
+	*   ```typescript
+	*   const forkTarget = new V2Builder().withDefaults().withMigration(makeCrossLedgerMigration);
+	*   ```;
+	*
+	* @param migration Builds the migration from the configuration and the sibling capabilities.
+	*/
+	withMigration(migration) {
+		const capabilities = this.#buildState;
+		return new V2Builder({
+			...capabilities,
+			migration
+		});
+	}
+	build(configuration) {
+		const v2Context = this.#buildContextFromBuildState(configuration);
+		const migration = this.#resolveMigration(configuration, () => v2Context);
+		return {
+			__polyTag__: V2Tag,
+			coinsAndBalances: v2Context.coinsAndBalancesCapability,
+			keys: v2Context.keysCapability,
+			serialization: v2Context.serializationCapability,
+			transactionHistory: v2Context.transactionHistoryService,
+			startAux: this.#resolveStartAux(),
+			start(context) {
+				return require_dist.gen(function* () {
+					return new RunningV2Variant(yield* require_dist.Scope, context, v2Context);
+				});
+			},
+			migrateState: (previousState) => migration.migrate(previousState).pipe(require_dist.mapError$2((error) => new require_dist.WalletRuntimeError({
+				message: "Failed to migrate dust wallet state into this variant",
+				cause: error
+			}))),
+			deserializeState: (serialized) => {
+				return v2Context.serializationCapability.deserialize(null, serialized);
+			}
+		};
+	}
+	/**
+	* Uses the default derivation: this ledger version's own dust secret key, built from the seed.
+	*
+	* @remarks
+	*   Constrained to a builder whose sync is started with a `DustSecretKey`, because that is the only start-aux this
+	*   derivation can produce. A builder whose sync expects something else has to say how that is derived, or say
+	*   nothing and be refused at `build`.
+	* @returns A builder that produces a variant able to start sync from a seed alone.
+	*/
+	withStartAuxDefaults() {
+		return this.withStartAux({ fromSeed: (seed) => _midnightntwrk_ledger_v9.DustSecretKey.fromSeed(seed) });
+	}
+	/**
+	* Chooses how this variant derives the key material its synchronization is started with from a seed.
+	*
+	* @param startAux The derivation.
+	* @returns A builder that produces a variant able to start sync from a seed alone.
+	*/
+	withStartAux(startAux) {
+		return new V2Builder({
+			...this.#buildState,
+			startAux
+		});
+	}
+	/**
+	* Resolves the configured derivation, refusing a builder that never stated one.
+	*
+	* @remarks
+	*   Kept out of the structural completeness check because it is typed rather than merely present: a builder whose sync
+	*   expects one kind of key material and whose derivation produces another is a wallet that would be silently handed
+	*   key objects of the wrong shape at the first migration.
+	*/
+	#resolveStartAux() {
+		const configured = this.#buildState.startAux;
+		if (configured === void 0) throw new Error("Not all components are configured in V2Builder: startAux");
+		return configured;
+	}
+	/**
+	* Resolves the configured migration, or the empty-wallet fallback when none was configured.
+	*
+	* @remarks
+	*   The fallback is written as a nullary function on purpose. It ignores whatever preceded it — it builds an empty
+	*   wallet from nothing — which makes it a valid migration from _any_ previous state, but a `StateMigration<null>`
+	*   value could only be widened to `StateMigration<TPreviousState>` through a cast. Declaring no parameter says the
+	*   same thing to the type system without one.
+	*/
+	#resolveMigration(configuration, getContext) {
+		const configured = this.#buildState.migration;
+		return configured === void 0 ? { migrate: () => makeEmptyWalletMigration(emptyWalletMigrationConfiguration(configuration)).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, serializationCapability, coinSelection, coinsAndBalancesCapability, keysCapability, transactionHistoryService } = this.#buildState;
+		const getContext = () => context;
+		const context = {
+			serializationCapability: serializationCapability(configuration, getContext),
+			syncCapability: syncCapability(configuration, getContext),
+			syncService: syncService(configuration, getContext),
+			transactingCapability: transactingCapability(configuration, getContext),
+			coinsAndBalancesCapability: coinsAndBalancesCapability(configuration, getContext),
+			keysCapability: keysCapability(configuration, getContext),
+			coinSelection: coinSelection(configuration, getContext),
+			transactionHistoryService: transactionHistoryService(configuration, getContext)
+		};
+		return context;
+	}
+};
+const isBuildStateFull = (buildState) => {
+	return [
+		"syncService",
+		"syncCapability",
+		"transactingCapability",
+		"coinSelection",
+		"serializationCapability",
+		"coinsAndBalancesCapability",
+		"keysCapability",
+		"transactionHistoryService"
+	].every((key) => typeof buildState[key] == "function");
+};
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-dust-wallet/dist/DustWallet.js
+/**
+* A dust wallet that registers a variant either side of a protocol boundary and follows the chain across it.
+*
+* @remarks
+*   One wallet, two ledger versions. Before the boundary the V1 variant reads the chain with the ledger version that
+*   produced it; from the boundary the V2 variant does, having been handed identity and a place in the timeline and
+*   nothing else — the dust itself is re-discovered from the indexer's replay, which is what
+*   `test/forkSimulation.test.ts` proves. Which variant is running is the runtime's business, not the application's:
+*   the wallet's public API speaks ledger-v9 throughout, and where the two sides genuinely differ — the key material
+*   each variant's synchronization needs — the wallet resolves it per variant from what it retained.
+*
+*   `DustWallet(configuration)` at the bottom is how this package ships it. `CustomForkingDustWallet` is the same wallet
+*   over builders the caller chooses, and `SingleVariantDustWallet.ts` is the composition that gives up the crossing to
+*   run one variant only.
+*/
+const asV8DustParameters = (parameters) => new _midnight_ntwrk_ledger_v8.DustParameters(parameters.nightDustRatio, parameters.generationDecayRate, parameters.dustGracePeriodSeconds);
+/**
+* The same dust rates, as ledger-v9's parameters object.
+*
+* @remarks
+*   The mirror of {@link asV8DustParameters}, and needed for the same reason: an empty state of either variant is
+*   parameterised, and the rates a caller names are plain numbers rather than either ledger's object. Ordinarily the
+*   ledger-v9 side's empty state is the migration's business; a wallet that starts on V2 because the chain said so has
+*   no migration to get one from, and builds its own here.
+* @param parameters The rates to express.
+* @returns The same generation and decay rates, as a ledger-v9 `DustParameters`.
+*/
+const asV9DustParameters = (parameters) => new _midnightntwrk_ledger_v9.DustParameters(parameters.nightDustRatio, parameters.generationDecayRate, parameters.dustGracePeriodSeconds);
+/**
+* Builds a dust 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, which for dust is load-bearing rather than tidy — see
+*   {@link SelfConfiguredDustVariant}.
+* @example
+*   ```typescript
+*   const Wallet = CustomForkingDustWallet(
+*     { forks },
+*     { builder: new V1Builder().withDefaults(), configuration: v1Configuration },
+*     { builder: new V2Builder().withDefaults().withMigration(...), configuration: v2Configuration },
+*   );
+*   const wallet = Wallet.startWithSeed(seed, dustParameters);
+*   ```;
+*
+* @param configuration What the wallet layer needs: 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 CustomForkingDustWallet(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();
+	/** What the rates are when a caller names none: the ledger's own initial parameters. */
+	const defaultRates = _midnightntwrk_ledger_v9.LedgerParameters.initialParameters().dust;
+	/** Nothing retained: never started, or stopped. */
+	const noKeys = {
+		v8: require_dist.none(),
+		v9: require_dist.none()
+	};
+	/** Both sides, derived from one seed. */
+	const keysFromSeed = (seed) => ({
+		v8: require_dist.some(variants[V1Tag].variant.startAux.fromSeed(seed)),
+		v9: require_dist.some(variants[V2Tag].variant.startAux.fromSeed(seed))
+	});
+	/**
+	* What a variant can be started with, or why it cannot be.
+	*
+	* @remarks
+	*   Two different failures, deliberately distinguished: a wallet that was never started (or has been stopped) holds
+	*   nothing at all, while one started with the other side's key object holds something it must not use here.
+	*/
+	const auxFor = (retained, side, variantTag) => require_dist.fromOption(side, () => new require_dist.MissingStartAuxError({
+		message: require_dist.isNone(retained.v8) && require_dist.isNone(retained.v9) ? "This wallet holds no key material: it has not been started, or it has been stopped. Start it before asking it to synchronize or to pay a fee." : `This wallet holds key material of the other protocol version only, which the variant ${String(variantTag)} cannot use: a Dust secret key belongs to one ledger version's runtime. Start this wallet with material that answers for either side — startWithSeed(seed), or startWithKeys({ v8, v9 }).`,
+		variantTag
+	}));
+	const v8Aux = (retained) => auxFor(retained, retained.v8, V1Tag);
+	const v9Aux = (retained) => auxFor(retained, retained.v9, V2Tag);
+	/**
+	* The protocol versions each variant owns, and the version a transaction it builds is stamped with.
+	*
+	* @remarks
+	*   The stamp is the 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));
+	/**
+	* How long a start waits for the chain to say which version it is on.
+	*
+	* @remarks
+	*   Short, because what is being bought is small: the alternative to an answer is the hand-over this wallet has always
+	*   done, which costs one migration and no correctness on a chain that produces events. It is a ceiling rather than a
+	*   typical cost — an unreachable indexer refuses a connection long before this — and it exists so that a probe which
+	*   neither answers nor fails cannot hold a start open indefinitely.
+	*/
+	const probeTimeout = require_dist.seconds(5);
+	/**
+	* The variant the chain's current version belongs to, or nothing.
+	*
+	* @remarks
+	*   Nothing covers every way the question can fail to produce an answer, and they are deliberately not distinguished:
+	*   no probe configured, a probe that rejected, a probe that outlived the wallet's patience, or a version no
+	*   registered variant claims. Each means the same thing to a caller — start where a wallet with no history starts —
+	*   and none of them is a reason to fail.
+	*/
+	const probedStart = configuration.chainVersionProbe === void 0 ? require_dist.succeedNone : require_dist.pipe(require_dist.tryPromise(configuration.chainVersionProbe), require_dist.timeout(probeTimeout), require_dist.map$2((version) => require_dist.map$5(BaseWallet.variantFor(version), (variant) => ({
+		version,
+		variant
+	}))), require_dist.orElseSucceed(() => require_dist.none()));
+	/**
+	* A fresh state of the variant a probed start begins at, recording the version the chain reported.
+	*
+	* @remarks
+	*   Built exactly as the head-variant boot path builds its own — an empty state of that variant, valued against that
+	*   ledger version's rebuild of the rates the caller named — and then annotated with the observed version, which is
+	*   what keeps a variant from starting outside its own activation range and signalling backwards on sight.
+	*/
+	const freshStateAt = (variant, keys, rates, version) => require_dist.getVersionedVariantTag(variant) === V2Tag ? CoreWallet$1.withProtocolVersion(CoreWallet$1.initEmpty(asV9DustParameters(rates), keys.v9, configuration.networkId), version) : CoreWallet.withProtocolVersion(CoreWallet.initEmpty(asV8DustParameters(rates), keys.v8, configuration.networkId), version);
+	return class ForkingDustWalletImplementation extends BaseWallet {
+		static configuration = configuration;
+		/**
+		* Starts at the variant the chain says it is on, or at the head variant when it does not say.
+		*
+		* @remarks
+		*   The second branch is the whole of this wallet's previous behaviour, unchanged and reached whenever the chain was
+		*   not asked or did not answer: the V1 variant, an empty state valued against the ledger-v8 rebuild of the rates
+		*   the caller named, and a hand-over on the first batch that reports a version it does not own.
+		* @param keys One ledger version's dust key per side of the boundary, since either side may be the one that runs.
+		* @param rates The rates the caller named, which whichever empty state is built is valued against.
+		* @returns The started wallet.
+		*/
+		static #startProbed(keys, rates) {
+			return require_dist.pipe(probedStart, require_dist.map$2(require_dist.match$1({
+				onNone: () => ForkingDustWalletImplementation.startFirst(ForkingDustWalletImplementation, CoreWallet.initEmpty(asV8DustParameters(rates), keys.v8, configuration.networkId)),
+				onSome: ({ version, variant }) => ForkingDustWalletImplementation.startAtVariant(ForkingDustWalletImplementation, variant, freshStateAt(variant, keys, rates, version))
+			})), require_dist.runPromise$1);
+		}
+		static async startWithSeed(seed, dustParameters = defaultRates) {
+			const derived = keysFromSeed(require_dist.WalletSeed(seed));
+			const wallet = await ForkingDustWalletImplementation.#startProbed({
+				v8: require_dist.getOrThrow(derived.v8),
+				v9: require_dist.getOrThrow(derived.v9)
+			}, dustParameters);
+			wallet.#retainKeys(derived);
+			return wallet;
+		}
+		static async startWithKeys(keys, dustParameters = defaultRates) {
+			const wallet = await ForkingDustWalletImplementation.#startProbed(keys, dustParameters);
+			wallet.#retainKeys({
+				v8: require_dist.some(keys.v8),
+				v9: require_dist.some(keys.v9)
+			});
+			return wallet;
+		}
+		static tryRestore(serializedState) {
+			return variantForSnapshot(serializedState, (version) => ForkingDustWalletImplementation.variantFor(version), require_dist.head(ForkingDustWalletImplementation.allVariants())).pipe(require_dist.flatMap$4((variant) => {
+				const deserialized = variant.variant.deserializeState(serializedState);
+				return require_dist.map$6(deserialized, (state) => ForkingDustWalletImplementation.startAtVariant(ForkingDustWalletImplementation, variant, state));
+			}));
+		}
+		static restore(serializedState) {
+			return require_dist.getOrThrow$1(ForkingDustWalletImplementation.tryRestore(serializedState));
+		}
+		state;
+		/**
+		* What the application started this wallet with, kept so synchronization can be started again.
+		*
+		* @remarks
+		*   A migration starts a fresh variant whose sync has never run, and sync needs key material that is deliberately
+		*   absent from anything the wallet serializes. A retained seed answers for both variants; a retained key object
+		*   answers only for the ledger-v9 one, which is the ledger version this wallet's public API speaks. Cleared by
+		*   {@link stop} so a stopped wallet cannot be resurrected by a late activation.
+		*/
+		#retainedKeys = require_dist.unsafeMake(noKeys);
+		/** Remembers key material for both sides of the boundary. */
+		#retainKeys(keys) {
+			require_dist.set(this.#retainedKeys, keys).pipe(require_dist.runSync);
+		}
+		/**
+		* Starts synchronization on a variant that has just become current, with key material it can use.
+		*
+		* @param running The variant to start.
+		* @param auxFor That variant's own resolution of what it can be started with.
+		*/
+		#resumeSyncOn(running, keysFor) {
+			return require_dist.get$1(this.#retainedKeys).pipe(require_dist.flatMap$1((retained) => require_dist.isNone(retained.v8) && require_dist.isNone(retained.v9) ? require_dist._void : require_dist.toEffect(keysFor(retained)).pipe(require_dist.flatMap$1((aux) => running.startSyncInBackground(aux)))));
+		}
+		/** One synchronization step on a variant, with key material it can use. */
+		#stepSyncOn(running, keysFor) {
+			return require_dist.get$1(this.#retainedKeys).pipe(require_dist.flatMap$1((retained) => require_dist.isNone(retained.v8) && require_dist.isNone(retained.v9) ? require_dist._void : require_dist.toEffect(keysFor(retained)).pipe(require_dist.flatMap$1((aux) => running.sync(aux)))));
+		}
+		/**
+		* Whether the activation watcher has been registered.
+		*
+		* @remarks
+		*   Registration is per wallet, not per `start`: watchers accumulate, so registering on every call would restart sync
+		*   once per historical `start` on the next activation. Flipped with `getAndSet` so concurrent `start` calls cannot
+		*   both observe it unset.
+		*/
+		#watcherRegistered = require_dist.unsafeMake(false);
+		constructor(runtime, scope) {
+			super(runtime, scope);
+			this.state = this.rawState.pipe(rxjs.map((emission) => emission.variantTag === V2Tag ? DustWalletState.fromVariant(variants[V2Tag].variant, emission) : DustWalletState.fromVariant(variants[V1Tag].variant, emission)), rxjs.shareReplay({
+				refCount: true,
+				bufferSize: 1
+			}));
+		}
+		/**
+		* Everything a start does once the wallet holds its key material: watch for the next variant, synchronize on this
+		* one.
+		*
+		* @remarks
+		*   The same work whichever start was called — what the three differ in is only what they retained a moment earlier —
+		*   so it is stated once. The watcher is registered before the first dispatch and only once per wallet:
+		*   `onVariantActivation` resolves only after its subscription is live, so an activation racing a start is queued
+		*   rather than missed, and watchers accumulate, so registering per call would restart synchronization once per
+		*   historical start.
+		*
+		*   Both branches of the dispatch resolve their key from what was retained rather than from what the caller passed,
+		*   because the variant that is current is not the caller's to know: a wallet restored below the boundary is on the
+		*   ledger-v8 one whatever the application holds.
+		*/
+		#startSynchronizing() {
+			return require_dist.gen(this, function* () {
+				if (!(yield* require_dist.getAndSet(this.#watcherRegistered, true))) yield* this.runtime.onVariantActivation({
+					[V1Tag]: (v1) => this.#resumeSyncOn(v1, v8Aux),
+					[V2Tag]: (v2) => this.#resumeSyncOn(v2, v9Aux)
+				});
+				yield* this.runtime.dispatch({
+					[V1Tag]: (v1) => this.#resumeSyncOn(v1, v8Aux),
+					[V2Tag]: (v2) => this.#resumeSyncOn(v2, v9Aux)
+				});
+			});
+		}
+		/**
+		* Starts background synchronization on whichever variant is current, and keeps the key for the next one.
+		*
+		* @remarks
+		*   The key is ledger-v9's, so it is retained against that variant alone and answers for it alone. A wallet still on
+		*   the V1 variant is started from whatever it holds for _that_ side — which a wallet built from a seed, or from
+		*   both versions' keys, can always answer and one holding only this cannot.
+		*
+		*   That is the position of a wallet restored from a snapshot written below the boundary: a snapshot carries no key
+		*   material, so this key leaves it with nothing the running variant can use, and it says so rather than pretending
+		*   to have started. {@link ForkingDustWallet.startWithSeed} and {@link ForkingDustWallet.startWithKeys} are the same
+		*   wallet started with material that answers for either side.
+		* @param secretKey The ledger-v9's dust secret key.
+		*/
+		start(secretKey) {
+			return require_dist.gen(this, function* () {
+				yield* require_dist.update(this.#retainedKeys, (retained) => ({
+					...retained,
+					v9: require_dist.some(secretKey)
+				}));
+				yield* this.#startSynchronizing();
+			}).pipe(require_dist.runPromise$1);
+		}
+		startWithSeed(seed) {
+			return require_dist.gen(this, function* () {
+				yield* require_dist.set(this.#retainedKeys, keysFromSeed(require_dist.WalletSeed(seed)));
+				yield* this.#startSynchronizing();
+			}).pipe(require_dist.runPromise$1);
+		}
+		startWithKeys(keys) {
+			return require_dist.gen(this, function* () {
+				yield* require_dist.set(this.#retainedKeys, {
+					v8: require_dist.some(keys.v8),
+					v9: require_dist.some(keys.v9)
+				});
+				yield* this.#startSynchronizing();
+			}).pipe(require_dist.runPromise$1);
+		}
+		async stop() {
+			require_dist.set(this.#retainedKeys, noKeys).pipe(require_dist.runSync);
+			await super.stop();
+		}
+		/**
+		* Runs one synchronization step on whichever variant is current.
+		*
+		* @remarks
+		*   Available on both sides of the boundary: the V1 variant is stepped with a key derived from what the wallet
+		*   retained, exactly as background synchronization is.
+		* @param secretKey The ledger-v9's dust secret key.
+		*/
+		stepSync(secretKey) {
+			return this.runtime.dispatch({
+				[V1Tag]: (v1) => this.#stepSyncOn(v1, v8Aux),
+				[V2Tag]: (v2) => v2.sync(secretKey)
+			}).pipe(require_dist.runPromise$1);
+		}
+		/**
+		* The key material the variant that is current can use, from what this wallet retained.
+		*
+		* @remarks
+		*   Fee payment selects dust the wallet owns, so it needs the same secret synchronization does. A wallet that was
+		*   never started, or one holding a key object of the other ledger version, has none the current variant can use
+		*   and says so by name.
+		*/
+		#requireAux(keysFor) {
+			return require_dist.get$1(this.#retainedKeys).pipe(require_dist.flatMap$1((retained) => require_dist.toEffect(keysFor(retained))));
+		}
+		createDustGenerationTransaction(currentTime, ttl, nightUtxos, nightVerifyingKey, dustReceiverAddress) {
+			return this.runtime.dispatch({
+				[V1Tag]: (v1) => require_dist.toEffect(require_v8Signatures.lowerSignatureVerifyingKey(nightVerifyingKey)).pipe(require_dist.flatMap$1((key) => v1.createDustGenerationTransaction(currentTime, ttl, nightUtxos, key, dustReceiverAddress)), require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unproven", tx, v8Stamp))),
+				[V2Tag]: (v2) => v2.createDustGenerationTransaction(currentTime, ttl, nightUtxos, nightVerifyingKey, dustReceiverAddress).pipe(require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unproven", tx, v9Stamp)))
+			}).pipe(require_dist.runPromise$1);
+		}
+		/**
+		* Splits Night UTxOs into the ones a registration puts in its guaranteed and fallible sections.
+		*
+		* @remarks
+		*   Available on both sides of the boundary, and deliberately not part of the seam above: it takes and returns plain
+		*   data — UTxOs, dust generation readings, a fee amount — and touches no transaction at all, so there is nothing
+		*   here that needs proving and nothing the V1 variant cannot answer.
+		*/
+		splitNightUtxosForDustRegistration(currentTime, nightUtxos, isRegistration) {
+			return this.runtime.dispatch({
+				[V1Tag]: (v1) => v1.splitNightUtxosForDustRegistration(currentTime, nightUtxos, isRegistration),
+				[V2Tag]: (v2) => v2.splitNightUtxosForDustRegistration(currentTime, nightUtxos, isRegistration)
+			}).pipe(require_dist.runPromise$1);
+		}
+		attachDustRegistration(transaction, currentTime, nightVerifyingKey, dustReceiverAddress, feePayment) {
+			return this.runtime.dispatch({
+				[V1Tag]: (v1) => require_dist.all([v8Tx(transaction), require_dist.toEffect(require_v8Signatures.lowerSignatureVerifyingKey(nightVerifyingKey))]).pipe(require_dist.flatMap$1(([tx, key]) => v1.attachDustRegistration(tx, currentTime, key, dustReceiverAddress, feePayment)), require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unproven", tx, v8Stamp))),
+				[V2Tag]: (v2) => v9Tx(transaction).pipe(require_dist.flatMap$1((tx) => v2.attachDustRegistration(tx, currentTime, nightVerifyingKey, dustReceiverAddress, feePayment)), require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unproven", tx, v9Stamp)))
+			}).pipe(require_dist.runPromise$1);
+		}
+		addDustGenerationSignature(transaction, signature) {
+			return this.runtime.dispatch({
+				[V1Tag]: (v1) => require_dist.all([v8Tx(transaction), require_dist.toEffect(require_v8Signatures.lowerSignature(signature))]).pipe(require_dist.flatMap$1(([tx, lowered]) => v1.addDustGenerationSignature(tx, lowered)), require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unproven", tx, v8Stamp))),
+				[V2Tag]: (v2) => v9Tx(transaction).pipe(require_dist.flatMap$1((tx) => v2.addDustGenerationSignature(tx, signature)), require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unproven", tx, v9Stamp)))
+			}).pipe(require_dist.runPromise$1);
+		}
+		addDustRegistrationSignature(transaction, signature) {
+			return this.runtime.dispatch({
+				[V1Tag]: (v1) => require_dist.all([v8Tx(transaction), require_dist.toEffect(require_v8Signatures.lowerSignature(signature))]).pipe(require_dist.flatMap$1(([tx, lowered]) => v1.addDustRegistrationSignature(tx, lowered)), require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unproven", tx, v8Stamp))),
+				[V2Tag]: (v2) => v9Tx(transaction).pipe(require_dist.flatMap$1((tx) => v2.addDustRegistrationSignature(tx, signature)), require_dist.map$2((tx) => require_dist.WalletTransaction.adopt("Unproven", tx, v9Stamp)))
+			}).pipe(require_dist.runPromise$1);
+		}
+		calculateFee(transactions) {
+			return this.runtime.dispatch({
+				[V1Tag]: (v1) => require_dist.forEach(transactions, v8Tx).pipe(require_dist.flatMap$1((txs) => v1.calculateFee(txs))),
+				[V2Tag]: (v2) => require_dist.forEach(transactions, v9Tx).pipe(require_dist.flatMap$1((txs) => v2.calculateFee(txs)))
+			}).pipe(require_dist.runPromise$1);
+		}
+		estimateFee(transactions, ttl, currentTime) {
+			const effectiveTtl = ttl ?? new Date(Date.now() + 3600 * 1e3);
+			return this.runtime.dispatch({
+				[V1Tag]: (v1) => require_dist.all([this.#requireAux(v8Aux), require_dist.forEach(transactions, v8Tx)]).pipe(require_dist.flatMap$1(([key, txs]) => v1.estimateFee(key, txs, effectiveTtl, currentTime))),
+				[V2Tag]: (v2) => require_dist.all([this.#requireAux(v9Aux), require_dist.forEach(transactions, v9Tx)]).pipe(require_dist.flatMap$1(([key, txs]) => v2.estimateFee(key, txs, effectiveTtl, currentTime)))
+			}).pipe(require_dist.runPromise$1);
+		}
+		balanceTransactions(transactions, ttl, currentTime) {
+			return this.runtime.dispatch({
+				[V1Tag]: (v1) => require_dist.all([this.#requireAux(v8Aux), require_dist.forEach(transactions, v8Tx)]).pipe(require_dist.flatMap$1(([key, txs]) => v1.balanceTransactions(key, txs, ttl, currentTime)), require_dist.map$2(({ transaction, blockData }) => ({
+					transaction: require_dist.WalletTransaction.adopt("Unproven", transaction, v8Stamp),
+					blockData
+				}))),
+				[V2Tag]: (v2) => require_dist.all([this.#requireAux(v9Aux), require_dist.forEach(transactions, v9Tx)]).pipe(require_dist.flatMap$1(([key, txs]) => v2.balanceTransactions(key, txs, ttl, currentTime)), require_dist.map$2(({ transaction, blockData }) => ({
+					transaction: require_dist.WalletTransaction.adopt("Unproven", transaction, v9Stamp),
+					blockData
+				})))
+			}).pipe(require_dist.runPromise$1);
+		}
+		/**
+		* Un-records a transaction this wallet paid the fee for, releasing the dust it had booked.
+		*
+		* @remarks
+		*   A transaction built on the other side of the boundary cannot have had its fee paid by the current variant, so
+		*   there is no dust of it to release and this resolves having done nothing. That is the one place a version
+		*   mismatch is not an error: the facade reverts all three wallets together when a submission fails, and a refusal
+		*   here would strand that whole path over a transaction this wallet was never holding anything for.
+		* @param transaction The transaction to un-record.
+		*/
+		revertTransaction(transaction) {
+			return this.runtime.dispatch({
+				[V1Tag]: (v1) => require_dist.match$2(require_dist.WalletTransaction.unwrapWithin(transaction, v8Epoch), {
+					onLeft: () => require_dist._void,
+					onRight: (tx) => v1.revertTransaction(tx)
+				}),
+				[V2Tag]: (v2) => require_dist.match$2(require_dist.WalletTransaction.unwrapWithin(transaction, v9Epoch), {
+					onLeft: () => require_dist._void,
+					onRight: (tx) => v2.revertTransaction(tx)
+				})
+			}).pipe(require_dist.runPromise$1);
+		}
+		waitForSyncedState(allowedGap = 0n) {
+			return rxjs.firstValueFrom(this.state.pipe(rxjs.filter((state) => state.state.progress.isCompleteWithin(allowedGap))));
+		}
+		async waitForGeneratedDust(nightUtxos, requiredAmount, clock, opts) {
+			if (nightUtxos.length === 0) throw Error("At least one Night UTXO is required.");
+			if (requiredAmount <= 0n) return;
+			const timeoutMs = opts?.timeoutMs ?? 3e5;
+			await rxjs.firstValueFrom(rxjs.combineLatest([this.state, rxjs.timer(0, 1e3)]).pipe(rxjs.filter(([dustState]) => claimableFeePayment(dustState, nightUtxos, clock.now()) >= requiredAmount), rxjs.timeout({ first: timeoutMs })));
+		}
+		serializeState() {
+			return rxjs.firstValueFrom(this.state).then((state) => state.serialize());
+		}
+		getAddress() {
+			return rxjs.firstValueFrom(this.state).then((state) => state.address);
+		}
+	};
+}
+/**
+* Builds the dust wallet this package ships: the default variant either side of `configuration.forks.v9`.
+*
+* @remarks
+*   Both variants read the chain through the indexer's dust event subscription and record transaction history in the same
+*   storage. Each is built from the same application configuration, because what they ask for happens to coincide —
+*   with one exception the type system cannot police: `dustParameters` names a ledger type, and the two ledgers'
+*   `DustParameters` are structurally identical, so it is passed only to the variant it belongs to.
+*
+*   **The V1 variant syncs by event replay only.** The projections fast-sync path is a ledger-v9 capability: it needs
+*   four `DustLocalState` APIs that no published ledger-v8 has. That is a permanent property of the V1 variant, not a
+*   gap to be closed.
+*
+*   **Fee-paying operations work on either side of the boundary**: the active variant answers with its own ledger's
+*   objects, and every result travels as a handle stamped with the epoch that 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 DustWallet(configuration) {
+	const dustParameters = configuration.dustParameters ?? _midnightntwrk_ledger_v9.LedgerParameters.initialParameters().dust;
+	return CustomForkingDustWallet({
+		...configuration,
+		chainVersionProbe: configuration.chainVersionProbe ?? require_dist.makeIndexerChainVersionProbe(configuration)
+	}, {
+		builder: new V1Builder().withDefaults(),
+		configuration: {
+			...configuration,
+			dustParameters: asV8DustParameters(dustParameters)
+		}
+	}, {
+		builder: new V2Builder().withDefaults().withMigration(() => makeCrossLedgerMigration({ dustParameters })),
+		configuration
+	});
+}
+//#endregion
+exports.BackgroundRepeat = BackgroundRepeat;
+exports.CustomDustWallet = CustomDustWallet;
+exports.CustomForkingDustWallet = CustomForkingDustWallet;
+exports.DustSectionSchema = DustSectionSchema;
+exports.DustSectionSchema$1 = DustSectionSchema;
+exports.DustWallet = DustWallet;
+exports.DustWalletState = DustWalletState;
+exports.SecretKeysResource = SecretKeysResource;
+exports.UnsupportedSnapshotVersionError = UnsupportedSnapshotVersionError;
+exports.annotateVersion = annotateVersion;
+exports.asV8DustParameters = asV8DustParameters;
+exports.asV9DustParameters = asV9DustParameters;
+exports.claimableFeePayment = claimableFeePayment;
+exports.createDustUtxoUpdates = createDustUtxoUpdates;
+exports.doEventlessSync = doEventlessSync;
+exports.makeDefaultSyncCapability = makeDefaultSyncCapability;
+exports.makeDefaultSyncService = makeDefaultSyncService;
+exports.makeEventLessSyncCapability = makeEventLessSyncCapability;
+exports.makeEventLessSyncService = makeEventLessSyncService;
+exports.makeIndexerSyncService = makeIndexerSyncService;
+exports.makeSimulatorSyncCapability = makeSimulatorSyncCapability;
+exports.makeSimulatorSyncService = makeSimulatorSyncService;
+exports.matchedDustSpends = matchedDustSpends;
+exports.mergeDustSections = mergeDustSections;
+exports.mergeDustSections$1 = mergeDustSections;
+exports.nullifierPhaseAppliedIndex = nullifierPhaseAppliedIndex;
+exports.nullifierPhaseProgress = nullifierPhaseProgress;
+exports.peekProtocolVersion = peekProtocolVersion;
+exports.splitAtVersionBoundary = splitAtVersionBoundary;