@laceio/sdk 0.1.1 → 0.1.2-canary.0

package/dist/midnight.js

@@ -0,0 +1,1352 @@
+import { r as __exportAll } from "./rolldown-runtime-OvD0k9op.js";
+import "./_web-crypto-random-bytes-Bo-GTcRS.js";
+import { n as import_buffer, r as init__polyfill_buffer_patch } from "./_polyfill-buffer-patch-yNxN4d5E.js";
+import "./libsodium-wrappers-BhbOA8dQ.js";
+import "./codecs-Dc1Krpbt.js";
+import "./util-Cp5cZkfK.js";
+import { t as ByteArray } from "./bytes.vo-BB7_4JK6.js";
+import { A as ContractName, C as walletRepoStoreContract, E as featureStoreContract, M as WalletId, O as combineStore, S as WalletType, T as failuresStoreContract, _ as walletActiveStateDependencyContract, a as createInMemoryWalletEntity, b as addressesStoreContract, c as createLaceWallet, i as createBlockchainWalletEntity, j as ModuleName, k as createMixin, l as signerFactoryAddonContract, n as sdk_default$1, o as inMemoryIntegrationAddonContract, r as sdk_default, s as AuthSecret, t as sdk_default$2, v as tokensStoreContract, w as networkStoreContract, x as activitiesStoreContract, y as syncStoreContract } from "./sdk-Cb-gZnS9.js";
+import { s as Timestamp } from "./time.vo-tNheinXm.js";
+import { t as BigNumber } from "./bignum.vo-CEXOIew0.js";
+import { n as Ok, t as Err } from "./asyncoption-CruEYOBI.js";
+import { t as createPasskeyKeySource } from "./key-source-B08HukZg.js";
+import { a as inferStoreContext, i as inferModuleContext, n as combineContracts, r as inferContractContext } from "./store-DuBG8qh5.js";
+import { t as FEATURE_FLAG_NETWORK_TYPE } from "./const-CjmfjBP3.js";
+import { t as AccountId } from "./account-id.vo-OPz2v-JZ.js";
+import "./slice-DBpJ2QGf.js";
+import "./retry-config-Dmgt28wM.js";
+import { t as ActivityType } from "./activity-type-GsJGWs-3.js";
+import { t as TokenId } from "./token-id.vo-Bvwhr3ZE.js";
+import { c as MidnightSDKNetworkIds, d as NIGHT_TOKEN_ID, g as MidnightNetworkId, m as defaultTxTtlLength, s as MidnightSDKNetworkId, v as TEMENOS_PROOF_SERVER_MODES, y as assertProofServerRouting } from "./const-D0CbQlo4.js";
+import { t as MidnightAccountId } from "./midnight-account-id.vo-DjCAGcqc.js";
+import { i as midnightContextSelectors, n as midnightContextActions } from "./slice-oWnc7YVD.js";
+import { c as toUnshieldedTokenType, i as fromUnshieldedTokenType, s as isInMemoryMidnightAccount } from "./utils-DFwzEvbv.js";
+import { a as AttestationError, ju as FEATURE_FLAG_MIDNIGHT_UNSHIELDED, ku as FEATURE_FLAG_MIDNIGHT, l as createProvingProviderFromCircuits, t as midnightDustBalances } from "./watch-CUEvcP-V.js";
+import { ReplaySubject, catchError, combineLatest, concat, defaultIfEmpty, defer, distinctUntilChanged, filter, finalize, firstValueFrom, from, ignoreElements, map, of, scan, share, skipWhile, startWith, switchMap, take, tap, throwError, timeout, timer, withLatestFrom } from "rxjs";
+import { createAction } from "@reduxjs/toolkit";
+import { dummyLogger } from "ts-log";
+import { DustAddress, MidnightBech32m, ShieldedAddress, UnshieldedAddress } from "@midnightntwrk/wallet-sdk-address-format";
+import inRange from "lodash/inRange.js";
+import toLower from "lodash/toLower.js";
+import * as ledger from "@midnight-ntwrk/ledger-v8";
+import { addressFromKey } from "@midnight-ntwrk/ledger-v8";
+//#region src/create-midnight-accounts.ts
+/**
+* Derives a Midnight account index using the entity's encrypted recovery material.
+* Indexes must be integers in `[0, 2³¹)`. Omitted networks use the integration's
+* defaults. Rejects duplicate accounts, an entity with neither a Midnight
+* seed nor a recovery phrase (a passkey entity), unavailable integration and
+* decryption or derivation errors. Other blockchain accounts are preserved.
+*
+* Returns an updated entity without dispatching. For a new entity, dispatch
+* `wallets.addWallet`; for an existing one, dispatch `wallets.updateWallet`
+* with its updated `accounts` and `blockchainSpecific`.
+*/
+const createMidnightAccounts = async (wallet, props) => {
+	if (!Number.isInteger(props.accountIndex) || props.accountIndex < 0 || props.accountIndex >= 2 ** 31) throw new RangeError("Midnight account index must be an integer in [0, 2³¹)");
+	if (!props.wallet.blockchainSpecific.Midnight?.encryptedSeed && !props.wallet.encryptedRecoveryPhrase) throw new Error("The entity holds no Midnight seed and no recovery phrase: derive the accounts of a passkey entity with createMidnightPasskeyWalletEntity({ accounts })");
+	const integration = (await wallet._loadModules("addons.loadInMemoryWalletIntegration")).find((candidate) => candidate.blockchainName === "Midnight");
+	if (!integration) throw new Error("Midnight integration is not loaded");
+	const { wallet: updated } = await integration.addAccounts(props, { logger: dummyLogger });
+	const accountIds = updated.accounts.map((account) => account.accountId);
+	if (new Set(accountIds).size !== accountIds.length) throw new Error("Midnight account already exists");
+	return updated;
+};
+//#endregion
+//#region ../../packages/contract/midnight-context/src/store/index.ts
+var store_default = inferStoreContext({
+	load: async () => import("./init-BpHTq2R5.js"),
+	context: {
+		actions: midnightContextActions,
+		selectors: midnightContextSelectors
+	}
+});
+//#endregion
+//#region ../../packages/contract/midnight-context/src/contract.ts
+const midnightContextStoreContract = inferContractContext({
+	name: ContractName("midnight-context-store"),
+	instance: "exactly-one",
+	contractType: "store",
+	dependsOn: combineContracts([networkStoreContract, featureStoreContract]),
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, store_default) }))
+});
+const midnightDependencyContract = inferContractContext({
+	contractType: "sideEffectDependency",
+	name: ContractName("midnight-dependency"),
+	instance: "exactly-one"
+});
+//#endregion
+//#region ../../packages/contract/midnight-context/src/midnight-engine-addon.ts
+/**
+* Engine access for code outside the store, such as the SDK's Midnight
+* helpers. Implemented by the headless Midnight engine module only.
+*/
+const midnightEngineAddonContract = inferContractContext({
+	name: ContractName("midnight-engine-addon"),
+	instance: "exactly-one",
+	contractType: "addon",
+	provides: { addons: ["loadMidnightEngine"] }
+});
+//#endregion
+//#region ../../packages/contract/midnight-context/src/dust-utils.ts
+/**
+* Determines the designation target type based on NIGHT coin registration and dust balance.
+*
+* TODO: Update when SDK supports distinguishing self vs external designation.
+* Currently, the SDK's `registeredForDustGeneration` flag only indicates that NIGHT is
+* participating in dust generation, but does not specify the target dust address.
+* Until SDK provides this information, we treat all designation as 'self'.
+*
+* @returns 'self' when user has designation (registered NIGHT or dust balance), 'none' otherwise.
+* Note: 'external' is not returned until SDK supports proper detection.
+*/
+const getDesignationTargetType = (coins, currentDustValue) => {
+	return coins.some((coin) => coin.registeredForDustGeneration === true) || currentDustValue > 0n ? "self" : "none";
+};
+const TOKEN_FORBIDDEN_NAMES = [
+	"dust",
+	"lace",
+	"midnight",
+	"tdust",
+	"night",
+	"tnight"
+];
+/** Checks reserved and additional excluded names case-insensitively; trim input first. */
+const isForbiddenTokenName = (name, extraExcludedTokenNames = []) => [...TOKEN_FORBIDDEN_NAMES, ...extraExcludedTokenNames.map(toLower)].includes(toLower(name));
+/** Checks case-insensitive display-name collisions; omit the current token from the list. */
+const isTakenTokenName = (name, takenTokenNames = []) => takenTokenNames.map(toLower).includes(toLower(name));
+const createTokenNameValidator = (minLength, maxLength) => (name, excludedNames = []) => {
+	const isInvalidNameLength = !inRange(name.trim().length, minLength, maxLength + 1);
+	return !(isForbiddenTokenName(name, excludedNames) || isInvalidNameLength);
+};
+/** Validates display-name length and reserved names; trim before validating and saving. */
+const isTokenFullNameValid = createTokenNameValidator(1, 30);
+/** Validates ticker length and reserved names; trim before validating and saving. */
+const isTokenShortNameValid = createTokenNameValidator(1, 4);
+/** Direct import of this is an anti-pattern. OK for tests. */
+const midnightSyncActions = { midnightSync: {
+	requestResync: createAction("midnight/requestResync"),
+	resync: createAction("midnight/resync"),
+	restartWalletWatch: createAction("midnight/restartWalletWatch"),
+	restartAccountWatch: createAction("midnight/restartAccountWatch")
+} };
+//#endregion
+//#region ../../packages/module/midnight-sync/src/store/prepare-midnight-tx.ts
+const constructDustDesignationTransaction = ({ address, networkId, nightUtxos, nightVerifyingKey, ttl = new Date(Date.now() + defaultTxTtlLength), allowFeePayment }) => {
+	const parsedAddress = MidnightBech32m.parse(address);
+	const receiverData = DustAddress.codec.decode(networkId, parsedAddress).data;
+	const currentTime = /* @__PURE__ */ new Date();
+	const intent = ledger.Intent.new(ttl);
+	const totalNightValue = nightUtxos.map(({ utxo: { value } }) => BigNumber.valueOf(value)).reduce((total, value) => total + value, 0n);
+	const inputs = nightUtxos.map(({ utxo }) => ({
+		...utxo,
+		owner: nightVerifyingKey
+	}));
+	const outputs = inputs.map((input) => ({
+		owner: ledger.addressFromKey(nightVerifyingKey),
+		type: input.type,
+		value: input.value
+	}));
+	intent.guaranteedUnshieldedOffer = ledger.UnshieldedOffer.new(inputs, outputs, []);
+	const dustRegistration = new ledger.DustRegistration("signature", nightVerifyingKey, receiverData, allowFeePayment ?? totalNightValue);
+	intent.dustActions = new ledger.DustActions("signature", "pre-proof", currentTime, [], [dustRegistration]);
+	return ledger.Transaction.fromParts(networkId, void 0, void 0, intent);
+};
+const constructUnshieldedTransaction = ({ networkId, transfers, ttl = new Date(Date.now() + defaultTxTtlLength) }) => {
+	const intent = ledger.Intent.new(ttl);
+	const outputs = transfers.map(({ address, amount, tokenId }) => ({
+		value: amount,
+		owner: UnshieldedAddress.codec.decode(networkId, MidnightBech32m.parse(address)).data.toString("hex"),
+		type: tokenId
+	}));
+	intent.guaranteedUnshieldedOffer = ledger.UnshieldedOffer.new([], outputs, []);
+	return ledger.Transaction.fromParts(networkId, void 0, void 0, intent);
+};
+const constructShieldedTransaction = ({ networkId, transfers }) => {
+	const toOffer = ({ address, amount, tokenId }) => {
+		const decodedAddress = ShieldedAddress.codec.decode(networkId, MidnightBech32m.parse(address));
+		const output = ledger.ZswapOutput.new(ledger.createShieldedCoinInfo(tokenId, amount), 0, decodedAddress.coinPublicKey.toHexString(), decodedAddress.encryptionPublicKey.toHexString());
+		return ledger.ZswapOffer.fromOutput(output, tokenId, amount);
+	};
+	const [firstTransfer, ...remainingTransfers] = transfers;
+	if (!firstTransfer) throw new Error("At least one token transfer is required");
+	const offer = remainingTransfers.map(toOffer).reduce((merged, singleton) => merged.merge(singleton), toOffer(firstTransfer));
+	return ledger.Transaction.fromParts(networkId, offer);
+};
+/** Normalize token-state IDs and reject a batch before any engine operation. */
+const normalizeMidnightTransfers = (networkId, kind, outputs) => {
+	if (kind !== "shielded" && kind !== "unshielded") throw new Error("Unsupported Midnight transfer kind");
+	if (outputs.length === 0) throw new Error("At least one token transfer is required");
+	return outputs.map(({ to, tokenId, amount }) => {
+		if (typeof amount !== "bigint" || amount <= 0n) throw new Error("Transfer amount must be a positive bigint");
+		const prefix = `unshielded-${networkId}`;
+		if (kind === "unshielded" && !tokenId.startsWith(prefix)) throw new Error("Unshielded token ID must match the transfer kind and network");
+		const raw = kind === "unshielded" ? fromUnshieldedTokenType(tokenId, networkId) : tokenId;
+		if (!/^[0-9a-f]{64}$/.test(raw)) throw new Error("Invalid token ID or token-kind mismatch");
+		const parsed = MidnightBech32m.parse(to);
+		if (kind === "shielded") ShieldedAddress.codec.decode(networkId, parsed);
+		else UnshieldedAddress.codec.decode(networkId, parsed);
+		return {
+			address: to,
+			tokenId: TokenId(raw),
+			amount
+		};
+	});
+};
+/** Keep designation's zero-fee exception identical in headless and UI preparation. */
+const estimatePreparedMidnightFee = (wallet, tx, { isDustDesignation, dustBalance, areKeysAvailable }) => {
+	if (isDustDesignation && dustBalance === 0n) return of(0n);
+	return areKeysAvailable ? wallet.estimateTransactionFee(tx, { currentTime: /* @__PURE__ */ new Date() }) : wallet.calculateTransactionFee(tx);
+};
+//#endregion
+//#region ../../packages/lib/vendor/src/temenos-attested-prover.ts
+var TemenosAttestationError = class extends AttestationError {
+	constructor(phase, checkId) {
+		super("temenos", phase === "obtain-evidence" ? "evidence" : phase === "fetch-expected-values" ? "policy" : phase === "bind-channel" ? "channel" : "appraisal", checkId ? `Temenos attestation failed: check "${checkId}" of phase "${phase}"` : `Temenos attestation failed at phase "${phase}"`);
+		this.phase = phase;
+		this.checkId = checkId;
+		this.name = "TemenosAttestationError";
+	}
+};
+/**
+* `pointerContractAddress` is the one on-chain constant: the pointer's
+* `current` cell names the attestation ledger, so a ledger redeploy is a
+* pointer update, not a Lace release. All Temenos deployments register on the
+* single preprod pointer, whatever network the proof server serves, so this
+* stays on preprod on every network. The caller resolves the ledger
+* indexer from Lace configuration at the start of each attestation run.
+*
+* `wardenTlsCertificate` is empty by design: a browser context cannot pin
+* the transport certificate, so the Warden is reached over public WebPKI
+* TLS — its verdict is defense-in-depth on top of the local checks, not a
+* trust root.
+*/
+const SHARED_TEMENOS_DEPLOYMENT = {
+	pointerContractAddress: "a58974f1cacda177edfea3bdc76c1cd48d5e3107b9a543b9d65cee6b454c9122",
+	wardenUrl: "https://warden.wastedp.io",
+	wardenTlsCertificate: ""
+};
+const TEMENOS_PREPROD_DEPLOYMENT = {
+	...SHARED_TEMENOS_DEPLOYMENT,
+	proofServerApiUrl: "https://api.proofserver.wastedp.io",
+	attestationHost: "attestation.proofserver.wastedp.io",
+	akxServerUrl: "https://attestation.proofserver.wastedp.io/tee_attestation",
+	applicationId: "afe48970b7083e1b2855acce95a488e93a7c257a34f6275e77ac26f79ac7ad05"
+};
+/**
+* Attestation parameters per network, matching `TEMENOS_PROOF_SERVER_MODES`
+* entry for entry. Values are build-baked and reviewed like code; the
+* persisted mode carries only the URL, so nothing here can be injected via
+* feature-flag payloads.
+*/
+const TEMENOS_ATTESTATION_CONFIGS = {
+	mainnet: {
+		...SHARED_TEMENOS_DEPLOYMENT,
+		proofServerApiUrl: "https://api.proofserver.mainnet.wastedp.io",
+		attestationHost: "attestation.proofserver.mainnet.wastedp.io",
+		akxServerUrl: "https://attestation.proofserver.mainnet.wastedp.io/tee_attestation",
+		applicationId: "70402462424c122c65e2d3d2312757face3974940c9ac5d09249b61028350427"
+	},
+	preprod: TEMENOS_PREPROD_DEPLOYMENT,
+	preview: {
+		...SHARED_TEMENOS_DEPLOYMENT,
+		proofServerApiUrl: "https://api.proofserver.preview.wastedp.io",
+		attestationHost: "attestation.proofserver.preview.wastedp.io",
+		akxServerUrl: "https://attestation.proofserver.preview.wastedp.io/tee_attestation",
+		applicationId: "b294b8879607f7d0f5cca3808a4b64aab7992de2a73d1e55dbafb091efca25f2"
+	}
+};
+for (const [networkId, mode] of Object.entries(TEMENOS_PROOF_SERVER_MODES)) {
+	if (!mode) continue;
+	if (TEMENOS_ATTESTATION_CONFIGS[networkId]?.proofServerApiUrl !== mode.url) throw new Error(`TEMENOS_PROOF_SERVER_MODES[${networkId}] ("${mode.url}") has no matching entry in TEMENOS_ATTESTATION_CONFIGS`);
+}
+/** temenos-spec phases 1–5 of the AKX flow, in execution order. */
+const TEMENOS_ATTESTATION_PHASES = [
+	"obtain-evidence",
+	"fetch-expected-values",
+	"verify-locally",
+	"warden-verify",
+	"bind-channel"
+];
+const PHASE_MAP = {
+	"obtain-evidence": "obtain-evidence",
+	"fetch-expected-values": "fetch-expected-values",
+	"verify-locally": "verify-locally",
+	"warden-verify": "warden-verify",
+	"bind-channel": "bind-channel"
+};
+/**
+* `nonce-freshness` belongs to the library's SPKI-pin flow, which Lace never
+* runs (the AKX evidence provider always yields epoch-key evidence) — it has
+* no contract ID, so its events are dropped rather than mislabeled.
+*/
+const mapCheckId = (id) => id === "nonce-freshness" ? void 0 : id;
+const mapPhaseEvent = (event) => {
+	if (event.status === "check") {
+		const id = mapCheckId(event.check.id);
+		if (!id) return void 0;
+		return {
+			type: "check",
+			check: {
+				id,
+				status: event.check.status,
+				detail: event.check.detail
+			}
+		};
+	}
+	if (event.phase === "prove") return void 0;
+	const phase = PHASE_MAP[event.phase];
+	switch (event.status) {
+		case "started": return {
+			type: "phase",
+			phase,
+			status: "started"
+		};
+		case "completed": return {
+			type: "phase",
+			phase,
+			status: "completed",
+			...event.detail === void 0 ? {} : { detail: event.detail }
+		};
+		case "failed": return {
+			type: "phase",
+			phase,
+			status: "failed",
+			detail: event.error.message
+		};
+	}
+};
+const toTemenosAttestationError = (error, fallbackPhase, { LocalCheckFailedError, AttestationVerificationError }) => {
+	const mapped = error instanceof LocalCheckFailedError ? new TemenosAttestationError("verify-locally", mapCheckId(error.checkId)) : error instanceof AttestationVerificationError ? new TemenosAttestationError(error.phase === "prove" ? fallbackPhase : PHASE_MAP[error.phase]) : new TemenosAttestationError(fallbackPhase);
+	mapped.cause = error;
+	return mapped;
+};
+/**
+* `/prove` payloads travel as AEAD records tunneled through the AKX channel.
+* The enclave proxy forwards to `/prove` only, so the session offers nothing
+* else: the public API endpoint is never contacted from this flow.
+*/
+const createTunneledSession = (session) => ({
+	prove: async (payload) => {
+		const response = await session.prove({ body: payload });
+		if (response.status !== 200) throw new Error(`Proof server returned ${response.status} through the attested channel`);
+		return response.body;
+	},
+	close: async () => session.close()
+});
+/**
+* {@link createTemenosAttestedProver} with a deployment override that replaces
+* the baked deployment and skips its proof-server URL match. No public entry
+* re-exports it; only tests driving the verifier library's mock fixtures pass
+* the override.
+*
+* @internal
+*/
+const createTemenosAttestedProverWith = ({ networkId, proofServerApiUrl, trustRoots, getLedgerIndexerUrl, verifier }, testSeam) => {
+	const baked = TEMENOS_ATTESTATION_CONFIGS[networkId];
+	const deployment = testSeam?.config ?? (baked?.proofServerApiUrl === proofServerApiUrl ? baked : void 0);
+	if (!deployment) throw new Error(`No baked Temenos attestation config on ${networkId} for proof server "${proofServerApiUrl}"`);
+	if (!trustRoots?.amdRootCertificates?.length || trustRoots.amdRootCertificates.some((root) => root.trim().length === 0)) throw new AttestationError("temenos", "policy", "Temenos requires explicit AMD trust roots");
+	const amdRootCertificates = [...trustRoots.amdRootCertificates];
+	return {
+		id: "temenos",
+		operations: ["prove"],
+		phases: TEMENOS_ATTESTATION_PHASES,
+		establishAttestedSession: async (onEvent, signal) => {
+			signal?.throwIfAborted();
+			const config = {
+				...deployment,
+				amdRootCertificates,
+				indexerUrl: await getLedgerIndexerUrl()
+			};
+			const operationVerifier = verifier.createVerifier(config, signal);
+			let currentPhase = "obtain-evidence";
+			try {
+				return createTunneledSession(await operationVerifier.establishVerifiedSession((event) => {
+					if (event.status === "started") signal?.throwIfAborted();
+					if (event.status === "started" && event.phase !== "prove") currentPhase = PHASE_MAP[event.phase];
+					const mapped = mapPhaseEvent(event);
+					if (mapped) onEvent(mapped);
+				}));
+			} catch (error) {
+				throw toTemenosAttestationError(error, currentPhase, verifier);
+			}
+		}
+	};
+};
+/**
+* The real Temenos attestation driver: runs the verifier library's full
+* pipeline — evidence from `GET /enclave-key`, expected values from the
+* on-chain registration via the indexer, the nine local checks against
+* explicitly supplied AMD roots, Warden verification, and the AKX
+* attested-channel handshake — then hands back a session that tunnels
+* through that channel. Trust-root sourcing is separate from this adapter.
+* Only the deployment baked for `networkId` is accepted, and only
+* when `proofServerApiUrl` names its proof server.
+*/
+const createTemenosAttestedProver = (props) => createTemenosAttestedProverWith(props);
+//#endregion
+//#region ../../packages/module/midnight-sync/src/sdk.ts
+const createMidnightSyncModule = (options) => inferModuleContext({
+	moduleName: ModuleName("midnight-sync"),
+	implements: combineContracts([
+		inMemoryIntegrationAddonContract,
+		tokensStoreContract,
+		syncStoreContract,
+		addressesStoreContract,
+		midnightContextStoreContract,
+		midnightDependencyContract,
+		midnightEngineAddonContract,
+		signerFactoryAddonContract
+	]),
+	dependsOn: combineContracts([
+		activitiesStoreContract,
+		failuresStoreContract,
+		featureStoreContract,
+		networkStoreContract,
+		walletActiveStateDependencyContract,
+		walletRepoStoreContract
+	]),
+	feature: {
+		willLoad: (featureFlags) => featureFlags.some((flag) => flag.key === FEATURE_FLAG_MIDNIGHT),
+		metadata: {
+			name: "MidnightSync",
+			description: "Midnight engine, wallet lifecycle and signer"
+		}
+	},
+	store: inferStoreContext({
+		load: async () => {
+			const { createSdkStoreInit } = await import("./sdk-init-Bln9rFtn.js");
+			return { default: createSdkStoreInit(options) };
+		},
+		context: {
+			actions: midnightSyncActions,
+			selectors: {}
+		}
+	}),
+	addons: {
+		loadSignerFactory: async () => import("./signer-factory-hzSRaIw2.js"),
+		loadMidnightEngine: async () => import("./midnight-engine-DpemplKO.js"),
+		loadInMemoryWalletIntegration: async () => import("./in-memory-wallet-integration-CBRiPjLO.js").then((module) => ({ default: module.inMemoryWalletIntegrationReactNative }))
+	}
+});
+//#endregion
+//#region src/midnight-module.ts
+const publicEndpoints = (networkId) => ({
+	nodeAddress: `https://rpc.${networkId}.midnight.network`,
+	indexerAddress: `https://indexer.${networkId}.midnight.network/api/v4/graphql`
+});
+/**
+* The public Midnight endpoints the SDK syncs through by default. Every other
+* network needs its endpoints from `networks` before `selectMidnightNetwork`
+* accepts it.
+*/
+const MIDNIGHT_PUBLIC_ENDPOINTS = {
+	[MidnightSDKNetworkIds.MainNet]: publicEndpoints(MidnightSDKNetworkIds.MainNet),
+	[MidnightSDKNetworkIds.PreProd]: publicEndpoints(MidnightSDKNetworkIds.PreProd),
+	[MidnightSDKNetworkIds.Preview]: publicEndpoints(MidnightSDKNetworkIds.Preview),
+	[MidnightSDKNetworkIds.QaNet]: publicEndpoints(MidnightSDKNetworkIds.QaNet)
+};
+/** The public node of Midnight Preview. */
+const MIDNIGHT_PREVIEW_NODE_URL = MIDNIGHT_PUBLIC_ENDPOINTS[MidnightSDKNetworkIds.Preview].nodeAddress;
+/** The public indexer of Midnight Preview. */
+const MIDNIGHT_PREVIEW_INDEXER_URL = MIDNIGHT_PUBLIC_ENDPOINTS[MidnightSDKNetworkIds.Preview].indexerAddress;
+/** A proof server on the consumer's own machine, the default prover. */
+const MIDNIGHT_LOCAL_PROOF_SERVER_URL = "http://localhost:6300";
+const isPublicNetworkId = (networkId) => networkId in MIDNIGHT_PUBLIC_ENDPOINTS;
+const passwordAuth = (password) => {
+	const owned = ByteArray.clone(ByteArray(password));
+	return {
+		authenticate: () => of(true),
+		accessAuthSecret: (callback) => {
+			const clone = AuthSecret(ByteArray.clone(owned));
+			return callback(clone).pipe(tap(() => clone.fill(0)), finalize(() => clone.fill(0)));
+		}
+	};
+};
+const proofServerMode = (url) => {
+	const { hostname } = new URL(url);
+	return hostname === "localhost" || hostname === "127.0.0.1" ? {
+		kind: "local-host",
+		url
+	} : {
+		kind: "delegated",
+		url,
+		label: hostname
+	};
+};
+const defaultProofServers = (proofServerUrl, networks, createAttestedProver) => Object.fromEntries(MidnightSDKNetworkId.map((networkId) => {
+	const mode = networks[networkId]?.proofServer ?? proofServerMode(proofServerUrl);
+	assertProofServerRouting(mode, !!createAttestedProver);
+	return [networkId, mode];
+}));
+const networkOverrides = (networks) => Object.fromEntries(MidnightSDKNetworkId.map((networkId) => {
+	const { proofServer: _, ...endpoints } = networks[networkId] ?? {};
+	return [networkId, {
+		...isPublicNetworkId(networkId) && MIDNIGHT_PUBLIC_ENDPOINTS[networkId],
+		...endpoints
+	}];
+}));
+/** The networks whose overrides carry both endpoints; the contract defaults are not served. */
+const supportedNetworkIds = (overrides) => MidnightSDKNetworkId.filter((networkId) => overrides[networkId]?.nodeAddress !== void 0 && overrides[networkId]?.indexerAddress !== void 0);
+/**
+* The Midnight engine for `createLaceWallet`: syncs every in-memory Midnight
+* account on the active network, persists its state through the loaded
+* storage module and signs with the password instead of a prompt. Loads
+* behind `FEATURE_FLAG_MIDNIGHT`. The password is copied here, but the
+* caller's buffer must stay intact until its last entity helper call that
+* takes the same bytes.
+*
+* The `config` of `createLaceWallet` must then set
+* `defaultMidnightTestnetNetworkId`, the testnet a wallet starts on, as
+* Cardano needs `defaultTestnetChainId`; without a testnet there,
+* `createLaceWallet` rejects.
+*/
+const createMidnightModule = ({ password, proofServerUrl = MIDNIGHT_LOCAL_PROOF_SERVER_URL, networks = {}, batchUpdates, createAttestedProver }) => {
+	const overrides = networkOverrides(networks);
+	return createMidnightSyncModule({
+		auth: passwordAuth(password),
+		networks: overrides,
+		supportedNetworkIds: supportedNetworkIds(overrides),
+		defaultProofServers: defaultProofServers(proofServerUrl, networks, createAttestedProver),
+		batchUpdates,
+		createAttestedProver
+	});
+};
+//#endregion
+//#region src/midnight-passkey-wallet-entity.ts
+/**
+* Derives the Midnight accounts of the passkey's words inside one assertion.
+* Unlike the Cardano passkey entity, the result is an `InMemory` wallet: the
+* Midnight engine needs the account keys while it syncs, so each account
+* holds its keys sealed under `password`. The entity holds no recovery
+* phrase and no seed, and no account of another blockchain.
+*/
+const createMidnightPasskeyWalletEntity = async (wallet, { keySource, password, walletName, accounts = [] }) => keySource.withPasskeyMnemonic(async (words) => {
+	let entity = await createBlockchainWalletEntity(wallet, "Midnight", {
+		mnemonicWords: [...words],
+		password,
+		walletName
+	});
+	if (entity.accounts.length === 0) throw new Error("No Midnight account derived: load createMidnightModule behind FEATURE_FLAG_MIDNIGHT");
+	for (const account of accounts) entity = await createMidnightAccounts(wallet, {
+		...account,
+		wallet: entity,
+		password
+	});
+	return withoutSeedMaterial(entity);
+});
+const withoutSeedMaterial = ({ encryptedRecoveryPhrase: _phrase, blockchainSpecific: { Midnight: _seed, ...blockchainSpecific }, ...entity }) => ({
+	...entity,
+	blockchainSpecific
+});
+//#endregion
+//#region src/midnight-errors.ts
+/** The loadout has no endpoints for the network: none public, none from `networks`. */
+var MidnightNetworkNotConfiguredError = class extends Error {
+	code = "midnight-network-not-configured";
+	constructor(networkId) {
+		super(`Midnight network "${networkId}" has no endpoints in this loadout: pass networks.${networkId} with nodeAddress and indexerAddress to createMidnightModule`);
+		this.name = "MidnightNetworkNotConfiguredError";
+	}
+};
+/** No single in-memory Midnight account on the active network answers the request. */
+var MidnightAccountNotFoundError = class extends Error {
+	code = "midnight-account-not-found";
+	constructor(message) {
+		super(message);
+		this.name = "MidnightAccountNotFoundError";
+	}
+};
+/** The engine did not start the account's wallets within the wait. */
+var MidnightWalletNotReadyError = class extends Error {
+	code = "midnight-wallet-not-ready";
+	constructor(accountId, timeoutMs) {
+		super(`Midnight wallet for account "${accountId}" did not start within ${timeoutMs}ms`);
+		this.name = "MidnightWalletNotReadyError";
+	}
+};
+/** The account holds no available NIGHT to register for DUST generation. */
+var MidnightNothingToRegisterError = class extends Error {
+	code = "midnight-nothing-to-register";
+	constructor(accountId) {
+		super(`Account "${accountId}" has no available NIGHT to register`);
+		this.name = "MidnightNothingToRegisterError";
+	}
+};
+/**
+* `submitMidnightTx` stopped waiting for the node to report the transaction final. The engine had already been
+* given the transaction, so it may be on chain or reach it later: look for `activityHash` in the account's
+* activities before submitting again.
+*/
+var MidnightSubmitTimeoutError = class extends Error {
+	code = "midnight-submit-timeout";
+	/** The transaction's hash, which is the `activityId` of its activity. */
+	activityHash;
+	constructor(activityHash, timeoutMs) {
+		super(`Midnight transaction ${activityHash} was not reported final within ${timeoutMs}ms and may still reach the chain`);
+		this.name = "MidnightSubmitTimeoutError";
+		this.activityHash = activityHash;
+	}
+};
+//#endregion
+//#region src/select-midnight-network.ts
+/**
+* Makes `networkId` the active Midnight network. A testnet also becomes the
+* selected testnet, so the wallet's testnet toggle returns to it. Throws
+* `MidnightNetworkNotConfiguredError` for a network the loadout has no
+* endpoints for: one outside `MIDNIGHT_PUBLIC_ENDPOINTS` whose `networks`
+* override lacks `nodeAddress` or `indexerAddress`.
+*/
+const selectMidnightNetwork = (wallet, networkId) => {
+	if (!(wallet.getState().midnightContext?.supportedNetworksIds ?? []).includes(networkId)) throw new MidnightNetworkNotConfiguredError(networkId);
+	if (networkId === MidnightSDKNetworkIds.MainNet) {
+		wallet.dispatch("network.setNetworkType", "mainnet");
+		return;
+	}
+	wallet.dispatch("network.setBlockchainNetworks", {
+		blockchain: "Midnight",
+		mainnet: MidnightNetworkId(MidnightSDKNetworkIds.MainNet),
+		testnet: MidnightNetworkId(networkId)
+	});
+	wallet.dispatch("network.setNetworkType", "testnet");
+};
+//#endregion
+//#region src/midnight-timeouts.ts
+/** The longest delay a timer honours; a longer one, or `Infinity`, fires at once. */
+const MAX_TIMEOUT_MS = 2 ** 31 - 1;
+/**
+* Applies a timeout option's default and refuses a value no timer can honour:
+* not a finite positive number of milliseconds, or above `MAX_TIMEOUT_MS`.
+*/
+const resolveTimeoutMs = (name, value, fallback) => {
+	const resolved = value ?? fallback;
+	if (typeof resolved !== "number" || !Number.isFinite(resolved) || resolved <= 0 || resolved > MAX_TIMEOUT_MS) throw new RangeError(`${name} must be a positive number of milliseconds up to ${MAX_TIMEOUT_MS}; got ${String(resolved)}`);
+	return resolved;
+};
+//#endregion
+//#region src/midnight-wallet.ts
+const DEFAULT_START_TIMEOUT_MS = 12e4;
+const resolveMidnightAccountId = async ({ stateObservables }, requestedAccountId) => {
+	const wallets = await firstValueFrom(stateObservables.wallets.selectAll$);
+	const activeNetworkIds = await firstValueFrom(stateObservables.network.selectAllActiveNetworkIds$);
+	const accounts = wallets.flatMap((wallet) => wallet.accounts).filter(isInMemoryMidnightAccount).filter((account) => activeNetworkIds.includes(account.blockchainNetworkId));
+	if (requestedAccountId) {
+		const found = accounts.find((account) => account.accountId === requestedAccountId);
+		if (!found) throw new MidnightAccountNotFoundError(`Midnight account "${requestedAccountId}" not found on the active network`);
+		return found.accountId;
+	}
+	if (accounts.length === 0) throw new MidnightAccountNotFoundError("No Midnight accounts found on the active network");
+	if (accounts.length > 1) throw new MidnightAccountNotFoundError(`Multiple Midnight accounts found (${accounts.length}) — specify accountId to disambiguate`);
+	return accounts[0].accountId;
+};
+/**
+* The engine's wallet for the account, emitted once the engine starts it and
+* again whenever the engine replaces it (a sync reset or a restart). Emits
+* `undefined` while the engine has stopped the account's wallet and not yet
+* replaced it. Resolves the account on subscription and errors with
+* `MidnightAccountNotFoundError`, or with `MidnightWalletNotReadyError` when
+* no wallet arrives within `startTimeout`, at first or after a stop, so a
+* subscriber that was already watching fails the same way a new one would.
+*/
+const observeMidnightWallet = (wallet, { accountId, startTimeout: requestedStartTimeout }) => defer(async () => {
+	const startTimeout = resolveTimeoutMs("startTimeout", requestedStartTimeout, DEFAULT_START_TIMEOUT_MS);
+	const resolvedAccountId = await resolveMidnightAccountId(wallet, accountId);
+	const [registry$] = await wallet._loadModules("addons.loadMidnightEngine");
+	if (!registry$) throw new MidnightWalletNotReadyError(resolvedAccountId, startTimeout);
+	return {
+		resolvedAccountId,
+		registry$,
+		startTimeout
+	};
+}).pipe(switchMap(({ resolvedAccountId, registry$, startTimeout }) => {
+	const notReady = () => throwError(() => new MidnightWalletNotReadyError(resolvedAccountId, startTimeout));
+	return registry$.pipe(map((wallets) => wallets[resolvedAccountId]), distinctUntilChanged(), skipWhile((candidate) => !candidate), timeout({
+		first: startTimeout,
+		with: notReady
+	}), switchMap((candidate) => candidate ? of(candidate) : concat(of(void 0), timer(startTimeout).pipe(switchMap(notReady)))));
+}));
+/** The engine's wallet for the account, once the engine has started it. */
+const midnightWalletFor = async (wallet, props) => firstValueFrom(observeMidnightWallet(wallet, props).pipe(filter((candidate) => !!candidate)));
+const toError = (error) => error instanceof Error ? error : new Error(String(error));
+/** Runs one engine operation for the account and settles it as a `Result`. */
+const withMidnightWallet = async (wallet, props, operation) => {
+	try {
+		return Ok(await firstValueFrom(operation(await midnightWalletFor(wallet, props))));
+	} catch (error) {
+		return Err(toError(error));
+	}
+};
+//#endregion
+//#region src/observe-midnight-balances.ts
+const sumNight = (coins) => coins.filter(({ utxo }) => utxo.type === NIGHT_TOKEN_ID).reduce((sum, { utxo }) => sum + utxo.value, 0n);
+const sameBalances = (a, b) => a.address.unshielded === b.address.unshielded && a.night.available === b.night.available && a.night.pending === b.night.pending && a.dust.balance === b.dust.balance && a.dust.available === b.dust.available && a.synced.unshielded === b.synced.unshielded && a.synced.shielded === b.synced.shielded && a.synced.dust === b.synced.dust;
+const NOT_SYNCED = {
+	unshielded: false,
+	shielded: false,
+	dust: false
+};
+const balancesOf = (midnightWallet) => combineLatest([
+	midnightWallet.state(),
+	midnightWallet.syncProgress$,
+	midnightWallet.address$
+]).pipe(map(([state, progress, address]) => ({
+	accountId: midnightWallet.accountId,
+	address,
+	night: {
+		available: sumNight(state.unshielded.availableCoins),
+		pending: sumNight(state.unshielded.pendingCoins)
+	},
+	dust: midnightDustBalances(state),
+	synced: progress.isStrictlyComplete
+})));
+/**
+* The account's NIGHT and DUST, straight from the engine, from the moment
+* it starts the account's wallets. Balances are complete once `synced`
+* reports the sub-wallet caught up; a transfer needs unshielded and dust.
+* NIGHT is summed from the engine's state, not from the store's token
+* balances; DUST is summed as the store sums it.
+*
+* Follows the engine across a sync reset or restart. While the engine has
+* stopped the account's wallets and not yet replaced them, it repeats the
+* last balances with every `synced` flag false; once the new wallets start,
+* it emits theirs.
+*
+* Cold: the account is resolved on subscription. Errors the subscriber with
+* `MidnightAccountNotFoundError`, or with `MidnightWalletNotReadyError` when
+* no wallets run for `startTimeout`, at first or after a stop.
+*/
+const observeMidnightBalances = (wallet, props = {}) => observeMidnightWallet(wallet, props).pipe(switchMap((midnightWallet) => midnightWallet ? balancesOf(midnightWallet) : of(void 0)), scan((last, next) => next ?? (last && {
+	...last,
+	synced: NOT_SYNCED
+}), void 0), filter((balances) => !!balances), distinctUntilChanged(sameBalances));
+//#endregion
+//#region src/balance-midnight-recipe.ts
+const messageOf = (error) => error instanceof Error ? error.message : String(error);
+/**
+* Releases a recipe the engine built, then rethrows the error that made it
+* useless. The engine reserves a recipe's inputs when it builds it and the
+* caller never receives this recipe, so nothing else could release them. If
+* the release fails too, the error is an `AggregateError` of both failures and
+* the coins stay reserved until a sync reset.
+*/
+const releaseThenThrow = (midnightWallet, recipe, error) => concat(midnightWallet.revert(recipe).pipe(ignoreElements(), catchError((releaseError) => throwError(() => new AggregateError([error, releaseError], `${messageOf(error)}; the coins it reserved could not be released: ${messageOf(releaseError)}`)))), throwError(() => error));
+/**
+* Pays a built recipe's fee with DUST. The engine books the recipe's inputs
+* when it builds it, so a failure here releases them before the error is
+* returned: the caller has no recipe to discard.
+*/
+const balanceMidnightRecipe = (midnightWallet, recipe, ttl) => midnightWallet.balanceUnprovenTransaction(recipe.transaction, {
+	ttl,
+	tokenKindsToBalance: ["dust"]
+}).pipe(catchError((balancingError) => releaseThenThrow(midnightWallet, recipe, balancingError)));
+//#endregion
+//#region src/build-midnight-transfer.ts
+/**
+* Builds an unshielded NIGHT transfer, selecting the inputs and the DUST
+* that pays its fee. The recipe is unsigned and unproven, and reserves its
+* inputs (see `MidnightTxRecipe`): obtain consent from `estimateMidnightFee`,
+* which reserves nothing, before building. When the fee cannot be paid, the
+* inputs the build reserved are released and the balancing error is returned;
+* if that release fails too, the error is an `AggregateError` of both failures
+* and the NIGHT stays reserved until a sync reset.
+*/
+const buildMidnightTransfer = async (wallet, { to, amount, ttl, ...account }) => withMidnightWallet(wallet, account, (midnightWallet) => defer(() => {
+	normalizeMidnightTransfers(midnightWallet.networkId, "unshielded", [{
+		to,
+		amount,
+		tokenId: toUnshieldedTokenType(NIGHT_TOKEN_ID, midnightWallet.networkId)
+	}]);
+	const resolvedTtl = ttl ?? new Date(Date.now() + 36e5);
+	return midnightWallet.transferTransaction([{
+		type: "unshielded",
+		outputs: [{
+			type: NIGHT_TOKEN_ID,
+			receiverAddress: UnshieldedAddress.codec.decode(midnightWallet.networkId, MidnightBech32m.parse(to)),
+			amount
+		}]
+	}], {
+		ttl: resolvedTtl,
+		payFees: false
+	}).pipe(switchMap((recipe) => balanceMidnightRecipe(midnightWallet, recipe, resolvedTtl)));
+}));
+//#endregion
+//#region src/build-midnight-transfers.ts
+/**
+* Builds an unsigned, unproven batch. The engine selects tokens and fee DUST
+* and reserves them (see `MidnightTxRecipe`): obtain consent from
+* `estimateMidnightFee`, which reserves nothing, before building. When the
+* fee cannot be paid, the inputs the build reserved are released and the
+* balancing error is returned; if that release fails too, the error is an
+* `AggregateError` of both failures and the coins stay reserved until a sync
+* reset.
+*/
+const buildMidnightTransfers = async (wallet, { kind, outputs, ttl, ...account }) => withMidnightWallet(wallet, account, (engine) => defer(() => {
+	const transfers = normalizeMidnightTransfers(engine.networkId, kind, outputs);
+	const desiredOutputs = kind === "shielded" ? {
+		type: "shielded",
+		outputs: transfers.map(({ address, tokenId, amount }) => ({
+			type: tokenId,
+			amount,
+			receiverAddress: ShieldedAddress.codec.decode(engine.networkId, MidnightBech32m.parse(address))
+		}))
+	} : {
+		type: "unshielded",
+		outputs: transfers.map(({ address, tokenId, amount }) => ({
+			type: tokenId,
+			amount,
+			receiverAddress: UnshieldedAddress.codec.decode(engine.networkId, MidnightBech32m.parse(address))
+		}))
+	};
+	const resolvedTtl = ttl ?? new Date(Date.now() + 36e5);
+	return engine.transferTransaction([desiredOutputs], {
+		ttl: resolvedTtl,
+		payFees: false
+	}).pipe(switchMap((recipe) => balanceMidnightRecipe(engine, recipe, resolvedTtl)));
+}));
+//#endregion
+//#region src/register-midnight-dust.ts
+/**
+* Whether the account already takes part in DUST generation: registered
+* NIGHT, generated DUST, or generation capacity (the contract's
+* `getDesignationTargetType` plus capacity). The engine does not report where
+* registered NIGHT generates, so this covers a designation to the account's
+* own address and to an external one alike.
+*/
+const isDesignatedForDust = (state, nightCoins) => getDesignationTargetType(nightCoins.map(({ utxo, meta }) => ({
+	status: "available",
+	value: BigNumber(utxo.value),
+	registeredForDustGeneration: meta.registeredForDustGeneration
+})), state.dust.totalCoins.reduce((sum, coin) => sum + coin.generatedNow, 0n)) !== "none" || state.dust.totalCoins.some((coin) => coin.maxCap > 0n);
+/** Internal unsigned selection shared with fee estimation. */
+const prepareMidnightDustRegistration = (midnightWallet, { dustAddress: destination, ttl }) => combineLatest([midnightWallet.state().pipe(take(1)), midnightWallet.address$.pipe(take(1))]).pipe(map(([state, address]) => {
+	if (ttl !== void 0) throw new Error("A DUST registration does not accept ttl: the engine sets its validity window");
+	const nightCoins = state.unshielded.availableCoins.filter(({ utxo }) => utxo.type === NIGHT_TOKEN_ID);
+	if (nightCoins.length === 0 || nightCoins.every(({ utxo }) => utxo.value <= 0n)) throw new MidnightNothingToRegisterError(midnightWallet.accountId);
+	const dustAddress = DustAddress.codec.decode(midnightWallet.networkId, MidnightBech32m.parse(destination ?? address.dust));
+	if (destination !== void 0 && isDesignatedForDust(state, nightCoins)) throw new Error("DUST destination cannot be changed while the account is designated for DUST generation");
+	return {
+		state,
+		nightCoins,
+		dustAddress,
+		destination: destination ?? address.dust,
+		isRepeatRegistration: nightCoins.some((coin) => coin.meta.registeredForDustGeneration)
+	};
+}));
+/**
+* Registers every available NIGHT UTXO. Obtain consumer consent before
+* calling: registration signs internally.
+*
+* - An explicit `dustAddress` is refused while the account is designated for
+*   DUST generation (registered NIGHT, generated DUST or generation capacity),
+*   so it never redirects an existing designation.
+* - Without `dustAddress` the NIGHT is registered to the account's own DUST
+*   address, whatever it is registered to now. NIGHT registered to an external
+*   address is therefore re-registered to the account's own address. When some
+*   NIGHT is already registered, the registration is balanced with DUST.
+*
+* The returned recipe reserves the NIGHT it registers (see `MidnightTxRecipe`).
+* When the registration cannot be built, the NIGHT it reserved is released
+* and the build error is returned; if that release fails too, the error is an
+* `AggregateError` of both failures, and the NIGHT stays reserved until a
+* sync reset. The wallet library does not release it when the fee query of a
+* first registration fails; it then also stays reserved until a sync reset.
+*/
+const registerMidnightDust = async (wallet, { ttl, dustAddress: destination, ...account } = {}) => withMidnightWallet(wallet, account, (midnightWallet) => prepareMidnightDustRegistration(midnightWallet, {
+	dustAddress: destination,
+	ttl
+}).pipe(switchMap(({ nightCoins, dustAddress, isRepeatRegistration }) => {
+	const registration$ = midnightWallet.registerNightUtxosForDustGeneration(nightCoins, dustAddress);
+	if (!isRepeatRegistration) return registration$;
+	return registration$.pipe(switchMap((registration) => balanceMidnightRecipe(midnightWallet, registration, new Date(Date.now() + defaultTxTtlLength))));
+})));
+//#endregion
+//#region src/estimate-midnight-fee.ts
+/**
+* Estimates DUST from unsigned preparation, without registering or signing.
+* A first registration with no spendable DUST estimates zero; a repeat
+* registration is estimated like the DUST balancing it performs.
+* Estimates depend on current state/time and are not guaranteed final charges.
+* Insufficient spendable DUST returns an error.
+*/
+const estimateMidnightFee = async (wallet, request) => {
+	return withMidnightWallet(wallet, request.kind === "transfer" ? request.transfer : request.registration, (engine) => defer(() => {
+		return combineLatest([request.kind === "transfer" ? engine.state().pipe(take(1), map((state) => {
+			const { kind, outputs, ttl } = request.transfer;
+			const transfers = normalizeMidnightTransfers(engine.networkId, kind, outputs);
+			return {
+				state,
+				tx: (kind === "shielded" ? constructShieldedTransaction : constructUnshieldedTransaction)({
+					networkId: engine.networkId,
+					transfers,
+					ttl
+				}),
+				isFirstDesignation: false
+			};
+		})) : prepareMidnightDustRegistration(engine, request.registration).pipe(map(({ state, nightCoins, destination, isRepeatRegistration }) => ({
+			state,
+			tx: constructDustDesignationTransaction({
+				networkId: engine.networkId,
+				address: destination,
+				nightUtxos: nightCoins,
+				nightVerifyingKey: engine.nightVerifyingKey,
+				allowFeePayment: isRepeatRegistration ? 0n : void 0
+			}),
+			isFirstDesignation: !isRepeatRegistration
+		}))), engine.areKeysAvailable$.pipe(take(1))]).pipe(switchMap(([{ state, tx, isFirstDesignation }, areKeysAvailable]) => {
+			const availableDust = state.dust.balance(/* @__PURE__ */ new Date());
+			return estimatePreparedMidnightFee(engine, tx, {
+				isDustDesignation: isFirstDesignation,
+				dustBalance: availableDust,
+				areKeysAvailable
+			}).pipe(map((dustFee) => {
+				if (dustFee > availableDust) throw new Error("Insufficient spendable DUST");
+				return {
+					dustFee,
+					availableDust
+				};
+			}));
+		}));
+	}));
+};
+//#endregion
+//#region ../../packages/lib/vendor/src/midnight-sign-data.ts
+init__polyfill_buffer_patch();
+/** Decode the connector transport form, preserving Buffer's permissive hex/base64 handling. */
+const decodeMidnightSignData = (data, encoding) => {
+	switch (encoding) {
+		case "hex": return new Uint8Array(import_buffer.Buffer.from(data, "hex"));
+		case "base64": return new Uint8Array(import_buffer.Buffer.from(data, "base64"));
+		case "text": return new TextEncoder().encode(data);
+		default: throw new Error(`Unsupported encoding: ${String(encoding)}`);
+	}
+};
+const SIGNED_MESSAGE_PREFIX = "midnight_signed_message:";
+/**
+* Prefixes decoded payload bytes with UTF-8 `midnight_signed_message:<byteLength>:`.
+* The length excludes the prefix; sign and verify these bytes, not the transport encoding.
+*/
+const applyMidnightSignedMessagePrefix = (data) => {
+	const header = new TextEncoder().encode(`${SIGNED_MESSAGE_PREFIX}${data.length}:`);
+	const prefixed = new Uint8Array(header.length + data.length);
+	prefixed.set(header, 0);
+	prefixed.set(data, header.length);
+	return prefixed;
+};
+//#endregion
+//#region src/sign-midnight-data.ts
+/**
+* Signs a connector-compatible message with the selected account's unshielded
+* NIGHT key. Obtain consumer consent for this payload and account before calling;
+* this helper shows no prompt and the module's password unlocks the key.
+*
+* Decodes hex/base64 with Buffer (including permissive malformed input), or text
+* as UTF-8, then prefixes `midnight_signed_message:<byteLength>:`. Empty payloads
+* still receive the prefix. Only the `unshielded` key type is supported.
+* Returns the original payload, signature and verifying key. Account resolution,
+* unsupported options and signing failures settle as `Err<Error>`.
+*/
+const signMidnightData = async (wallet, { data, options, ...account }) => withMidnightWallet(wallet, account, (midnightWallet) => defer(() => {
+	if (options.keyType !== "unshielded") throw new Error(`Unsupported key type: ${String(options.keyType)}`);
+	const bytes = applyMidnightSignedMessagePrefix(decodeMidnightSignData(data, options.encoding));
+	return midnightWallet.signData(bytes).pipe(map(({ signature, verifyingKey }) => ({
+		data,
+		signature,
+		verifyingKey
+	})));
+}));
+//#endregion
+//#region src/discard-midnight-tx.ts
+/**
+* Releases the coins a built recipe holds, so they return to the account's
+* available balance and a later build can select them.
+*
+* Discard only a recipe that never reached proving: consent declined,
+* `signMidnightTx` failed, or `proveMidnightTx` returned
+* `MidnightAccountNotFoundError`, `MidnightWalletNotReadyError` or a
+* `RangeError` for its `proveTimeout`, which are raised before proving. Do
+* not discard after any other `proveMidnightTx`
+* error, including a timeout, nor after it returned a transaction: the engine
+* releases a recipe whose proving fails, and releases a proved transaction
+* that never reaches the chain once its validity window (`ttl`) has passed.
+* Pass the `accountId` the recipe was built with: under another account the
+* release finds no reserved coins and still reports `Ok`. The release works
+* per coin, not per transaction, so discarding a recipe the engine has
+* already released, or one built before a sync reset cleared its
+* reservation, can free coins that a later build reserved
+* for a transaction still in flight. For the same reason, never discard a
+* recipe whose transaction was passed to `submitMidnightTx`.
+*/
+const discardMidnightTx = async (wallet, { recipe, ...account }) => withMidnightWallet(wallet, account, (midnightWallet) => defer(() => midnightWallet.revert(recipe)));
+//#endregion
+//#region src/sign-midnight-tx.ts
+/**
+* Signs the recipe's unshielded inputs with the account's NIGHT key. The
+* module's password unlocks the key; no prompt is shown. Obtain consumer consent
+* for the exact transaction and account before invoking this helper.
+*/
+const signMidnightTx = async (wallet, { recipe, ...account }) => withMidnightWallet(wallet, account, (midnightWallet) => defer(() => midnightWallet.signRecipe(recipe)));
+//#endregion
+//#region src/prove-midnight-tx.ts
+/** How long every proving helper waits for the proof server unless told otherwise. */
+const DEFAULT_PROVE_TIMEOUT_MS = 10 * 6e4;
+/** Applies the default `proveTimeout` and refuses a value no timer can honour. */
+const resolveProveTimeout = (proveTimeout) => resolveTimeoutMs("proveTimeout", proveTimeout, DEFAULT_PROVE_TIMEOUT_MS);
+/**
+* Proves the recipe through the proof server the module was configured
+* with. Timeout stops observation; it does not cancel underlying proving.
+*/
+const proveMidnightTx = async (wallet, { recipe, onProgress, proveTimeout, ...account }) => withMidnightWallet(wallet, account, (midnightWallet) => {
+	const limit = resolveProveTimeout(proveTimeout);
+	let observer = onProgress;
+	return defer(() => onProgress ? midnightWallet.finalizeRecipe(recipe, (event) => observer?.(event)) : midnightWallet.finalizeRecipe(recipe)).pipe(timeout(limit), finalize(() => {
+		observer = void 0;
+	}));
+});
+//#endregion
+//#region ../../packages/module/dapp-connector-midnight/src/store/helpers/derive-pending-activity-from-midnight-tx.ts
+const utxoKey = (intentHash, outputNo) => `${intentHash}#${outputNo}`;
+const processOffer = (offer, ownUtxoIndex, ownUserAddressHex) => {
+	if (!offer) return {
+		nightDelta: 0n,
+		isInvolved: false
+	};
+	let nightDelta = 0n;
+	let isInvolved = false;
+	for (const input of offer.inputs) {
+		const own = ownUtxoIndex.get(utxoKey(input.intentHash, input.outputNo));
+		if (!own) continue;
+		isInvolved = true;
+		if (own.utxo.type === "0000000000000000000000000000000000000000000000000000000000000000") nightDelta -= own.utxo.value;
+	}
+	for (const output of offer.outputs) {
+		if (output.owner !== ownUserAddressHex) continue;
+		isInvolved = true;
+		if (output.type === "0000000000000000000000000000000000000000000000000000000000000000") nightDelta += output.value;
+	}
+	return {
+		nightDelta,
+		isInvolved
+	};
+};
+const buildOwnUtxoIndex = (nightUtxos) => {
+	const index = /* @__PURE__ */ new Map();
+	for (const entry of nightUtxos) index.set(utxoKey(entry.utxo.intentHash, entry.utxo.outputNo), entry);
+	return index;
+};
+const derivePendingActivityFromMidnightTx = ({ deserializedTx, accountId, ownUserAddressHex, nightUtxos, networkId }) => {
+	const ownUtxoIndex = buildOwnUtxoIndex(nightUtxos);
+	let nightAmount = 0n;
+	let isAccountInvolved = false;
+	for (const intent of deserializedTx.intents?.values() ?? []) for (const offer of [intent.guaranteedUnshieldedOffer, intent.fallibleUnshieldedOffer]) {
+		const { nightDelta, isInvolved } = processOffer(offer, ownUtxoIndex, ownUserAddressHex);
+		nightAmount += nightDelta;
+		isAccountInvolved = isAccountInvolved || isInvolved;
+	}
+	if (!isAccountInvolved) return void 0;
+	const tokenBalanceChanges = nightAmount === 0n ? [] : [{
+		tokenId: TokenId(toUnshieldedTokenType(NIGHT_TOKEN_ID, networkId)),
+		amount: BigNumber(nightAmount)
+	}];
+	return {
+		accountId,
+		activityId: deserializedTx.transactionHash(),
+		timestamp: Timestamp(Date.now()),
+		tokenBalanceChanges,
+		type: ActivityType.Pending
+	};
+};
+//#endregion
+//#region src/submit-midnight-tx.ts
+const DEFAULT_SUBMIT_TIMEOUT_MS = 5 * 6e4;
+const PENDING_ROW_STATE_TIMEOUT_MS = 1e4;
+/** Records the Pending activity unless the account already has a confirmed row for the transaction. */
+const recordPendingActivity = ({ dispatch, activities, midnightWallet, transaction, utxos }) => {
+	try {
+		const activity = derivePendingActivityFromMidnightTx({
+			deserializedTx: transaction,
+			accountId: midnightWallet.accountId,
+			ownUserAddressHex: addressFromKey(midnightWallet.nightVerifyingKey),
+			nightUtxos: utxos,
+			networkId: midnightWallet.networkId
+		});
+		if (!activity) return void 0;
+		const current = activities[activity.accountId]?.find((row) => row.activityId === activity.activityId);
+		if (current && current.type !== ActivityType.Pending) return void 0;
+		dispatch("activities.upsertActivities", {
+			accountId: activity.accountId,
+			activities: [activity]
+		});
+		return activity;
+	} catch {
+		return;
+	}
+};
+/**
+* Submits a proved transaction after consumer authorization and resolves once the node reports it final: the
+* engine submits at its `Finalized` stage, so `Ok` means the transaction is on chain. `txId` is the engine's
+* identifier, which is not the activity hash; the activity hash is `transaction.transactionHash()`.
+*
+* On an instance that tracks activities, the transaction's Pending activity, keyed by the activity hash, is
+* recorded when the submission is handed to the engine, before finality; the history sync then replaces it with
+* the confirmed row. The engine reports no acceptance before finality, so the row is written as soon as the call
+* is issued. When the engine fails the submission it releases the transaction's coins and the Pending row is
+* removed; if the transaction reaches the chain anyway, the history sync records it. Tracking failures never fail
+* a submission.
+*
+* An `Err` does not prove that nothing was broadcast. {@link MidnightSubmitTimeoutError} (`code`
+* `midnight-submit-timeout`) means the node did not report finality within `submitTimeout`: the transaction may
+* still reach the chain, and its Pending row stays. The SDK keeps listening to the engine's submission after the
+* timeout, for as long as that submission runs in this process: a failure it reports later removes the row, a
+* confirmation reaches the history sync. A row whose outcome this process never learns (it ends first) stays
+* until the history sync confirms it or the consumer removes it. The account-resolution errors
+* (`MidnightAccountNotFoundError`, `MidnightWalletNotReadyError`) precede the call and so precede any broadcast;
+* any other error is the engine's, and may also arrive after broadcast. Before retrying, check the account's
+* activities for the activity hash.
+*/
+const submitMidnightTx = async (wallet, { transaction, submitTimeout: requestedSubmitTimeout, ...account }) => withMidnightWallet(wallet, account, (midnightWallet) => defer(() => {
+	const submitTimeout = resolveTimeoutMs("submitTimeout", requestedSubmitTimeout, DEFAULT_SUBMIT_TIMEOUT_MS);
+	const { dispatch } = wallet;
+	const activities$ = dispatch ? wallet.stateObservables.activities?.selectAllMap$ : void 0;
+	const latestActivities$ = activities$ ? activities$.pipe(startWith(void 0), catchError(() => of(void 0))) : of(void 0);
+	const utxos$ = activities$ ? defer(() => midnightWallet.state()).pipe(take(1), map((state) => [...state.unshielded.availableCoins, ...state.unshielded.pendingCoins]), defaultIfEmpty(void 0), catchError(() => of(void 0))) : of(void 0);
+	const removePendingRow = (pending) => {
+		if (!dispatch || !activities$) return;
+		activities$.pipe(take(1), catchError(() => of(void 0))).subscribe((latest) => {
+			if ((latest?.[pending.accountId]?.find((row) => row.activityId === pending.activityId))?.type !== ActivityType.Pending) return;
+			try {
+				dispatch("activities.removeActivities", {
+					accountId: pending.accountId,
+					activityIds: [pending.activityId]
+				});
+			} catch {}
+		});
+	};
+	const settle = (finality$, pending) => {
+		const outcome$ = finality$.pipe(share({
+			connector: () => new ReplaySubject(1),
+			resetOnError: false,
+			resetOnComplete: false
+		}));
+		if (pending) outcome$.subscribe({
+			next: () => void 0,
+			error: () => {
+				removePendingRow(pending);
+			}
+		});
+		return outcome$.pipe(timeout({
+			first: submitTimeout,
+			with: () => throwError(() => new MidnightSubmitTimeoutError(transaction.transactionHash(), submitTimeout))
+		}), map((txId) => ({ txId })));
+	};
+	return utxos$.pipe(timeout({
+		first: Math.min(PENDING_ROW_STATE_TIMEOUT_MS, submitTimeout),
+		with: () => of(void 0)
+	}), switchMap((utxos) => {
+		const finality$ = midnightWallet.submitTransaction(transaction);
+		return of(utxos).pipe(withLatestFrom(latestActivities$), map(([coins, activities]) => dispatch && activities && coins ? recordPendingActivity({
+			dispatch,
+			activities,
+			midnightWallet,
+			transaction,
+			utxos: coins
+		}) : void 0), switchMap((pending) => settle(finality$, pending)));
+	}));
+}));
+//#endregion
+//#region src/modules-midnight.ts
+var modules_midnight_exports = /* @__PURE__ */ __exportAll({
+	featureDev: () => sdk_default,
+	storageInMemory: () => sdk_default$1,
+	storageWebIndexeddb: () => sdk_default$2
+});
+//#endregion
+//#region src/midnight-proving-provider.ts
+const withinTimeout = async (operation, milliseconds) => firstValueFrom(from(operation).pipe(timeout(milliseconds)));
+/**
+* Captures one account identity and resolves its current engine on every use.
+* No proof-server URL or wallet keys are exposed. Factory failures are `Err`;
+* `check`/`prove` reject on transport or attestation failure without fallback,
+* and on timeout.
+* The consumer must authorize disclosure of the circuit preimage to the configured prover.
+*/
+const getMidnightProvingProvider = async (wallet, { keyMaterialProvider, proveTimeout: requestedProveTimeout, ...selection }) => {
+	try {
+		const proveTimeout = resolveProveTimeout(requestedProveTimeout);
+		const accountId = await resolveMidnightAccountId(wallet, selection.accountId);
+		const account = {
+			...selection,
+			accountId
+		};
+		await midnightWalletFor(wallet, account);
+		const provider = createProvingProviderFromCircuits({
+			check: async (payload) => (await midnightWalletFor(wallet, account)).proofCircuitProvider.check(payload),
+			prove: async (payload) => (await midnightWalletFor(wallet, account)).proofCircuitProvider.prove(payload)
+		}, keyMaterialProvider, { onKeyMaterialError: "propagate" });
+		return Ok({
+			check: async (serializedPreimage, keyLocation) => withinTimeout(provider.check(serializedPreimage, keyLocation), proveTimeout),
+			prove: async (serializedPreimage, keyLocation, overwriteBindingInput) => withinTimeout(provider.prove(serializedPreimage, keyLocation, overwriteBindingInput), proveTimeout)
+		});
+	} catch (error) {
+		return Err(error instanceof Error ? error : new Error(String(error)));
+	}
+};
+//#endregion
+//#region ../../packages/lib/vendor/src/midnight-connector-transaction.ts
+init__polyfill_buffer_patch();
+/** Deserialize a hex-encoded, proven and bound connector transaction. */
+const deserializeMidnightSealedTransaction = async (tx) => ledger.Transaction.deserialize("signature", "proof", "binding", import_buffer.Buffer.from(tx, "hex"));
+/** Deserialize a hex-encoded, proven connector transaction that is not yet bound. */
+const deserializeMidnightUnsealedTransaction = async (tx) => ledger.Transaction.deserialize("signature", "proof", "pre-binding", import_buffer.Buffer.from(tx, "hex"));
+/**
+* Groups connector outputs into the wallet SDK's transfer shape, unshielded
+* first; a kind without outputs is omitted. Throws when a recipient is not a
+* Bech32m address of its kind on `networkId`.
+*/
+const groupMidnightConnectorOutputs = (desiredOutputs, networkId) => {
+	const unshielded = [];
+	const shielded = [];
+	for (const { kind, type, recipient, value } of desiredOutputs) {
+		const parsedAddress = MidnightBech32m.parse(recipient);
+		if (kind === "unshielded") unshielded.push({
+			type,
+			receiverAddress: UnshieldedAddress.codec.decode(networkId, parsedAddress),
+			amount: value
+		});
+		if (kind === "shielded") shielded.push({
+			type,
+			receiverAddress: ShieldedAddress.codec.decode(networkId, parsedAddress),
+			amount: value
+		});
+	}
+	const result = [];
+	if (unshielded.length) result.push({
+		type: "unshielded",
+		outputs: unshielded
+	});
+	if (shielded.length) result.push({
+		type: "shielded",
+		outputs: shielded
+	});
+	return result;
+};
+/** Sums connector inputs per kind and token type into the wallet SDK's swap shape. */
+const groupMidnightConnectorInputs = (desiredInputs) => desiredInputs.reduce((inputs, { kind, type, value }) => {
+	if (kind === "shielded" || kind === "unshielded") {
+		const tokens = inputs[kind] ?? {};
+		tokens[type] = (tokens[type] ?? 0n) + value;
+		inputs[kind] = tokens;
+	}
+	return inputs;
+}, {});
+//#endregion
+//#region src/midnight-connector-transactions.ts
+const validateOptions = (options) => {
+	if (options !== void 0 && (!options || typeof options !== "object" || Array.isArray(options) || options.payFees !== void 0 && typeof options.payFees !== "boolean")) throw new Error("Invalid Midnight fee options");
+};
+const validateTokens = (tokens) => {
+	if (!Array.isArray(tokens)) throw new Error("Expected Midnight token array");
+	for (const token of tokens) {
+		if (!token || token.kind !== "shielded" && token.kind !== "unshielded") throw new Error("Unsupported Midnight token kind");
+		if (typeof token.type !== "string" || !/^[\da-f]{64}$/i.test(token.type)) throw new Error("Expected a raw Midnight ledger token type");
+		if (typeof token.value !== "bigint" || token.value < 0n) throw new Error("Expected a non-negative Midnight token value");
+	}
+};
+const validateBalance = ({ tx, options }) => {
+	validateOptions(options);
+	if (typeof tx !== "string" || !/^(?:[\da-f]{2})+$/i.test(tx)) throw new Error("Expected a hexadecimal Midnight transaction");
+};
+const reservedBy = (recipe) => recipe.type === "UNPROVEN_TRANSACTION" ? recipe : recipe.balancingTransaction && {
+	type: "UNPROVEN_TRANSACTION",
+	transaction: recipe.balancingTransaction
+};
+const finalize$1 = async (wallet, recipe, { sign, proveTimeout }) => {
+	const reserved = reservedBy(recipe);
+	const prepared = sign ? await firstValueFrom(wallet.signRecipe(recipe).pipe(catchError((signingError) => reserved ? releaseThenThrow(wallet, reserved, signingError) : throwError(() => signingError)))) : recipe;
+	return firstValueFrom(wallet.finalizeRecipe(prepared).pipe(timeout(proveTimeout)));
+};
+/**
+* Balances, signs and proves a binding transaction; never submits it.
+* Obtain consumer consent for the transaction, account and prover disclosure before calling.
+*/
+const balanceMidnightSealedTransaction = async (wallet, props) => withMidnightWallet(wallet, props, (engine) => defer(async () => {
+	const proveTimeout = resolveProveTimeout(props.proveTimeout);
+	validateBalance(props);
+	const transaction = await deserializeMidnightSealedTransaction(props.tx);
+	return finalize$1(engine, await firstValueFrom(engine.balanceFinalizedTransaction(transaction, {
+		ttl: new Date(Date.now() + defaultTxTtlLength),
+		tokenKindsToBalance: props.options?.payFees === false ? ["shielded", "unshielded"] : void 0
+	})), {
+		sign: true,
+		proveTimeout
+	});
+}));
+/**
+* Balances, signs and proves a pre-binding transaction; never submits it.
+* Obtain consumer consent for the transaction, account and prover disclosure before calling.
+*/
+const balanceMidnightUnsealedTransaction = async (wallet, props) => withMidnightWallet(wallet, props, (engine) => defer(async () => {
+	const proveTimeout = resolveProveTimeout(props.proveTimeout);
+	validateBalance(props);
+	const transaction = await deserializeMidnightUnsealedTransaction(props.tx);
+	return finalize$1(engine, await firstValueFrom(engine.balanceUnboundTransaction(transaction, {
+		ttl: new Date(Date.now() + defaultTxTtlLength),
+		tokenKindsToBalance: props.options?.payFees === false ? ["shielded", "unshielded"] : void 0
+	})), {
+		sign: true,
+		proveTimeout
+	});
+}));
+/**
+* Builds and proves connector transfers, including mixed token kinds; signs when unshielded outputs exist.
+* Obtain consumer consent before calling. Returns a native finalized transaction without submitting.
+* Fees default to enabled; use `buildMidnightTransfers` for separate homogeneous build/sign/prove stages.
+*/
+const makeMidnightTransfer = async (wallet, props) => withMidnightWallet(wallet, props, (engine) => defer(async () => {
+	const proveTimeout = resolveProveTimeout(props.proveTimeout);
+	validateOptions(props.options);
+	validateTokens(props.desiredOutputs);
+	const outputs = groupMidnightConnectorOutputs(props.desiredOutputs, engine.networkId);
+	const ttl = new Date(Date.now() + defaultTxTtlLength);
+	return finalize$1(engine, await firstValueFrom(engine.transferTransaction(outputs, {
+		ttl,
+		payFees: false
+	}).pipe(switchMap((built) => props.options?.payFees ?? true ? balanceMidnightRecipe(engine, built, ttl) : of(built)))), {
+		sign: outputs.some((output) => output.type === "unshielded"),
+		proveTimeout
+	});
+}));
+const assertOutputKindsHaveInputs = (inputs, outputs) => {
+	const missing = outputs.map((output) => output.type).filter((kind) => inputs[kind] === void 0);
+	if (missing.length > 0) throw new Error(`Midnight intent requests ${missing.join(" and ")} outputs without inputs of that kind, which the wallet library would drop`);
+};
+/**
+* Builds and proves an intent, signing when inputs or outputs include unshielded tokens.
+* Obtain consumer consent before calling. Never submits. `intentId` is accepted but ignored,
+* matching the existing connector; no intent ordering is guaranteed. Every output kind
+* needs an input of the same kind: the wallet library builds a leg from its inputs and
+* drops the outputs of a kind without any, so such a request is refused before anything
+* is reserved or signed. When the fee cannot be paid, the inputs the build reserved are
+* released and the balancing error is returned; if that release fails too, the error is
+* an `AggregateError` of both failures and the coins stay reserved until a sync reset.
+*/
+const makeMidnightIntent = async (wallet, props) => withMidnightWallet(wallet, props, (engine) => defer(async () => {
+	const proveTimeout = resolveProveTimeout(props.proveTimeout);
+	validateOptions(props.options);
+	if (!props.options || typeof props.options.payFees !== "boolean" || props.options.intentId !== "random" && typeof props.options.intentId !== "number") throw new Error("Invalid Midnight intent options");
+	validateTokens(props.desiredInputs);
+	validateTokens(props.desiredOutputs);
+	const inputs = groupMidnightConnectorInputs(props.desiredInputs);
+	const outputs = groupMidnightConnectorOutputs(props.desiredOutputs, engine.networkId);
+	assertOutputKindsHaveInputs(inputs, outputs);
+	const ttl = new Date(Date.now() + defaultTxTtlLength);
+	return finalize$1(engine, await firstValueFrom(engine.initSwap(inputs, outputs, {
+		ttl,
+		payFees: false
+	}).pipe(switchMap((built) => props.options.payFees ? balanceMidnightRecipe(engine, built, ttl) : of(built)))), {
+		sign: !!inputs.unshielded || outputs.some((output) => output.type === "unshielded"),
+		proveTimeout
+	});
+}));
+//#endregion
+export { AccountId, Err, FEATURE_FLAG_MIDNIGHT, FEATURE_FLAG_MIDNIGHT_UNSHIELDED, FEATURE_FLAG_NETWORK_TYPE, MIDNIGHT_LOCAL_PROOF_SERVER_URL, MIDNIGHT_PREVIEW_INDEXER_URL, MIDNIGHT_PREVIEW_NODE_URL, MIDNIGHT_PUBLIC_ENDPOINTS, MidnightAccountId, MidnightAccountNotFoundError, MidnightNetworkId, MidnightNetworkNotConfiguredError, MidnightNothingToRegisterError, MidnightSDKNetworkIds, MidnightSubmitTimeoutError, MidnightWalletNotReadyError, NIGHT_TOKEN_ID, Ok, WalletId, WalletType, balanceMidnightSealedTransaction, balanceMidnightUnsealedTransaction, buildMidnightTransfer, buildMidnightTransfers, createInMemoryWalletEntity, createLaceWallet, createMidnightAccounts, createMidnightModule, createMidnightPasskeyWalletEntity, createPasskeyKeySource, createTemenosAttestedProver, discardMidnightTx, estimateMidnightFee, getMidnightProvingProvider, isForbiddenTokenName, isTakenTokenName, isTokenFullNameValid, isTokenShortNameValid, modules_midnight_exports as m, makeMidnightIntent, makeMidnightTransfer, observeMidnightBalances, proveMidnightTx, registerMidnightDust, selectMidnightNetwork, signMidnightData, signMidnightTx, submitMidnightTx };