@laceio/sdk 0.1.1-canary.2 → 0.1.1

package/dist/midnight.js

@@ -1,1350 +0,0 @@
-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-D1e0skzp.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-DIcjlgLF.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-BfEnY8fg.js";
-import { t as MidnightAccountId } from "./midnight-account-id.vo-DjCAGcqc.js";
-import { i as midnightContextSelectors, n as midnightContextActions } from "./slice-BnTJeMOb.js";
-import { c as toUnshieldedTokenType, i as fromUnshieldedTokenType, s as isInMemoryMidnightAccount } from "./utils-CvAW5Yw7.js";
-import { a as AttestationError, d as FEATURE_FLAG_MIDNIGHT, l as createProvingProviderFromTransport, p as FEATURE_FLAG_MIDNIGHT_UNSHIELDED, t as midnightDustBalances } from "./watch-Z53L4yoK.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-KQnIdm39.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) => {
-			const config = {
-				...deployment,
-				amdRootCertificates,
-				indexerUrl: await getLedgerIndexerUrl()
-			};
-			const operationVerifier = verifier.createVerifier(config);
-			let currentPhase = "obtain-evidence";
-			try {
-				return createTunneledSession(await operationVerifier.establishVerifiedSession((event) => {
-					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-DNd-oQXp.js");
-			return { default: createSdkStoreInit(options) };
-		},
-		context: {
-			actions: midnightSyncActions,
-			selectors: {}
-		}
-	}),
-	addons: {
-		loadSignerFactory: async () => import("./signer-factory-Cd2TwD50.js"),
-		loadMidnightEngine: async () => import("./midnight-engine-DpemplKO.js"),
-		loadInMemoryWalletIntegration: async () => import("./in-memory-wallet-integration-CUKesGG1.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 = createProvingProviderFromTransport({
-			check: async (payload) => (await midnightWalletFor(wallet, account)).proofServerTransport.check(payload),
-			prove: async (payload) => (await midnightWalletFor(wallet, account)).proofServerTransport.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 };