@laceio/sdk 0.1.1 → 0.1.2-canary.0

package/dist/dist-nTZ70qj7.cjs

@@ -0,0 +1,1306 @@
+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");
+const require_dist$1 = require("./dist-DqJfSlTd.cjs");
+const require_dist$2 = require("./dist-Dcsxh3be.cjs");
+const require_dist$3 = require("./dist-CykEjYEX.cjs");
+let rxjs = require("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-facade/dist/transaction.js
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+/**
+* The key under which a transaction's history entry is stored.
+*
+* Prefer the ledger transaction hash — it's the canonical chain identifier and the value the indexer reports a
+* confirmed tx under. `transactionHash()` is only defined for proven + signed + bound transactions, though; it throws
+* for the other variants, notably the proof-erased transactions the simulator produces. In that case fall back to the
+* hex of the tx's serialized bytes: `serialize()` is total over every variant (it's the same encoding used to submit
+* the tx), so a key is always available — unlike `identifiers[0]`, which is an identifier, not a hash of the
+* transaction.
+*
+* Both the submit (pending) and revert (rejected) sides route through this one function so they can never disagree on
+* the key. The fallback is deterministic: the same transaction object yields the same bytes every time, and the
+* auto-revert path reverts the very object it submitted, so the rejected entry lands on the pending entry in place.
+* (Serialization differs across lifecycle states, so this is only stable for a fixed tx — which is exactly the
+* submit→revert flow.)
+*/
+const txHistoryHash = (tx) => {
+	try {
+		return String(tx.transactionHash());
+	} catch {
+		return require__polyfill_buffer_patch.import_buffer.Buffer.from(tx.serialize()).toString("hex");
+	}
+};
+const v9FinalizedTransactionTrait = {
+	areAllTxIdsIncluded(tx, txIds) {
+		const txIdsSet = require_dist.fromIterable$1(tx.identifiers());
+		const expectedIdSet = require_dist.fromIterable$1(txIds);
+		return require_dist.isSubset(txIdsSet, expectedIdSet);
+	},
+	deserialize(serialized) {
+		return _midnightntwrk_ledger_v9.Transaction.deserialize("signature", "proof", "binding", serialized);
+	},
+	firstId(tx) {
+		return tx.identifiers()[0];
+	},
+	hasTTLExpired(tx, creationTime, now) {
+		const defaultShieldedGracePeriod = _midnightntwrk_ledger_v9.LedgerParameters.initialParameters().dust.dustGracePeriodSeconds;
+		const intentTTLs = require_dist.pipe(tx.intents?.values().toArray() ?? [], require_dist.map$3((i) => i.ttl), require_dist.filterMap$1(require_dist.make$1));
+		const hasDustPayments = require_dist.pipe(tx.intents?.values().toArray() ?? [], require_dist.flatMap$2((i) => i.dustActions?.spends ?? []), require_dist.isNonEmptyArray);
+		const hasShieldedOffers = tx.guaranteedOffer != null || (tx.fallibleOffer?.size ?? 0) == 0;
+		const maybeShieldedTTL = hasDustPayments || hasShieldedOffers ? require_dist.pipe(creationTime, require_dist.addDuration(require_dist.seconds(Number(defaultShieldedGracePeriod))), require_dist.of) : require_dist.empty$2();
+		return require_dist.pipe(intentTTLs, require_dist.appendAll(maybeShieldedTTL), (arr) => require_dist.isNonEmptyReadonlyArray(arr) ? require_dist.some(require_dist.min(arr, require_dist.mapInput(require_dist.Date, require_dist.toDate))) : require_dist.none(), require_dist.match$1({
+			onNone: () => false,
+			onSome: (finalTTL) => require_dist.distance(finalTTL, now) > 0
+		}));
+	},
+	ids(tx) {
+		return tx.identifiers();
+	},
+	isOneIncludedInOther(tx, otherTx) {
+		const txIds = require_dist.fromIterable$1(tx.identifiers());
+		const otherTxIds = require_dist.fromIterable$1(otherTx.identifiers());
+		const smallerSize = require_dist.min$1(require_dist.number)(require_dist.size(txIds), require_dist.size(otherTxIds));
+		const intersection$1 = require_dist.intersection(txIds, otherTxIds);
+		return require_dist.size(intersection$1) == smallerSize;
+	},
+	isTx(tx) {
+		return tx instanceof _midnightntwrk_ledger_v9.Transaction;
+	},
+	serialize(tx) {
+		return tx.serialize();
+	}
+};
+/**
+* The ledger-v8's reading of a pending transaction.
+*
+* @remarks
+*   Structurally the same as ledger-v9's — identifiers, a TTL, bytes — against a different ledger version's classes. It
+*   is the classes that make this a separate trait: `instanceof` distinguishes them, each deserializer refuses the
+*   other's bytes, and a grace period is read off that version's own initial parameters.
+*/
+const v8FinalizedTransactionTrait = {
+	areAllTxIdsIncluded(tx, txIds) {
+		return require_dist.isSubset(require_dist.fromIterable$1(tx.identifiers()), require_dist.fromIterable$1(txIds));
+	},
+	deserialize(serialized) {
+		return _midnight_ntwrk_ledger_v8.Transaction.deserialize("signature", "proof", "binding", serialized);
+	},
+	firstId(tx) {
+		return tx.identifiers()[0];
+	},
+	hasTTLExpired(tx, creationTime, now) {
+		const defaultShieldedGracePeriod = _midnight_ntwrk_ledger_v8.LedgerParameters.initialParameters().dust.dustGracePeriodSeconds;
+		const intentTTLs = require_dist.pipe(tx.intents?.values().toArray() ?? [], require_dist.map$3((i) => i.ttl), require_dist.filterMap$1(require_dist.make$1));
+		const hasDustPayments = require_dist.pipe(tx.intents?.values().toArray() ?? [], require_dist.flatMap$2((i) => i.dustActions?.spends ?? []), require_dist.isNonEmptyArray);
+		const hasShieldedOffers = tx.guaranteedOffer != null || (tx.fallibleOffer?.size ?? 0) == 0;
+		const maybeShieldedTTL = hasDustPayments || hasShieldedOffers ? require_dist.pipe(creationTime, require_dist.addDuration(require_dist.seconds(Number(defaultShieldedGracePeriod))), require_dist.of) : require_dist.empty$2();
+		return require_dist.pipe(intentTTLs, require_dist.appendAll(maybeShieldedTTL), (arr) => require_dist.isNonEmptyReadonlyArray(arr) ? require_dist.some(require_dist.min(arr, require_dist.mapInput(require_dist.Date, require_dist.toDate))) : require_dist.none(), require_dist.match$1({
+			onNone: () => false,
+			onSome: (finalTTL) => require_dist.distance(finalTTL, now) > 0
+		}));
+	},
+	ids(tx) {
+		return tx.identifiers();
+	},
+	isOneIncludedInOther(tx, otherTx) {
+		const txIds = require_dist.fromIterable$1(tx.identifiers());
+		const otherTxIds = require_dist.fromIterable$1(otherTx.identifiers());
+		const smallerSize = require_dist.min$1(require_dist.number)(require_dist.size(txIds), require_dist.size(otherTxIds));
+		return require_dist.size(require_dist.intersection(txIds, otherTxIds)) == smallerSize;
+	},
+	isTx(tx) {
+		return tx instanceof _midnight_ntwrk_ledger_v8.Transaction;
+	},
+	serialize(tx) {
+		return tx.serialize();
+	}
+};
+/**
+* Lifts one ledger version's trait onto the handle the facade actually carries.
+*
+* @remarks
+*   The router has already chosen this trait by the version stamped on the handle, so unwrapping at the same epoch is a
+*   restatement of the choice rather than a second one — but it is where a handle that does not belong is refused
+*   rather than handed to a reader that would misread it. A handle it cannot read is reported as not being its
+*   transaction at all, which is precisely what `isTx` is for.
+* @param trait The ledger version's own reading of a transaction.
+* @param epoch The range of protocol versions that ledger version answers for.
+* @returns The same reading, in terms of handles.
+*/
+const overHandles = (trait, epoch) => {
+	const [stamp] = epoch;
+	const carried = (handle) => require_dist.getOrThrow$1(require_dist.WalletTransaction.unwrapWithin(handle, epoch));
+	return {
+		ids: (tx) => trait.ids(carried(tx)),
+		firstId: (tx) => trait.firstId(carried(tx)),
+		areAllTxIdsIncluded: (tx, txIds) => trait.areAllTxIdsIncluded(carried(tx), txIds),
+		isOneIncludedInOther: (tx, otherTx) => trait.isOneIncludedInOther(carried(tx), carried(otherTx)),
+		hasTTLExpired: (tx, creationTime, now) => trait.hasTTLExpired(carried(tx), creationTime, now),
+		serialize: (tx) => trait.serialize(carried(tx)),
+		deserialize: (serialized) => require_dist.WalletTransaction.adopt("Finalized", trait.deserialize(serialized), stamp),
+		isTx: (tx) => require_dist.WalletTransaction.is(tx) && require_dist.match$2(require_dist.WalletTransaction.unwrapWithin(tx, epoch), {
+			onLeft: () => false,
+			onRight: (carried) => trait.isTx(carried)
+		})
+	};
+};
+/**
+* The traits pending transactions are read with, split at the protocol version this chain forks at.
+*
+* @remarks
+*   One trait per ledger version, each reading the handle it is registered for and refusing the other's. That is what
+*   lets a transaction authored before the v9 fork be recognised as stranded once the wallets cross — its bytes can
+*   never be included afterwards — instead of waiting out a TTL for an inclusion that can never happen.
+* @param forkVersion The protocol version this chain forks at.
+* @returns The registry the pending transaction service reads with.
+*/
+const finalizedTransactionTraits = (forkVersion) => require_dist.getOrThrow$1(require_dist.makeRegistryFromActivations(forkVersion > require_dist.MinSupportedVersion ? [{
+	sinceVersion: require_dist.MinSupportedVersion,
+	value: overHandles(v8FinalizedTransactionTrait, require_dist.epochOf(require_dist.MinSupportedVersion, forkVersion))
+}, {
+	sinceVersion: forkVersion,
+	value: overHandles(v9FinalizedTransactionTrait, require_dist.epochOf(forkVersion, forkVersion))
+}] : [{
+	sinceVersion: require_dist.MinSupportedVersion,
+	value: overHandles(v9FinalizedTransactionTrait, require_dist.epochOf(require_dist.MinSupportedVersion, require_dist.MinSupportedVersion))
+}]));
+//#endregion
+//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-facade/dist/index.js
+/**
+* Why the wallet gave up on a transaction, for the history entry.
+*
+* @remarks
+*   A chain rejection speaks for itself through the entry's status; an orphaned transaction has no chain verdict at all,
+*   so the entry is the only place the reason can be recorded.
+*/
+const rejectionReason = (result) => result.status === "ORPHANED_BY_FORK" ? "orphaned-by-protocol-upgrade" : void 0;
+/**
+* Full entry schema for transaction history. The common entry data and wallet-specific sections (`shielded`,
+* `unshielded`, `dust`) live on every entry regardless of lifecycle; the `lifecycle` field is the only discriminator.
+* Pass this to `InMemoryTransactionHistoryStorage` to enable serialize/restore.
+*/
+const WalletEntrySchema = require_dist.extendEntrySchema({
+	shielded: require_dist.optional(require_dist$2.ShieldedSectionSchema$1),
+	unshielded: require_dist.optional(require_dist$3.UnshieldedSectionSchema$1),
+	dust: require_dist.optional(require_dist$1.DustSectionSchema$1)
+});
+const isPendingWalletEntry = (entry) => entry.lifecycle.status === "pending";
+const isFinalizedWalletEntry = (entry) => entry.lifecycle.status === "finalized";
+/**
+* Merge two wallet entries arriving under the same hash. Treats the entry as `T × lifecycle` per the storage model:
+*
+* - **Shared scalar facts about the tx** (`protocolVersion`, `status`, `timestamp`, `fees`) — first writer wins. Once any
+*   wallet has set the value, later writes are no-ops for these fields. This is correct because the value is the same
+*   across all wallets (it's a property of the on-chain tx, not the wallet's view of it).
+* - **`identifiers`** — unioned (each wallet may surface a different identifier subset).
+* - **`lifecycle`** — incoming wins, except that a late rejection cannot overwrite recorded on-chain inclusion.
+* - **Wallet sections** (`shielded`, `unshielded`, `dust`) — combined via per-section merge when both sides have them;
+*   otherwise whichever side is present is used.
+*/
+/**
+* Combine two optional values under a merge function: if both sides have it, delegate to `merge`; otherwise return
+* whichever side is present (or `undefined` if neither). Encapsulates the four-way pattern used for every wallet
+* section in {@link mergeWalletEntries}.
+*/
+const mergeOptionalSection = (existing, incoming, merge) => {
+	if (existing !== void 0 && incoming !== void 0) return merge(existing, incoming);
+	return existing ?? incoming;
+};
+function mergeWalletEntries(existing, incoming) {
+	const identifiers = Array.from(new Set([...existing.identifiers, ...incoming.identifiers]));
+	const shielded = mergeOptionalSection(existing.shielded, incoming.shielded, require_dist$2.mergeShieldedSections$1);
+	const unshielded = mergeOptionalSection(existing.unshielded, incoming.unshielded, require_dist$3.mergeUnshieldedSections$1);
+	const dust = mergeOptionalSection(existing.dust, incoming.dust, require_dist$1.mergeDustSections$1);
+	return {
+		hash: existing.hash,
+		identifiers,
+		protocolVersion: existing.protocolVersion ?? incoming.protocolVersion,
+		status: existing.status ?? incoming.status,
+		timestamp: existing.timestamp ?? incoming.timestamp,
+		fees: existing.fees ?? incoming.fees,
+		lifecycle: existing.lifecycle.status === "finalized" && incoming.lifecycle.status === "rejected" ? existing.lifecycle : incoming.lifecycle,
+		...shielded !== void 0 ? { shielded } : {},
+		...unshielded !== void 0 ? { unshielded } : {},
+		...dust !== void 0 ? { dust } : {}
+	};
+}
+/**
+* Storage key for a tx we're about to submit (record as pending). The hash comes from {@link txHistoryHash}, which the
+* revert side uses too — so a tx keyed here while pending resolves to the same key when later confirmed or reverted.
+*/
+const submitTxHistoryKey = (tx) => ({
+	hash: txHistoryHash(tx),
+	identifiers: tx.identifiers()
+});
+/**
+* Storage key for a tx we're about to revert (record as rejected). Shares {@link txHistoryHash} with the submit side so
+* the rejected entry lands on the pending entry in place. Returns `undefined` only when the tx has no identifiers at
+* all (nothing to revert).
+*/
+const revertTxHistoryKey = (tx) => {
+	const identifiers = tx.identifiers();
+	if (identifiers.length === 0) return void 0;
+	return {
+		hash: txHistoryHash(tx),
+		identifiers
+	};
+};
+const v9Authoring = {
+	sampleSigningKey: () => _midnightntwrk_ledger_v9.sampleSigningKey(),
+	signatureVerifyingKey: (signingKey) => _midnightntwrk_ledger_v9.signatureVerifyingKey(signingKey),
+	signData: (signingKey, data) => _midnightntwrk_ledger_v9.signData(signingKey, data),
+	deserializers: {
+		Unproven: (bytes) => _midnightntwrk_ledger_v9.Transaction.deserialize("signature", "pre-proof", "pre-binding", bytes),
+		Unbound: (bytes) => _midnightntwrk_ledger_v9.Transaction.deserialize("signature", "proof", "pre-binding", bytes),
+		Finalized: (bytes) => _midnightntwrk_ledger_v9.Transaction.deserialize("signature", "proof", "binding", bytes)
+	}
+};
+const v8Authoring = {
+	sampleSigningKey: () => _midnight_ntwrk_ledger_v8.sampleSigningKey(),
+	signatureVerifyingKey: (signingKey) => require_v8Signatures.liftSignatureVerifyingKey(_midnight_ntwrk_ledger_v8.signatureVerifyingKey(signingKey)),
+	signData: (signingKey, data) => require_v8Signatures.liftSignature(_midnight_ntwrk_ledger_v8.signData(signingKey, data)),
+	deserializers: {
+		Unproven: (bytes) => _midnight_ntwrk_ledger_v8.Transaction.deserialize("signature", "pre-proof", "pre-binding", bytes),
+		Unbound: (bytes) => _midnight_ntwrk_ledger_v8.Transaction.deserialize("signature", "proof", "pre-binding", bytes),
+		Finalized: (bytes) => _midnight_ntwrk_ledger_v8.Transaction.deserialize("signature", "proof", "binding", bytes)
+	}
+};
+const TokenKindsToBalance = new class {
+	allTokenKinds = [
+		"shielded",
+		"unshielded",
+		"dust"
+	];
+	toFlags = (tokenKinds) => {
+		return require_dist.pipe(tokenKinds, (kinds) => kinds === "all" ? this.allTokenKinds : kinds, (kinds) => ({
+			shouldBalanceUnshielded: kinds.includes("unshielded"),
+			shouldBalanceShielded: kinds.includes("shielded"),
+			shouldBalanceDust: kinds.includes("dust")
+		}));
+	};
+}();
+const BalancingRecipe = {
+	isRecipe: (value) => {
+		return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string" && [
+			"FINALIZED_TRANSACTION",
+			"UNBOUND_TRANSACTION",
+			"UNPROVEN_TRANSACTION"
+		].includes(value.type);
+	},
+	getTransactions: (recipe) => {
+		switch (recipe.type) {
+			case "FINALIZED_TRANSACTION": return [recipe.originalTransaction, recipe.balancingTransaction];
+			case "UNBOUND_TRANSACTION": {
+				const balancingPart = recipe.balancingTransaction ? [recipe.balancingTransaction] : [];
+				return [recipe.baseTransaction, ...balancingPart];
+			}
+			case "UNPROVEN_TRANSACTION": return [recipe.transaction];
+		}
+	}
+};
+/**
+* The lowest of the protocol versions the three wallets have reached.
+*
+* @remarks
+*   The three wallets follow the same chain but not in lock-step: each recognises a protocol version change when its own
+*   synchronization reaches it, so around a fork they disagree for a while. A transaction spans all three, so the one
+*   still behind is what bounds the facade as a whole — the highest version every wallet is known to be at.
+* @param versions The version each wallet has reached.
+* @returns The lowest of the three.
+*/
+const lowestProtocolVersion = (versions) => [
+	versions.shielded,
+	versions.unshielded,
+	versions.dust
+].reduce((lowest, candidate) => candidate < lowest ? candidate : lowest);
+/**
+* The ledger-v9 key objects the wallets' own `start` takes, from whichever material the caller supplied.
+*
+* @remarks
+*   Only the ledger-v9 side is needed here: a wallet built from seeds or from both versions' keys already holds what its
+*   V1 variant needs, retained when it was built. What `start` supplies is the side the wallet's own API speaks.
+*/
+const v9KeysOf = (material) => "v9" in material ? material.v9 : {
+	shielded: _midnightntwrk_ledger_v9.ZswapSecretKeys.fromSeed(material.shielded),
+	dust: _midnightntwrk_ledger_v9.DustSecretKey.fromSeed(material.dust)
+};
+/** The three wallets in a fixed order, so {@link protocolPhaseOf} reports them the same way every time. */
+const walletKinds = [
+	"shielded",
+	"unshielded",
+	"dust"
+];
+/**
+* Reads whether the wallets are settled on one side of a protocol boundary, or still crossing it.
+*
+* @remarks
+*   Derived entirely from the version each wallet has reported and where the boundary lies — the same two facts every
+*   other version-routing decision in the SDK is made from, so this reading cannot disagree with them.
+* @param versions The version each wallet has reached.
+* @param forkVersion The version at which the chain hands over to the next ledger version.
+* @returns The reading. See {@link ProtocolPhase}.
+*/
+const protocolPhaseOf = (versions, forkVersion) => {
+	const reported = walletKinds.map((kind) => [kind, versions[kind]]);
+	const from = lowestProtocolVersion(versions);
+	const epoch = require_dist.epochOf(from, forkVersion);
+	const crossed = reported.filter(([, version]) => !require_dist.withinRange(version, epoch));
+	if (crossed.length === 0) return {
+		_tag: "Settled",
+		version: from
+	};
+	return {
+		_tag: "Crossing",
+		from,
+		to: crossed.reduce((highest, [, version]) => version > highest ? version : highest, crossed[0][1]),
+		behind: reported.filter(([, version]) => require_dist.withinRange(version, epoch)).map(([kind]) => kind)
+	};
+};
+/** Reads what has become of a transaction from the verdict the pending set holds, if it holds one. */
+const pendingStatusOf = (result) => {
+	if (result === void 0) return { _tag: "Submitted" };
+	switch (result.status) {
+		case "SUCCESS": return {
+			_tag: "Confirmed",
+			segments: result.segments
+		};
+		case "FAILURE":
+		case "PARTIAL_SUCCESS": return {
+			_tag: "Rejected",
+			segments: result.segments
+		};
+		case "ORPHANED_BY_FORK": return {
+			_tag: "Orphaned",
+			authoredFor: result.authoredFor,
+			chainNow: result.chainNow
+		};
+	}
+};
+/**
+* The pending transactions as an application reads them.
+*
+* @remarks
+*   A projection over the pending set the services keep, not a second copy of it: the facts are the same, stated as a
+*   list of transactions with a status each rather than as the bag the machinery works in.
+* @param pending The pending set.
+* @returns One entry per transaction, in the order the wallet recorded them.
+*/
+const pendingTransactionsOf = (pending) => pending.all.map((item) => ({
+	transaction: item.tx,
+	submittedAt: item.creationTime,
+	authoredFor: item.protocolVersion,
+	status: pendingStatusOf("result" in item ? item.result : void 0)
+}));
+var FacadeState = class {
+	shielded;
+	unshielded;
+	dust;
+	pending;
+	/** The protocol version each of the three wallets has reached. */
+	get protocolVersion() {
+		return {
+			shielded: this.shielded.protocolVersion,
+			unshielded: this.unshielded.protocolVersion,
+			dust: this.dust.protocolVersion
+		};
+	}
+	/**
+	* The protocol version the facade as a whole can act at: the lowest the three wallets have reached.
+	*
+	* @remarks
+	*   Around a protocol boundary the three wallets cross at slightly different moments, and a transaction needs all
+	*   three. This is the version every one of them is known to understand.
+	*/
+	get activeProtocolVersion() {
+		return lowestProtocolVersion(this.protocolVersion);
+	}
+	/**
+	* Whether the three wallets are settled on one side of the protocol boundary, or still crossing it.
+	*
+	* @remarks
+	*   Additive, and the reading `protocolVersion` alone cannot give: three versions that differ tell an application
+	*   nothing about whether the difference matters. See {@link ProtocolPhase}.
+	*/
+	get protocol() {
+		return protocolPhaseOf(this.protocolVersion, this.#forkVersion);
+	}
+	get isSynced() {
+		return this.shielded.state.progress.isStrictlyComplete() && this.dust.state.progress.isStrictlyComplete() && this.unshielded.progress.isStrictlyComplete();
+	}
+	/** Where the chain hands over from one ledger version to the next, which is what {@link protocol} is read against. */
+	#forkVersion;
+	constructor(shielded, unshielded, dust, pending, forkVersion = require_dist.MinSupportedVersion) {
+		this.shielded = shielded;
+		this.unshielded = unshielded;
+		this.dust = dust;
+		this.pending = pendingTransactionsOf(pending);
+		this.#forkVersion = forkVersion;
+	}
+};
+const DEFAULT_TTL_MS = 3600 * 1e3;
+/**
+* The fork schedule the facade presets when a configuration names none: {@link ProtocolVersion.V9NativeForkSchedule},
+* ledger-v9 from the version a 2.x node reports.
+*
+* @remarks
+*   Where a chain forks is a fact about the chain, which is why each wallet package requires `forks` and presets nothing.
+*   The facade is the one place a preset decides nothing the SDK has not already decided: every chain the 2.x node line
+*   runs hands over at this version, so an application copying the constant into its configuration only restates it. A
+*   chain that hands over elsewhere states its own `forks`, which wins.
+*/
+const DefaultForkSchedule = require_dist.V9NativeForkSchedule;
+var WalletFacade = class WalletFacade {
+	static makeDefaultSubmissionService(config) {
+		return require_dist.makeDefaultSubmissionService(config);
+	}
+	static makeDefaultPendingTransactionsService(config) {
+		return require_dist.PendingTransactionsServiceImpl.init({
+			configuration: config,
+			txTraits: finalizedTransactionTraits(config.forks.v9)
+		});
+	}
+	/**
+	* Builds the proving service a configuration describes.
+	*
+	* @remarks
+	*   Handed the same fork schedule the wallets are built with, because a proving backend is chosen by the epoch a
+	*   transaction belongs to and the two ends of that question must not be able to compute the boundary differently.
+	*/
+	static makeDefaultProvingService(config) {
+		return require_dist.getOrThrowWith(require_dist.makeDefaultVersionedProvingService(config, config.forks), (error) => new Error(error.message));
+	}
+	/**
+	* Fills in what the facade presets — `forks`, as {@link DefaultForkSchedule} — so that the result is a configuration a
+	* wallet package can be built from.
+	*
+	* @remarks
+	*   {@link WalletFacade.init} does this itself, once and before anything is built, so the wallets, the default services
+	*   and the facade's own boundary cannot be given different schedules, and no factory needs to call it. It is public
+	*   for code outside a factory that needs the configuration the facade will use: an application building a wallet
+	*   package directly, or reading `forks` back to author a transaction for the right ledger version. Resolving twice
+	*   is the same as resolving once, so `init` may be handed the result.
+	* @example
+	*   ```typescript
+	*   const configuration = WalletFacade.resolveConfiguration({ networkId: 'undeployed', ... });
+	*   const facade = await WalletFacade.init({ configuration, shielded: (config) => ShieldedWallet(config), ... });
+	*   const authoredForV9 = protocolVersion >= configuration.forks.v9;
+	*   ```;
+	*
+	* @param configuration The configuration as given, with or without `forks`.
+	* @returns The same configuration with `forks` present: the schedule it named, or {@link DefaultForkSchedule}.
+	*/
+	static resolveConfiguration(configuration) {
+		return {
+			...configuration,
+			forks: configuration.forks ?? DefaultForkSchedule
+		};
+	}
+	/**
+	* Fetches the current Terms and Conditions from the network indexer.
+	*
+	* This is a static, pre-initialization utility — no wallet instance is required. Wallet builders should call this
+	* before or independently of wallet initialization to display the current T&C to end users and obtain the hash for
+	* content verification.
+	*
+	* The returned `hash` is the hex-encoded SHA-256 hash of the document at `url`. Wallet builders are responsible for
+	* fetching and rendering the document content via `url` in whatever manner suits their application.
+	*
+	* @param configuration - An object with an `indexerClientConnection.indexerHttpUrl`. Any wallet configuration that
+	*   satisfies {@link FetchTermsAndConditionsConfiguration} can be passed directly.
+	* @returns A promise resolving to the current {@link TermsAndConditions}, or rejecting if no Terms and Conditions have
+	*   been set on the network yet.
+	*/
+	static async fetchTermsAndConditions(configuration) {
+		const tc = (await require_dist.runPromise(require_dist.FetchTermsAndConditions, {}, { url: configuration.indexerClientConnection.indexerHttpUrl })).block?.systemParameters?.termsAndConditions;
+		if (!tc) throw new Error("Terms and Conditions are not currently set on the network.");
+		return tc;
+	}
+	/**
+	* Default initialization for {@link WalletFacade}. It is a static method, which takes an object holding configuration
+	* and initialization of necessary components. Specifically - it requires following fields:
+	*
+	* - `configuration` - holding a configuration, which needs to extend {@link DefaultConfiguration} - this way allows to
+	*   convey use-case-specific settings in the same way, as the SDK works by default. `forks` may be left out; every
+	*   factory below is handed a {@link ResolvedConfiguration}, which always has it — what
+	*   {@link WalletFacade.resolveConfiguration} returns
+	* - `shielded` - a function taking the configuration and returning shielded wallet (or a promise with such)
+	*   implementing {@link ShieldedWalletAPI}
+	* - `unshielded` - a function taking the configuration and returning unshielded wallet (or a promise with such)
+	*   implementing {@link UnshieldedWalletAPI}
+	* - `dust` - a function taking the configuration and returning Dust wallet (or a promise with such) implementing
+	*   {@link DustWalletAPI} There are some optional services/abstractions to provide, too. If not provided - default
+	*   implementations will be used, each of them is initialized by a function taking the configuration and returning
+	*   proper implementation (wrapped in a {@link Promise} or not).
+	* - `submissionService` - needs to implement {@link SubmissionService} for a {@link ledgerV9.FinalizedTransaction} to
+	*   submit transactions to the network, default uses Node RPC connection
+	* - `pendingTransactionsService` - needs to implement {@link PendingTransactionsService} for a
+	*   {@link ledgerV9.FinalizedTransaction} to keep track of pending transactions, default uses in-memory
+	*   implementation
+	* - `provingService` - needs to implement {@link VersionedProvingService} to prove it, default uses proving server
+	* - `clock` - needs to implement {@link Clock.Clock} for getting current time, default uses system clock
+	*/
+	static async init(initParams) {
+		const configuration = WalletFacade.resolveConfiguration(initParams.configuration);
+		const submissionService = await Promise.resolve(initParams.submissionService ? initParams.submissionService(configuration) : WalletFacade.makeDefaultSubmissionService(configuration));
+		const pendingTransactionsService = await Promise.resolve(initParams.pendingTransactionsService ? initParams.pendingTransactionsService(configuration) : WalletFacade.makeDefaultPendingTransactionsService(configuration));
+		const provingService = await Promise.resolve(initParams.provingService ? initParams.provingService(configuration) : WalletFacade.makeDefaultProvingService(configuration));
+		const shielded = await Promise.resolve(initParams.shielded(configuration));
+		const unshielded = await Promise.resolve(initParams.unshielded(configuration));
+		const dust = await Promise.resolve(initParams.dust(configuration));
+		const clock = await Promise.resolve(initParams.clock ? initParams.clock(configuration) : require_dist.systemClock);
+		const fetchBlockData = await Promise.resolve(initParams.fetchBlockData ? initParams.fetchBlockData(configuration) : require_dist.makeDefaultBlockDataFetcher(configuration));
+		return new WalletFacade(shielded, unshielded, dust, submissionService, pendingTransactionsService, provingService, await Promise.resolve(initParams.validationService ? initParams.validationService(configuration, {
+			fetchBlockData,
+			clock
+		}) : require_dist.makeDefaultVersionedValidationService({
+			fetchBlockData,
+			networkId: configuration.networkId,
+			clock
+		}, configuration.forks.v9)), configuration.txHistoryStorage, configuration.forks.v9, clock);
+	}
+	shielded;
+	unshielded;
+	dust;
+	submissionService;
+	pendingTransactionsService;
+	provingService;
+	validationService;
+	#txHistoryStorage;
+	clock;
+	#pendingSubscription;
+	#protocolVersionSubscription;
+	/**
+	* The protocol version the wallets have all reached, as last observed.
+	*
+	* @remarks
+	*   `Option.none()` until the three wallets have each emitted once. A transaction stamped with `none` is never
+	*   orphaned, so an unobserved version costs a transaction nothing but the ability to be given up on early.
+	*/
+	#observedProtocolVersion = new rxjs.BehaviorSubject(require_dist.none());
+	/** Where the chain hands over from one ledger version to the next, which is what divides the two epochs. */
+	#forkVersion;
+	/**
+	* Constructor is private on purpose - much of initialization of the facade is potentially asynchronous, and adding
+	* new parameters is a breaking change to the users Use {@link WalletFacade.init} instead
+	*
+	* @private
+	*/
+	constructor(shieldedWallet, unshieldedWallet, dustWallet, submissionService, pendingTransactionsService, provingService, validationService, txHistoryStorage, forkVersion, clock = require_dist.systemClock) {
+		this.shielded = shieldedWallet;
+		this.unshielded = unshieldedWallet;
+		this.dust = dustWallet;
+		this.submissionService = submissionService;
+		this.pendingTransactionsService = pendingTransactionsService;
+		this.provingService = provingService;
+		this.validationService = validationService;
+		this.#txHistoryStorage = txHistoryStorage;
+		this.#forkVersion = forkVersion;
+		this.clock = clock;
+		this.#pendingSubscription = this.pendingTransactionsService.state().pipe((0, rxjs.concatMap)((pending) => require_dist.allRejected(pending)), (0, rxjs.concatMap)(async (item) => {
+			if (!await this.reconcileFinalizedTransaction(item.tx, await this.#txHistoryStorage.getAll())) await this.revert(item.tx, rejectionReason(item.result));
+		})).subscribe();
+		this.#protocolVersionSubscription = (0, rxjs.combineLatest)([
+			this.shielded.state,
+			this.unshielded.state,
+			this.dust.state
+		]).pipe((0, rxjs.map)(([shieldedState, unshieldedState, dustState]) => lowestProtocolVersion({
+			shielded: shieldedState.protocolVersion,
+			unshielded: unshieldedState.protocolVersion,
+			dust: dustState.protocolVersion
+		})), (0, rxjs.distinctUntilChanged)(), (0, rxjs.tap)((version) => this.#observedProtocolVersion.next(require_dist.some(version))), (0, rxjs.concatMap)((version) => this.pendingTransactionsService.orphanBeyond(version))).subscribe();
+	}
+	/**
+	* The protocol version the facade is currently acting at.
+	*
+	* @remarks
+	*   The lowest the three wallets have reached, once they have all reported; the minimum supported version until then,
+	*   which is the epoch a wallet with no history belongs to. It is what a transaction the facade builds is stamped
+	*   with, and what the side of the boundary it accepts transactions from is measured against.
+	*/
+	currentVersion() {
+		return require_dist.getOrElse(this.#observedProtocolVersion.getValue(), () => require_dist.MinSupportedVersion);
+	}
+	/** The range of protocol versions on the same side of the boundary as a given one. */
+	epochOf(version) {
+		return require_dist.epochOf(version, this.#forkVersion);
+	}
+	/** The range of protocol versions on the facade's current side of the boundary. */
+	currentEpoch() {
+		return this.epochOf(this.currentVersion());
+	}
+	/**
+	* Reads a transaction an application handed in, refusing one built on the other side of the boundary.
+	*
+	* @remarks
+	*   The enforcement point for everything that enters the facade — a transaction the wallets built, or one an
+	*   application authored and sealed with `WalletTransaction.adopt`. Only the current epoch is accepted, because a
+	*   transaction of the other one cannot be merged, proved or submitted alongside anything the facade would build for
+	*   it. Both a stranded ledger-v8 transaction after the crossing and a ledger-v9 transaction offered before it are
+	*   refused here, by name, with the versions written down.
+	* @param handle The handle to read.
+	* @returns The carried transaction.
+	* @throws {@link ProtocolVersionMismatchError} When the transaction was built on the other side of the boundary.
+	*/
+	accept(handle) {
+		return require_dist.getOrThrowWith(require_dist.WalletTransaction.unwrapWithin(handle, this.currentEpoch()), (error) => error);
+	}
+	/**
+	* Seals a transaction the facade or a wallet produced, at the version its bytes were fixed by.
+	*
+	* @remarks
+	*   The version is the caller's to state, never read from the facade here, because the two can differ: a crossing can
+	*   land while a transaction is at the prover, and what comes back is still the bytes of the ledger version that made
+	*   them. A caller sealing something it has just built passes the version it is building at; a caller sealing
+	*   something that has travelled through an await passes the version stamped on the handle it started from.
+	* @param stage How far along the building of the transaction the sealed handle is.
+	* @param transaction The transaction to seal.
+	* @param protocolVersion The version the transaction's bytes were fixed by.
+	* @returns The sealed handle.
+	*/
+	seal(stage, transaction, protocolVersion) {
+		return require_dist.WalletTransaction.adopt(stage, transaction, protocolVersion);
+	}
+	/** The ledger primitives the facade signs with on its current side of the boundary. */
+	authoring() {
+		return this.currentVersion() < this.#forkVersion ? v8Authoring : v9Authoring;
+	}
+	/**
+	* Reads a transaction from bytes that name no protocol version, at the version the facade is acting at.
+	*
+	* @remarks
+	*   For bytes that reach the wallet from outside the SDK — a dApp connector's serialized transaction above all, whose
+	*   contract carries no version alongside them. The bytes cannot say which ledger version wrote them, so this answers
+	*   with the only version the facade could act at anyway, and reads them with that version's ledger. Bytes the other
+	*   ledger version wrote are refused here rather than misread, because the markers a stage names are part of what the
+	*   ledger checks as it reads.
+	*
+	*   The version is the facade's rather than the caller's, which is the point: a caller that reads
+	*   {@link FacadeState.activeProtocolVersion} and seals a handle itself is answering the same question a moment
+	*   earlier, with a crossing able to land in between. It is still only the version at the moment of the call — a
+	*   crossing can land before the handle is used, and {@link ProtocolVersionMismatchError} from the operation that uses
+	*   it is what says so.
+	* @example
+	*   Balancing a transaction a dApp connector handed over as hex:
+	*
+	*   ```typescript
+	*   const handle = facade.adoptTransaction(Buffer.from(txHex, 'hex'), 'Unbound');
+	*   const recipe = await facade.balanceUnboundTransaction(handle, { ttl });
+	*   ```;
+	*
+	* @param bytes The transaction's own serialization, as the ledger version that wrote it produced it.
+	* @param stage How far along the building of the transaction these bytes are, which decides the markers they are read
+	*   with.
+	* @returns The sealed handle, stamped with the protocol version the facade is acting at.
+	* @throws {@link WireFormatError} When the bytes are not a transaction of that version at that stage — which is what
+	*   a transaction authored on the other side of a protocol boundary looks like from here.
+	*/
+	adoptTransaction(bytes, stage) {
+		const protocolVersion = this.currentVersion();
+		return require_dist.getOrThrowWith(require_dist.try_$1({
+			try: () => this.authoring().deserializers[stage](bytes),
+			catch: (cause) => new require_dist.WireFormatError({
+				message: `These bytes are not a transaction of protocol version ${protocolVersion} at stage ${stage} — that is the version this wallet is acting at, and a transaction built for another one has to be built again for it.`,
+				cause
+			})
+		}).pipe(require_dist.map$6((transaction) => require_dist.WalletTransaction.adopt(stage, transaction, protocolVersion))), (error) => error);
+	}
+	defaultTtl() {
+		return new Date(this.clock.now().getTime() + DEFAULT_TTL_MS);
+	}
+	/**
+	* Checks whether a transaction is structurally well-formed before passing it to a balance or submit method.
+	*
+	* Highly recommended in particular for transactions received from a 3rd party (e.g., a dApp or partner service)
+	* before forwarding them to a balance or submit method.
+	*
+	* TTL expiry, Network ID mismatch, and transaction structure are always enforced regardless of `flags`. All three
+	* configurable flags must be supplied explicitly — there are no defaults, so callers must be intentional about each
+	* check.
+	*
+	* Recommended flags per call site:
+	*
+	* | Method                        | enforceBalancing | verifySignatures | enforceLimits |
+	* | ----------------------------- | ---------------- | ---------------- | ------------- |
+	* | `submitTransaction`           | `true`           | `true`           | `true`        |
+	* | `balanceFinalizedTransaction` | `false`          | `true`           | `false`       |
+	* | `balanceUnboundTransaction`   | `false`          | `false`          | `false`       |
+	* | `balanceUnprovenTransaction`  | `false`          | `false`          | `false`       |
+	*
+	* Real on-chain ledger parameters are always used — `options.blockData` is used if provided, otherwise the service
+	* fetches the latest block data via the configured fetcher. Pass `recipe.blockData` to reuse the fetch performed
+	* during balancing and avoid a redundant network call.
+	*
+	* @example
+	*   ```typescript
+	*   // Reuse the block data captured during balancing — no extra fetch
+	*   const recipe = await facade.balanceFinalizedTransaction(tx, secretKeys, options);
+	*   const finalizedTx = await facade.finalizeRecipe(recipe);
+	*   await facade.validateTransaction(finalizedTx, {
+	*     flags: { enforceBalancing: true, verifySignatures: true, enforceLimits: true },
+	*     blockData: recipe.blockData,
+	*   });
+	*   await facade.submitTransaction(finalizedTx);
+	*
+	*   // No recipe to source blockData from — the service fetches automatically
+	*   await facade.validateTransaction(tx, {
+	*     flags: { enforceBalancing: false, verifySignatures: false, enforceLimits: false },
+	*   });
+	*   ```;
+	*
+	* @param tx - The transaction to validate (`FinalizedTransaction`, `UnboundTransaction`, or `UnprovenTransaction`).
+	* @param options - Strictness flags and optional `blockData` to skip the fetch.
+	* @throws {@link WellFormedError} If the transaction fails any enabled check.
+	* @throws {@link ValidationFetchError} If the block-data fetch fails.
+	*/
+	async validateTransaction(tx, options) {
+		return this.validationService.validateTx(require_dist.getOrThrowWith(require_dist.WalletTransaction.unwrapWithin(tx, require_dist.epochOf(tx.protocolVersion, this.#forkVersion)), (error) => error), tx.protocolVersion, options);
+	}
+	/**
+	* Merges two unproven transactions of the same epoch, or returns whichever there is.
+	*
+	* @remarks
+	*   Both are unwrapped before merging, which is where a pair from different epochs is refused: a merge across the
+	*   boundary is not a failure to compute, it is unrepresentable, and saying so is the whole point of the stamp.
+	*/
+	mergeUnprovenTransactions(a, b) {
+		if (a && b) return this.seal("Unproven", this.accept(a).merge(this.accept(b)), this.currentVersion());
+		return a ?? b;
+	}
+	async createDustActionTransaction(action, nightUtxos, nightVerifyingKey, signDustRegistration) {
+		const ttl = this.defaultTtl();
+		const now = this.clock.now();
+		const isRegistration = action.type === "registration";
+		const dustReceiverAddress = isRegistration ? action.dustReceiverAddress : void 0;
+		const split = await this.dust.splitNightUtxosForDustRegistration(now, nightUtxos.map(({ utxo, meta }) => ({
+			...utxo,
+			ctime: meta.ctime,
+			registeredForDustGeneration: meta.registeredForDustGeneration
+		})), isRegistration);
+		const toUnshieldedUtxoWithMeta = (u) => ({
+			utxo: {
+				value: u.utxo.value,
+				type: u.utxo.type,
+				owner: u.utxo.owner,
+				intentHash: u.utxo.intentHash,
+				outputNo: u.utxo.outputNo
+			},
+			meta: {
+				ctime: u.utxo.ctime,
+				registeredForDustGeneration: u.utxo.registeredForDustGeneration
+			}
+		});
+		const guaranteedForUnshielded = split.guaranteedUtxos.map(toUnshieldedUtxoWithMeta);
+		const fallibleForUnshielded = split.fallibleUtxos.map(toUnshieldedUtxoWithMeta);
+		const txWithOffers = await this.unshielded.rotateUtxos(guaranteedForUnshielded, fallibleForUnshielded, nightVerifyingKey, ttl);
+		let txWithDustActions;
+		try {
+			txWithDustActions = await this.dust.attachDustRegistration(txWithOffers, now, nightVerifyingKey, dustReceiverAddress, split.feePayment);
+		} catch (error) {
+			await this.unshielded.revertTransaction(txWithOffers);
+			throw error;
+		}
+		const hasUnregisteredGuaranteed = split.guaranteedUtxos.some((u) => !u.utxo.registeredForDustGeneration);
+		if (isRegistration && hasUnregisteredGuaranteed) {
+			const fee = await this.dust.calculateFee([txWithDustActions]);
+			if (split.feePayment < fee) {
+				await this.unshielded.revertTransaction(txWithOffers);
+				throw Error(`Insufficient generated dust to cover registration fee (have ${split.feePayment}, need ${fee}). Use WalletFacade.waitForGeneratedDust(utxos, ${fee}) before retrying.`);
+			}
+		}
+		try {
+			const signedRecipe = await this.signRecipe({
+				type: "UNPROVEN_TRANSACTION",
+				protocolVersion: this.currentVersion(),
+				transaction: txWithDustActions
+			}, signDustRegistration);
+			if (signedRecipe.type !== "UNPROVEN_TRANSACTION") throw Error("signRecipe returned unexpected recipe type for dust action transaction.");
+			return signedRecipe.transaction;
+		} catch (error) {
+			await this.unshielded.revertTransaction(txWithOffers);
+			throw error;
+		}
+	}
+	state() {
+		return (0, rxjs.combineLatest)([
+			this.shielded.state,
+			this.unshielded.state,
+			this.dust.state,
+			this.pendingTransactionsService.state()
+		]).pipe((0, rxjs.map)(([shieldedState, unshieldedState, dustState, pending]) => new FacadeState(shieldedState, unshieldedState, dustState, pending, this.#forkVersion)));
+	}
+	async waitForSyncedState() {
+		const [shieldedState, unshieldedState, dustState, pending] = await Promise.all([
+			this.shielded.waitForSyncedState(),
+			this.unshielded.waitForSyncedState(),
+			this.dust.waitForSyncedState(),
+			(0, rxjs.firstValueFrom)(this.pendingTransactionsService.state())
+		]);
+		return new FacadeState(shieldedState, unshieldedState, dustState, pending, this.#forkVersion);
+	}
+	/**
+	* Submits a finalized transaction to the network and tracks it as pending until finalized or discarded.
+	*
+	* Call {@link validateTransaction} with `{ enforceBalancing: true, verifySignatures: true, enforceLimits: true }`
+	* before this method to surface structural errors with a clear diagnostic instead of a cryptic network rejection.
+	*
+	* @param tx - The finalized transaction to submit.
+	* @returns The transaction identifier.
+	* @throws {@link WellFormedError} — call {@link validateTransaction} first to get this error early.
+	*/
+	async submitTransaction(tx) {
+		const carried = this.accept(tx);
+		const identifiers = carried.identifiers();
+		try {
+			await this.pendingTransactionsService.addPendingTransaction(tx, this.#observedProtocolVersion.getValue());
+			const key = submitTxHistoryKey(carried);
+			await this.#txHistoryStorage.gotPending({
+				...key,
+				submittedAt: this.clock.now()
+			});
+			await this.submissionService.submitTransaction(tx, "Finalized");
+			return identifiers.at(-1);
+		} catch (error) {
+			await this.revert(tx);
+			throw error;
+		}
+	}
+	/**
+	* Balances a finalized transaction by adding shielded, unshielded, and dust inputs/outputs as needed.
+	*
+	* Call {@link validateTransaction} with `{ enforceBalancing: false, verifySignatures: true, enforceLimits: false }`
+	* before this method to surface structural errors early. `enforceBalancing` is `false` because the transaction is not
+	* yet balanced at this stage; `verifySignatures` is `true` because signatures are already present and must be valid.
+	*
+	* @param tx - The finalized transaction to balance.
+	* @param secretKeys - Secret keys for shielded and dust coin selection.
+	* @param options - TTL for the balancing transaction, and optional subset of token kinds to balance.
+	* @returns A {@link FinalizedTransactionRecipe} containing the original and balancing transactions.
+	*/
+	async balanceFinalizedTransaction(tx, options) {
+		const { ttl, tokenKindsToBalance = "all" } = options;
+		const { shouldBalanceDust, shouldBalanceShielded, shouldBalanceUnshielded } = TokenKindsToBalance.toFlags(tokenKindsToBalance);
+		const unshieldedBalancingTx = shouldBalanceUnshielded ? await this.unshielded.balanceFinalizedTransaction(tx) : void 0;
+		const shieldedBalancingTx = shouldBalanceShielded ? await this.shielded.balanceTransaction(tx) : void 0;
+		const mergedBalancingTx = this.mergeUnprovenTransactions(shieldedBalancingTx, unshieldedBalancingTx);
+		const dustResult = shouldBalanceDust ? await this.dust.balanceTransactions(mergedBalancingTx ? [tx, mergedBalancingTx] : [tx], ttl) : void 0;
+		const feeBalancingTx = dustResult?.transaction;
+		const balancingTx = this.mergeUnprovenTransactions(mergedBalancingTx, feeBalancingTx);
+		if (!balancingTx) throw new Error("No balancing transaction was created. Please check your transaction.");
+		return {
+			type: "FINALIZED_TRANSACTION",
+			protocolVersion: this.currentVersion(),
+			originalTransaction: tx,
+			balancingTransaction: balancingTx,
+			...dustResult ? { blockData: dustResult.blockData } : {}
+		};
+	}
+	/**
+	* Balances an unbound (proven, pre-binding) transaction by adding shielded, unshielded, and dust inputs/outputs.
+	*
+	* Call {@link validateTransaction} with `{ enforceBalancing: false, verifySignatures: false, enforceLimits: false }`
+	* before this method to surface structural errors early. All configurable flags are `false` because the transaction
+	* is not yet balanced and signatures are not yet present.
+	*
+	* @param tx - The unbound transaction to balance.
+	* @param secretKeys - Secret keys for shielded and dust coin selection.
+	* @param options - TTL for the balancing transaction, and optional subset of token kinds to balance.
+	* @returns An {@link UnboundTransactionRecipe} containing the base and optional balancing transactions.
+	*/
+	async balanceUnboundTransaction(tx, options) {
+		const { ttl, tokenKindsToBalance = "all" } = options;
+		const { shouldBalanceDust, shouldBalanceShielded, shouldBalanceUnshielded } = TokenKindsToBalance.toFlags(tokenKindsToBalance);
+		const shieldedBalancingTx = shouldBalanceShielded ? await this.shielded.balanceTransaction(tx) : void 0;
+		const balancedUnshieldedTx = shouldBalanceUnshielded ? await this.unshielded.balanceUnboundTransaction(tx) : void 0;
+		const baseTx = balancedUnshieldedTx ?? tx;
+		const dustResult = shouldBalanceDust ? await this.dust.balanceTransactions(shieldedBalancingTx ? [baseTx, shieldedBalancingTx] : [baseTx], ttl) : void 0;
+		const feeBalancingTransaction = dustResult?.transaction;
+		const balancingTransaction = this.mergeUnprovenTransactions(shieldedBalancingTx, feeBalancingTransaction);
+		if (!balancingTransaction && !balancedUnshieldedTx) throw new Error("No balancing transaction was created. Please check your transaction.");
+		return {
+			type: "UNBOUND_TRANSACTION",
+			protocolVersion: this.currentVersion(),
+			baseTransaction: baseTx,
+			balancingTransaction: balancingTransaction ?? void 0,
+			...dustResult ? { blockData: dustResult.blockData } : {}
+		};
+	}
+	/**
+	* Balances an unproven transaction by adding shielded, unshielded, and dust inputs/outputs.
+	*
+	* Call {@link validateTransaction} with `{ enforceBalancing: false, verifySignatures: false, enforceLimits: false }`
+	* before this method to surface structural errors early. All configurable flags are `false` because the transaction
+	* is not yet balanced and signatures are not yet present.
+	*
+	* @param tx - The unproven transaction to balance.
+	* @param secretKeys - Secret keys for shielded and dust coin selection.
+	* @param options - TTL for the balancing transaction, and optional subset of token kinds to balance.
+	* @returns An {@link UnprovenTransactionRecipe} containing the balanced transaction.
+	*/
+	async balanceUnprovenTransaction(tx, options) {
+		const { ttl, tokenKindsToBalance = "all" } = options;
+		const { shouldBalanceDust, shouldBalanceShielded, shouldBalanceUnshielded } = TokenKindsToBalance.toFlags(tokenKindsToBalance);
+		const shieldedBalancingTx = shouldBalanceShielded ? await this.shielded.balanceTransaction(tx) : void 0;
+		const baseTx = (shouldBalanceUnshielded ? await this.unshielded.balanceUnprovenTransaction(tx) : void 0) ?? tx;
+		const mergedTx = this.mergeUnprovenTransactions(baseTx, shieldedBalancingTx);
+		const dustResult = shouldBalanceDust ? await this.dust.balanceTransactions([mergedTx], ttl) : void 0;
+		const feeBalancingTx = dustResult?.transaction;
+		const balancedTx = this.mergeUnprovenTransactions(mergedTx, feeBalancingTx);
+		return {
+			type: "UNPROVEN_TRANSACTION",
+			protocolVersion: this.currentVersion(),
+			transaction: balancedTx,
+			...dustResult ? { blockData: dustResult.blockData } : {}
+		};
+	}
+	async finalizeRecipe(recipe) {
+		return Promise.resolve(recipe).then(async (recipe) => {
+			switch (recipe.type) {
+				case "FINALIZED_TRANSACTION": {
+					const finalizedBalancing = await this.finalizeTransaction(recipe.balancingTransaction);
+					return this.seal("Finalized", this.accept(recipe.originalTransaction).merge(this.accept(finalizedBalancing)), recipe.originalTransaction.protocolVersion);
+				}
+				case "UNBOUND_TRANSACTION": {
+					const finalizedBalancingTx = recipe.balancingTransaction ? await this.finalizeTransaction(recipe.balancingTransaction) : void 0;
+					const finalizedTransaction = this.accept(recipe.baseTransaction).bind();
+					return this.seal("Finalized", finalizedBalancingTx ? finalizedTransaction.merge(this.accept(finalizedBalancingTx)) : finalizedTransaction, recipe.baseTransaction.protocolVersion);
+				}
+				case "UNPROVEN_TRANSACTION": return await this.finalizeTransaction(recipe.transaction);
+			}
+		}).then(async (finalizedTx) => {
+			await this.pendingTransactionsService.addPendingTransaction(finalizedTx, require_dist.some(finalizedTx.protocolVersion));
+			return finalizedTx;
+		});
+	}
+	async signRecipe(recipe, signSegment) {
+		switch (recipe.type) {
+			case "FINALIZED_TRANSACTION": {
+				const signedBalancingTx = await this.signUnprovenTransaction(recipe.balancingTransaction, signSegment);
+				const withDustSig = await this.#signDustRegistrationIfPresent(signedBalancingTx, signSegment);
+				return {
+					type: "FINALIZED_TRANSACTION",
+					protocolVersion: recipe.protocolVersion,
+					originalTransaction: recipe.originalTransaction,
+					balancingTransaction: withDustSig,
+					...recipe.blockData ? { blockData: recipe.blockData } : {}
+				};
+			}
+			case "UNBOUND_TRANSACTION": {
+				const signedBalancingTx = recipe.balancingTransaction ? await this.signUnprovenTransaction(recipe.balancingTransaction, signSegment).then((tx) => this.#signDustRegistrationIfPresent(tx, signSegment)) : void 0;
+				const signedBaseTx = await this.signUnboundTransaction(recipe.baseTransaction, signSegment);
+				return {
+					type: "UNBOUND_TRANSACTION",
+					protocolVersion: recipe.protocolVersion,
+					baseTransaction: signedBaseTx,
+					balancingTransaction: signedBalancingTx,
+					...recipe.blockData ? { blockData: recipe.blockData } : {}
+				};
+			}
+			case "UNPROVEN_TRANSACTION": {
+				const signedTx = await this.signUnprovenTransaction(recipe.transaction, signSegment);
+				const withDustSig = await this.#signDustRegistrationIfPresent(signedTx, signSegment);
+				return {
+					type: "UNPROVEN_TRANSACTION",
+					protocolVersion: recipe.protocolVersion,
+					transaction: withDustSig,
+					...recipe.blockData ? { blockData: recipe.blockData } : {}
+				};
+			}
+		}
+	}
+	async #signDustRegistrationIfPresent(tx, signSegment) {
+		const intent = this.accept(tx).intents?.get(1);
+		const registrations = intent?.dustActions?.registrations ?? [];
+		if (!intent || registrations.length === 0) return tx;
+		const signature = await signSegment(intent.signatureData(1));
+		return await this.dust.addDustRegistrationSignature(tx, signature);
+	}
+	async signUnprovenTransaction(tx, signSegment) {
+		return await this.unshielded.signUnprovenTransaction(tx, signSegment);
+	}
+	async signUnboundTransaction(tx, signSegment) {
+		return await this.unshielded.signUnboundTransaction(tx, signSegment);
+	}
+	/**
+	* Proves and binds an unproven transaction, and records it as pending.
+	*
+	* @remarks
+	*   Proved at the version stamped on the transaction itself, which is the version that fixed its bytes, and sealed at
+	*   that same version: proving is a long await, so the wallets can move under it, and neither the prover a
+	*   transaction is routed to nor the stamp it comes back with may be decided by where they have moved to.
+	*
+	*   Where they have moved to decides one thing only, and it is decided again once the proof is back: a crossing while
+	*   the transaction was in flight leaves it belonging to an epoch the wallets have left, and no chain they are on can
+	*   include it. Such a transaction is refused rather than sealed, and nothing is recorded as pending for it — a
+	*   pending entry would only wait out a TTL for an inclusion that cannot happen — while the reservations it made in
+	*   the three wallets are given back like those of any other failure here.
+	* @param tx The unproven transaction.
+	* @returns The finalized transaction, stamped with the version it was authored at.
+	* @throws {@link ProtocolVersionMismatchError} When the wallets left the transaction's epoch while it was being
+	*   proved, or were never in it.
+	*/
+	async finalizeTransaction(tx) {
+		try {
+			const unboundTx = await this.provingService.prove(this.accept(tx), tx.protocolVersion);
+			this.accept(tx);
+			const finalizedTx = this.seal("Finalized", unboundTx.bind(), tx.protocolVersion);
+			await this.pendingTransactionsService.addPendingTransaction(finalizedTx, require_dist.some(finalizedTx.protocolVersion));
+			return finalizedTx;
+		} catch (error) {
+			await Promise.allSettled([
+				this.shielded.revertTransaction(tx),
+				this.unshielded.revertTransaction(tx),
+				this.dust.revertTransaction(tx)
+			]);
+			throw error;
+		}
+	}
+	/** Estimates the fee for the given transaction only. This lacks the fees of the balancing transaction. */
+	async calculateTransactionFee(tx) {
+		return await this.dust.calculateFee([tx]);
+	}
+	/** Calculates the total fee for the given transaction plus the fee of the balancing transaction. */
+	async estimateTransactionFee(tx, options) {
+		const ttl = options?.ttl ?? this.defaultTtl();
+		return await this.dust.estimateFee([tx], ttl, options?.currentTime);
+	}
+	async transferTransaction(outputs, options) {
+		const { ttl, payFees = true } = options;
+		const unshieldedOutputs = outputs.filter((output) => output.type === "unshielded").flatMap((output) => output.outputs);
+		const shieldedOutputs = outputs.filter((output) => output.type === "shielded").flatMap((output) => output.outputs);
+		if (unshieldedOutputs.length === 0 && shieldedOutputs.length === 0) throw Error("At least one shielded or unshielded output is required.");
+		const shieldedTx = shieldedOutputs.length > 0 ? await this.shielded.transferTransaction(shieldedOutputs) : void 0;
+		const unshieldedTx = unshieldedOutputs.length > 0 ? await this.unshielded.transferTransaction(unshieldedOutputs, ttl) : void 0;
+		const mergedTxs = this.mergeUnprovenTransactions(shieldedTx, unshieldedTx);
+		const dustResult = payFees ? await this.dust.balanceTransactions([mergedTxs], ttl) : void 0;
+		const feeBalancingTx = dustResult?.transaction;
+		const finalTx = this.mergeUnprovenTransactions(mergedTxs, feeBalancingTx);
+		return {
+			type: "UNPROVEN_TRANSACTION",
+			protocolVersion: this.currentVersion(),
+			transaction: finalTx,
+			...dustResult ? { blockData: dustResult.blockData } : {}
+		};
+	}
+	/**
+	* Provides estimate of the fee of issuing registration transaction with provided UTxOs
+	*
+	* @param nightUtxos - Night UTxOs to use for the registration
+	* @returns And object informing about fee at the moment, as well as estimation of dust generation of the UTxO(s),
+	*   that would be used for paying the fee. These include data that allows to compute when the fee could be paid
+	*/
+	async estimateRegistration(nightUtxos) {
+		const now = this.clock.now();
+		const dustState = await this.dust.waitForSyncedState();
+		const dustGenerationEstimations = require_dist.pipe(nightUtxos, require_dist.map$3(({ utxo, meta }) => ({
+			...utxo,
+			ctime: meta.ctime,
+			registeredForDustGeneration: meta.registeredForDustGeneration
+		})), (utxosWithMeta) => dustState.estimateDustGeneration(utxosWithMeta, now), (estimatedUtxos) => dustState.splitNightUtxos(estimatedUtxos), (split) => split.guaranteed);
+		const authoring = this.authoring();
+		const fakeSigningKey = authoring.sampleSigningKey();
+		const fakeVerifyingKey = authoring.signatureVerifyingKey(fakeSigningKey);
+		const ttl = this.defaultTtl();
+		const fakeUnsignedTx = await this.dust.createDustGenerationTransaction(void 0, ttl, nightUtxos.map(({ utxo, meta }) => ({
+			...utxo,
+			ctime: meta.ctime,
+			registeredForDustGeneration: meta.registeredForDustGeneration
+		})), fakeVerifyingKey, dustState.address);
+		const intent = this.accept(fakeUnsignedTx).intents?.get(1);
+		if (!intent) throw Error("Dust generation transaction is missing intent segment 1.");
+		const signature = authoring.signData(fakeSigningKey, intent.signatureData(1));
+		const fakeSignedTx = await this.dust.addDustGenerationSignature(fakeUnsignedTx, signature);
+		const finalizedFakeTx = this.seal("Finalized", this.accept(fakeSignedTx).mockProve().bind(), this.currentVersion());
+		return {
+			fee: await this.calculateTransactionFee(finalizedFakeTx),
+			dustGenerationEstimations
+		};
+	}
+	async initSwap(desiredInputs, desiredOutputs, options) {
+		const { ttl, payFees = false } = options;
+		const { shielded: shieldedInputs, unshielded: unshieldedInputs } = desiredInputs;
+		const shieldedOutputs = desiredOutputs.filter((output) => output.type === "shielded").flatMap((output) => output.outputs);
+		const unshieldedOutputs = desiredOutputs.filter((output) => output.type === "unshielded").flatMap((output) => output.outputs);
+		const hasShieldedPart = shieldedInputs && Object.keys(shieldedInputs).length > 0 || shieldedOutputs.length > 0;
+		const hasUnshieldedPart = unshieldedInputs && Object.keys(unshieldedInputs).length > 0 || unshieldedOutputs.length > 0;
+		if (!hasShieldedPart && !hasUnshieldedPart) throw Error("At least one shielded or unshielded swap is required.");
+		const shieldedTx = hasShieldedPart ? await this.shielded.initSwap(shieldedInputs ?? {}, shieldedOutputs) : void 0;
+		const unshieldedTx = hasUnshieldedPart ? await this.unshielded.initSwap(unshieldedInputs ?? {}, unshieldedOutputs, ttl) : void 0;
+		const combinedTx = this.mergeUnprovenTransactions(shieldedTx, unshieldedTx);
+		if (!combinedTx) throw Error("Unexpected transaction state.");
+		const dustResult = payFees ? await this.dust.balanceTransactions([combinedTx], ttl) : void 0;
+		const feeBalancingTx = dustResult?.transaction;
+		const finalTx = this.mergeUnprovenTransactions(combinedTx, feeBalancingTx);
+		return {
+			type: "UNPROVEN_TRANSACTION",
+			protocolVersion: this.currentVersion(),
+			transaction: finalTx,
+			...dustResult ? { blockData: dustResult.blockData } : {}
+		};
+	}
+	async registerNightUtxosForDustGeneration(nightUtxos, nightVerifyingKey, signDustRegistration, dustReceiverAddress) {
+		if (nightUtxos.length === 0) throw Error("At least one Night UTXO is required.");
+		const receiverAddress = dustReceiverAddress ?? await this.dust.getAddress();
+		const dustRegistrationTx = await this.createDustActionTransaction({
+			type: "registration",
+			dustReceiverAddress: receiverAddress
+		}, nightUtxos, nightVerifyingKey, signDustRegistration);
+		return {
+			type: "UNPROVEN_TRANSACTION",
+			protocolVersion: this.currentVersion(),
+			transaction: dustRegistrationTx
+		};
+	}
+	/**
+	* Waits until the dust projected to be generated by the given Night UTxOs reaches `requiredAmount`, re-checking every
+	* second. Pair with {@link estimateRegistration} to pick `requiredAmount`, then call before
+	* {@link registerNightUtxosForDustGeneration} so the registration covers its own fee.
+	*
+	* @param nightUtxos - Night UTxOs to project generation for; the same set passed to the registration.
+	* @param requiredAmount - Dust threshold to wait for. Resolves immediately if `<= 0n`.
+	* @param opts.timeoutMs - Deadline, in ms, for the threshold to be reached. Rejects otherwise. Default `300_000`.
+	* @throws If `nightUtxos` is empty, or if `requiredAmount` is not reached within `opts.timeoutMs`.
+	*/
+	async waitForGeneratedDust(nightUtxos, requiredAmount, opts) {
+		await this.dust.waitForGeneratedDust(nightUtxos.map(({ utxo, meta }) => ({
+			...utxo,
+			ctime: meta.ctime,
+			registeredForDustGeneration: meta.registeredForDustGeneration
+		})), requiredAmount, this.clock, opts);
+	}
+	async deregisterFromDustGeneration(nightUtxos, nightVerifyingKey, signDustRegistration) {
+		const dustDeregistrationTx = await this.createDustActionTransaction({ type: "deregistration" }, nightUtxos, nightVerifyingKey, signDustRegistration);
+		return {
+			type: "UNPROVEN_TRANSACTION",
+			protocolVersion: this.currentVersion(),
+			transaction: dustDeregistrationTx
+		};
+	}
+	async revert(txOrRecipe, reason) {
+		const transactionsToRevert = BalancingRecipe.isRecipe(txOrRecipe) ? BalancingRecipe.getTransactions(txOrRecipe) : [txOrRecipe];
+		await Promise.all(transactionsToRevert.map((tx) => this.revertTransaction(tx, reason)));
+	}
+	/**
+	* The finalized entry recording `tx`, if sync has written one, even under the hash aggregation gave it on-chain. A
+	* transaction whose stamp no epoch can read has no entry, rather than an error, so a verdict on it still resolves.
+	*/
+	finalizedEntryFor(tx, history) {
+		return require_dist.match$1(require_dist.getRight(require_dist.WalletTransaction.unwrapWithin(tx, this.epochOf(tx.protocolVersion))), {
+			onNone: () => void 0,
+			onSome: (carried) => {
+				const key = submitTxHistoryKey(carried);
+				return history.find((entry) => isFinalizedWalletEntry(entry) && require_dist.coversTransaction(entry, key));
+			}
+		});
+	}
+	/** Sync can record inclusion before the independent pending-status poller observes it. */
+	async reconcileFinalizedTransaction(tx, history) {
+		const entry = this.finalizedEntryFor(tx, history);
+		if (entry === void 0) return false;
+		if (entry.status === "FAILURE" || entry.status === "PARTIAL_SUCCESS") await this.revertTransaction(tx);
+		else await this.pendingTransactionsService.clear(tx);
+		return true;
+	}
+	async revertTransaction(tx, reason) {
+		await Promise.all([
+			this.shielded.revertTransaction(tx),
+			this.unshielded.revertTransaction(tx),
+			this.dust.revertTransaction(tx)
+		]).then(async () => {
+			await this.pendingTransactionsService.clear(tx);
+			const key = require_dist.match$1(require_dist.getRight(require_dist.WalletTransaction.unwrapWithin(tx, this.epochOf(tx.protocolVersion))), {
+				onNone: () => void 0,
+				onSome: revertTxHistoryKey
+			});
+			if (key !== void 0) await this.#txHistoryStorage.gotRejected({
+				...key,
+				rejectedAt: this.clock.now(),
+				...reason !== void 0 ? { reason } : {}
+			});
+		});
+	}
+	/**
+	* Starts the wallets and their background synchronization.
+	*
+	* @remarks
+	*   Seeds, not key objects. A seed is the only key material that crosses a protocol boundary — every ledger version
+	*   derives its own keys from the same seed and arrives at the same identity — so a wallet started from seeds can
+	*   follow the chain across a fork, and one started from key objects of a single ledger version cannot. Derive them
+	*   once with `WalletSeeds.fromMasterSeed` and hand them over.
+	*
+	*   {@link FacadeKeysByEpoch} is the escape hatch for a caller that will not part with a seed. It requires **both**
+	*   ledger versions' key objects, because a wallet holding one side could not read the other side of the chain, and
+	*   it costs the caller an import of both ledger packages and the same derivation performed twice. A seed costs
+	*   neither.
+	* @example
+	*   ```typescript
+	*   await facade.start(WalletSeeds.fromMasterSeed(masterSeed));
+	*   ```;
+	*
+	* @param material The three wallets' seeds, or both ledger versions' key objects.
+	* @param options `manualSync` leaves the dust wallet unstarted in the background; drive it explicitly with
+	*   {@link doSync} instead (requires a dust wallet built with the projections sync service, see
+	*   `makeEventLessSyncService`).
+	*/
+	async start(material, options = {}) {
+		const keys = v9KeysOf(material);
+		await Promise.all([
+			this.shielded.start(keys.shielded),
+			this.unshielded.start(),
+			!options.manualSync ? this.dust.start(keys.dust) : void 0,
+			this.pendingTransactionsService.start()
+		]);
+	}
+	/**
+	* Runs a single dust synchronization pass and resolves when it completes. Only the dust wallet supports manual sync;
+	* the shielded and unshielded wallets keep syncing in the background via {@link start}.
+	*
+	* @param material The same material {@link start} was given.
+	*/
+	async doSync(material) {
+		await this.dust.stepSync(v9KeysOf(material).dust);
+	}
+	async stop() {
+		await Promise.all([
+			this.shielded.stop(),
+			this.unshielded.stop(),
+			this.dust.stop(),
+			this.submissionService.close(),
+			this.pendingTransactionsService.stop(),
+			Promise.resolve(this.#pendingSubscription?.unsubscribe()),
+			Promise.resolve(this.#protocolVersionSubscription?.unsubscribe())
+		]);
+	}
+	async queryTxHistoryByHash(hash) {
+		return this.#txHistoryStorage.get(hash);
+	}
+	async getAllFromTxHistory() {
+		return [...await this.#txHistoryStorage.getAll()];
+	}
+};
+//#endregion
+exports.BalancingRecipe = BalancingRecipe;
+Object.defineProperty(exports, "Clock", {
+	enumerable: true,
+	get: function() {
+		return require_dist.Clock_exports;
+	}
+});
+exports.DefaultForkSchedule = DefaultForkSchedule;
+exports.FacadeState = FacadeState;
+exports.ValidationFetchError = require_dist.ValidationFetchError;
+exports.WalletEntrySchema = WalletEntrySchema;
+exports.WalletFacade = WalletFacade;
+exports.WellFormedError = require_dist.WellFormedError;
+exports.isFinalizedWalletEntry = isFinalizedWalletEntry;
+exports.isPendingWalletEntry = isPendingWalletEntry;
+exports.lowestProtocolVersion = lowestProtocolVersion;
+exports.mergeWalletEntries = mergeWalletEntries;
+exports.pendingTransactionsOf = pendingTransactionsOf;
+exports.protocolPhaseOf = protocolPhaseOf;