@fased/fased 0.1.61 → 0.1.64

package/dist/wallet/solana-swap.js

@@ -1,10 +1,76 @@
-import { fetchSolanaNativeBalanceViaRpc, fetchSolanaWalletAssetsViaRpc } from "./solana-assets.js";
-import { applyWalletPolicyConfig, enforceWalletDailyCap, validateWalletTxPolicy } from "./wallet-policy.js";
+import { SOLANA_ASSET_CONSTANTS, fetchSolanaMintInfoViaRpc, fetchSolanaNativeBalanceViaRpc, fetchSolanaWalletAssetsViaRpc } from "./solana-assets.js";
+import { applyWalletPolicyConfig, validateWalletTxPolicy } from "./wallet-policy.js";
+import { deriveAssociatedTokenAddress } from "./solana-spl-transfer.js";
 import { createWalletProviderAdapter, resolveScopedRpcUrlForWallet } from "./wallet-provider-resolver.js";
+import { beginExternalSubmission, claimExternalSubmissionExecution, createExternalSubmissionKey, updateExternalSubmission } from "./external-submission-ledger.js";
 import { inspectSerializedSolanaSwapTransaction } from "./solana-transaction-inspection.js";
+import { createHash } from "node:crypto";
 
 //#region src/wallet/solana-swap.ts
 const SOLANA_NATIVE_MINT = "So11111111111111111111111111111111111111112";
+const DEFAULT_JUPITER_MAX_FEE_LAMPORTS = "5000000";
+function storedSwapOrder(entry) {
+	const value = entry.details?.order;
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return undefined;
+	}
+	const order = value;
+	if (order.ok !== true || typeof order.inputMint !== "string" || typeof order.outputMint !== "string" || typeof order.inAmount !== "string" || !order.raw || typeof order.raw !== "object" || Array.isArray(order.raw)) {
+		return undefined;
+	}
+	return order;
+}
+function storedSignerOperation(entry) {
+	const value = entry.result?.operation;
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return undefined;
+	}
+	const operation = value;
+	if (typeof operation.requestId !== "string" || typeof operation.walletId !== "string" || typeof operation.intentType !== "string" || typeof operation.intentDigest !== "string" || typeof operation.policyHash !== "string" || typeof operation.asset !== "string" || typeof operation.amount !== "string" || ![
+		"reserved",
+		"broadcast",
+		"confirmed",
+		"failed",
+		"unknown"
+	].includes(operation.state ?? "")) {
+		return undefined;
+	}
+	return operation;
+}
+function signerReviewMatchesAutonomousSwap(params) {
+	const { review } = params;
+	return review.requestId === params.requestId && review.walletId === params.walletId && review.mode === "autonomous" && review.intentType === "solana.jupiter.swap" && review.semanticIntent.type === "solana.jupiter.swap" && review.semanticIntent.jupiter.owner === params.owner && review.semanticIntent.jupiter.inputMint === params.inputMint && review.semanticIntent.jupiter.outputMint === params.outputMint && review.semanticIntent.jupiter.inputAmount === params.amount && review.semanticIntent.jupiter.maxInputAmount === params.amount && review.transaction?.submission === "rpc" && Boolean(review.transaction.serializedTxBase64);
+}
+function swapExecutionResult(params) {
+	const { operation } = params;
+	if (operation.state !== "confirmed" || !operation.signature) {
+		const ambiguous = operation.state === "reserved" || operation.state === "broadcast" || operation.state === "unknown";
+		return {
+			ok: false,
+			code: ambiguous ? "wallet_provider_ambiguous" : "wallet_swap_failed",
+			message: ambiguous ? `signer operation ${operation.requestId} is ${operation.state}; reconcile its existing signature before any new Jupiter order` : operation.error ?? `typed Jupiter swap ended in state=${operation.state}`
+		};
+	}
+	const tx = {
+		ok: true,
+		chain: "solana",
+		txHash: operation.signature,
+		signer: params.signer,
+		metadata: {
+			provider: "local-socket-signer",
+			signerProtocol: 2,
+			signerOperationState: operation.state,
+			signerIntentDigest: operation.intentDigest,
+			signerTransactionDigest: operation.transactionDigest,
+			...params.inspection ? { swapInspection: params.inspection } : {}
+		}
+	};
+	return {
+		ok: true,
+		tx,
+		order: params.order
+	};
+}
 function stringValue(value) {
 	return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
@@ -12,12 +78,13 @@ function numberValue(value) {
 	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
 function parsePositiveBaseUnits(value) {
-	if (!value?.trim()) {
+	const normalized = value?.trim();
+	if (!normalized || normalized.length > 32 || !/^\d+$/.test(normalized)) {
 		throw new Error("amount is required");
 	}
-	const parsed = BigInt(value.trim());
-	if (parsed <= 0n) {
-		throw new Error("amount must be positive base units");
+	const parsed = BigInt(normalized);
+	if (parsed <= 0n || parsed > 18446744073709551615n) {
+		throw new Error("amount must be positive uint64 base units");
 	}
 	return parsed;
 }
@@ -31,6 +98,93 @@ function normalizeSlippageBps(value) {
 	}
 	return rounded;
 }
+function resolveSolanaSwapMinimumOutput(order) {
+	if (order.otherAmountThreshold?.trim()) {
+		return parsePositiveBaseUnits(order.otherAmountThreshold).toString();
+	}
+	const quoted = parsePositiveBaseUnits(order.outAmount);
+	const slippageBps = BigInt(normalizeSlippageBps(order.slippageBps));
+	return ((quoted * (10000n - slippageBps) + 9999n) / 10000n).toString();
+}
+function resolveJupiterMaxFeeLamports(env) {
+	const value = env.FASED_WALLET_JUPITER_MAX_FEE_LAMPORTS?.trim() || DEFAULT_JUPITER_MAX_FEE_LAMPORTS;
+	const parsed = BigInt(value);
+	if (parsed <= 0n || parsed > 100000000n) {
+		throw new Error("FASED_WALLET_JUPITER_MAX_FEE_LAMPORTS must be between 1 and 100000000");
+	}
+	return parsed.toString();
+}
+function createSignerReviewId(prefix, seed) {
+	return `${prefix}:${createHash("sha256").update(seed).digest("hex")}`;
+}
+async function exactJupiterTokenAccount(params) {
+	const tokenProgramId = params.mint === SOLANA_NATIVE_MINT ? SOLANA_ASSET_CONSTANTS.tokenProgramId : (await fetchSolanaMintInfoViaRpc({
+		rpcUrl: params.rpcUrl,
+		mint: params.mint
+	}))?.tokenProgramId;
+	if (!tokenProgramId) {
+		throw new Error(`unable to resolve token program for mint ${params.mint}`);
+	}
+	return await deriveAssociatedTokenAddress({
+		owner: params.owner,
+		mint: params.mint,
+		tokenProgramId
+	});
+}
+async function buildSolanaSwapSignerIntent(params) {
+	const inAmount = parsePositiveBaseUnits(params.order.inAmount).toString();
+	const minimumOutputAmount = resolveSolanaSwapMinimumOutput(params.order);
+	const sourceTokenAccount = await exactJupiterTokenAccount({
+		rpcUrl: params.rpcUrl,
+		owner: params.owner,
+		mint: params.order.inputMint
+	});
+	const destinationTokenAccount = await exactJupiterTokenAccount({
+		rpcUrl: params.rpcUrl,
+		owner: params.owner,
+		mint: params.order.outputMint
+	});
+	return {
+		type: "solana.jupiter.swap",
+		jupiter: {
+			owner: params.owner,
+			inputMint: params.order.inputMint,
+			outputMint: params.order.outputMint,
+			inputAmount: inAmount,
+			maxInputAmount: inAmount,
+			minimumOutputAmount,
+			maxFeeLamports: resolveJupiterMaxFeeLamports(params.env ?? process.env),
+			sourceTokenAccount,
+			destinationTokenAccount,
+			programs: [...params.inspection.programIds].toSorted()
+		}
+	};
+}
+async function prepareSolanaSwapSignerReview(params) {
+	if (!params.provider.prepareJupiterReview) {
+		throw new Error("Jupiter execution requires protocol-v2 local-socket-signer review.prepare support");
+	}
+	const intent = await buildSolanaSwapSignerIntent(params);
+	if (!params.order.transaction) {
+		throw new Error("Jupiter signer review requires the exact serialized transaction");
+	}
+	const review = await params.provider.prepareJupiterReview({
+		walletId: params.walletId,
+		requestId: params.requestId ?? createSignerReviewId("jupiter-swap", params.order.requestId ?? params.order.transaction ?? JSON.stringify(params.order.raw)),
+		mode: params.mode,
+		intent,
+		transaction: {
+			serializedTxBase64: params.order.transaction,
+			programs: params.inspection.programIds,
+			writableAccounts: params.inspection.writableAccounts,
+			submission: "rpc"
+		}
+	});
+	return {
+		review,
+		intent
+	};
+}
 function resolveSwapApiBaseUrl(env = process.env) {
 	const raw = env.FASED_JUPITER_SWAP_API_BASE_URL?.trim() || env.JUPITER_SWAP_API_BASE_URL?.trim() || "https://api.jup.ag/swap/v2";
 	return raw.replace(/\/+$/, "");
@@ -59,6 +213,26 @@ function extractRouteLabel(raw) {
 function isSolanaSwapApprovalPayload(payload) {
 	return payload.actionKind === "solana_swap" && payload.chain === "solana" && Boolean(payload.inputMint?.trim()) && Boolean(payload.outputMint?.trim()) && Boolean(payload.amount?.trim()) && Boolean(payload.walletId?.trim());
 }
+function reviewedSolanaSwapOrderFromPayload(payload) {
+	const transaction = payload.serializedTxBase64?.trim();
+	if (!transaction || !isSolanaSwapApprovalPayload(payload)) {
+		return undefined;
+	}
+	return {
+		ok: true,
+		requestId: payload.jupiterRequestId,
+		transaction,
+		inputMint: payload.inputMint,
+		outputMint: payload.outputMint,
+		inAmount: payload.amount,
+		outAmount: payload.outAmount,
+		otherAmountThreshold: payload.otherAmountThreshold,
+		slippageBps: payload.slippageBps,
+		priceImpactPct: payload.priceImpactPct,
+		routeLabel: payload.routeLabel,
+		raw: {}
+	};
+}
 async function fetchJupiterSwapOrder(params) {
 	const env = params.env ?? process.env;
 	parsePositiveBaseUnits(params.amount);
@@ -84,13 +258,17 @@ async function fetchJupiterSwapOrder(params) {
 	if (errorMessage && !stringValue(body.transaction)) {
 		throw new Error(`jupiter order failed: ${errorMessage}`);
 	}
+	const inAmount = stringValue(body.inAmount) ?? params.amount.trim();
+	if (parsePositiveBaseUnits(inAmount) !== parsePositiveBaseUnits(params.amount)) {
+		throw new Error("jupiter order changed the requested exact input amount");
+	}
 	return {
 		ok: true,
 		requestId: stringValue(body.requestId),
 		transaction: stringValue(body.transaction) ?? stringValue(body.tx),
 		inputMint,
 		outputMint,
-		inAmount: stringValue(body.inAmount) ?? params.amount.trim(),
+		inAmount,
 		outAmount: stringValue(body.outAmount),
 		otherAmountThreshold: stringValue(body.otherAmountThreshold),
 		slippageBps: numberValue(body.slippageBps) ?? normalizeSlippageBps(params.slippageBps),
@@ -159,7 +337,11 @@ function validateSolanaSwapIntentPolicy(params) {
 function validateSolanaSwapRoutePolicy(params) {
 	const allowlist = new Set(params.config.policy.solana.allowPrograms.map((program) => program.trim()).filter(Boolean));
 	if (allowlist.size === 0) {
-		return { ok: true };
+		return {
+			ok: false,
+			code: "wallet_swap_program_allowlist_required",
+			message: "swap execution requires an explicit non-empty Solana program allowlist"
+		};
 	}
 	const denied = params.routeProgramIds.filter((programId) => !allowlist.has(programId));
 	if (denied.length === 0) {
@@ -256,21 +438,6 @@ async function executeSolanaSwapApprovalPayload(params) {
 			message: policy.message ?? "wallet policy rejected"
 		};
 	}
-	const daily = enforceWalletDailyCap({
-		config: effectiveConfig,
-		chain: "solana",
-		amount: params.payload.amount,
-		tokenMint: params.payload.inputMint === SOLANA_NATIVE_MINT ? undefined : params.payload.inputMint,
-		walletId: params.payload.walletId,
-		env
-	});
-	if (!daily.ok) {
-		return {
-			ok: false,
-			code: daily.code ?? "wallet_cap_daily_exceeded",
-			message: daily.message ?? "wallet daily cap exceeded"
-		};
-	}
 	const provider = createWalletProviderAdapter({
 		cfg: params.runtimeConfig,
 		wallet: params.config,
@@ -292,51 +459,340 @@ async function executeSolanaSwapApprovalPayload(params) {
 			message: "wallet has no Solana address"
 		};
 	}
-	const balance = await validateSolanaSwapInputBalance({
-		rpcUrl,
-		ownerAddress: taker,
-		inputMint: params.payload.inputMint,
-		amount: params.payload.amount
-	});
-	if (!balance.ok) {
-		return balance;
+	if (!rpcUrl?.trim()) {
+		return {
+			ok: false,
+			code: "wallet_swap_rpc_required",
+			message: "Solana RPC is required for signer-owned Jupiter validation"
+		};
 	}
-	const order = await fetchJupiterSwapOrder({
-		inputMint: params.payload.inputMint,
-		outputMint: params.payload.outputMint,
-		amount: params.payload.amount,
-		slippageBps: params.payload.slippageBps,
-		taker,
-		env
-	});
-	const inspection = await inspectAndValidateSolanaSwapOrder({
-		order,
-		expectedSigner: taker,
-		rpcUrl,
-		config: effectiveConfig
-	});
-	if (!inspection.ok) {
-		return inspection;
+	if (!provider.executeJupiterReview) {
+		return {
+			ok: false,
+			code: "wallet_signer_v2_required",
+			message: "Jupiter execution requires protocol-v2 local-socket-signer review.execute support"
+		};
 	}
-	const tx = await provider.sendTx({
-		chain: "solana",
+	const autonomousIdentity = params.autonomous ? createExternalSubmissionKey({
+		kind: "jupiter-swap",
 		walletId: params.payload.walletId,
-		serializedTxBase64: order.transaction,
-		amount: params.payload.amount,
-		tokenMint: params.payload.inputMint === SOLANA_NATIVE_MINT ? undefined : params.payload.inputMint
-	});
-	return {
-		ok: true,
-		tx: {
-			...tx,
-			metadata: {
-				...tx.metadata,
-				swapInspection: inspection
+		explicitIntentId: params.payload.executionIntentId,
+		intent: {
+			owner: taker,
+			inputMint: params.payload.inputMint,
+			outputMint: params.payload.outputMint,
+			amount: params.payload.amount,
+			slippageBps: normalizeSlippageBps(params.payload.slippageBps),
+			apiBaseUrl: resolveSwapApiBaseUrl(env),
+			rpcUrlDigest: `sha256:${createHash("sha256").update(rpcUrl).digest("hex")}`
+		}
+	}) : undefined;
+	let entry = autonomousIdentity ? (await beginExternalSubmission({
+		...autonomousIdentity,
+		kind: "jupiter-swap",
+		walletId: params.payload.walletId,
+		details: { semanticIntent: {
+			owner: taker,
+			inputMint: params.payload.inputMint,
+			outputMint: params.payload.outputMint,
+			amount: params.payload.amount,
+			slippageBps: normalizeSlippageBps(params.payload.slippageBps)
+		} },
+		env
+	})).entry : undefined;
+	const releaseExecution = autonomousIdentity ? await claimExternalSubmissionExecution(autonomousIdentity.key, env) : undefined;
+	try {
+		let order = entry ? storedSwapOrder(entry) : undefined;
+		if (entry?.state === "confirmed") {
+			const operation = storedSignerOperation(entry);
+			if (!operation || !order) {
+				return {
+					ok: false,
+					code: "wallet_provider_ambiguous",
+					message: "confirmed swap ledger entry is incomplete; refusing to create another order"
+				};
 			}
-		},
-		order
-	};
+			return swapExecutionResult({
+				operation,
+				signer: typeof entry.result?.signer === "string" ? entry.result.signer : taker,
+				order
+			});
+		}
+		if (entry?.signerRequestId && (entry.state === "unknown" || entry.state === "submitting" || entry.state === "signed")) {
+			let operation;
+			try {
+				operation = provider.reconcileSignerOperation ? await provider.reconcileSignerOperation({
+					walletId: params.payload.walletId,
+					requestId: entry.signerRequestId
+				}) : provider.getSignerOperation ? await provider.getSignerOperation({
+					walletId: params.payload.walletId,
+					requestId: entry.signerRequestId
+				}) : undefined;
+			} catch {
+				operation = undefined;
+			}
+			if (!operation || !order) {
+				return {
+					ok: false,
+					code: "wallet_provider_ambiguous",
+					message: `swap intent ${entry.key} has an unresolved signer submission; no new Jupiter order was created`
+				};
+			}
+			if (operation.state === "confirmed" && operation.signature) {
+				entry = await updateExternalSubmission({
+					key: entry.key,
+					expectedStates: [
+						"unknown",
+						"submitting",
+						"signed"
+					],
+					state: "confirmed",
+					patch: {
+						result: {
+							operation,
+							signer: taker
+						},
+						reason: undefined
+					},
+					env
+				});
+			} else if (operation.state === "failed") {
+				entry = await updateExternalSubmission({
+					key: entry.key,
+					expectedStates: [
+						"unknown",
+						"submitting",
+						"signed"
+					],
+					state: "failed",
+					patch: {
+						result: {
+							operation,
+							signer: taker
+						},
+						reason: operation.error
+					},
+					env
+				});
+			} else {
+				await updateExternalSubmission({
+					key: entry.key,
+					expectedStates: [
+						"unknown",
+						"submitting",
+						"signed"
+					],
+					state: "unknown",
+					patch: {
+						result: {
+							operation,
+							signer: taker
+						},
+						reason: `signer operation remains ${operation.state}`
+					},
+					env
+				});
+			}
+			return swapExecutionResult({
+				operation,
+				signer: taker,
+				order
+			});
+		}
+		if (entry?.state === "failed") {
+			const operation = storedSignerOperation(entry);
+			return {
+				ok: false,
+				code: "wallet_swap_failed",
+				message: operation?.error ?? entry.reason ?? "this swap intent failed; use a distinct explicit intentId for a new order"
+			};
+		}
+		if (entry?.state === "reserved" && provider.getSignerReview && autonomousIdentity) {
+			try {
+				const recovered = await provider.getSignerReview({
+					walletId: params.payload.walletId,
+					requestId: autonomousIdentity.key
+				});
+				if (!signerReviewMatchesAutonomousSwap({
+					review: recovered,
+					requestId: autonomousIdentity.key,
+					walletId: params.payload.walletId,
+					owner: taker,
+					inputMint: params.payload.inputMint,
+					outputMint: params.payload.outputMint,
+					amount: params.payload.amount
+				})) {
+					throw new Error("stored signer review does not match the durable autonomous swap intent");
+				}
+				if (recovered.semanticIntent.type !== "solana.jupiter.swap") {
+					throw new Error("stored signer review has an unexpected semantic intent type");
+				}
+				order = {
+					ok: true,
+					transaction: recovered.transaction.serializedTxBase64,
+					inputMint: params.payload.inputMint,
+					outputMint: params.payload.outputMint,
+					inAmount: params.payload.amount,
+					otherAmountThreshold: recovered.semanticIntent.jupiter.minimumOutputAmount,
+					slippageBps: params.payload.slippageBps,
+					raw: {}
+				};
+				entry = await updateExternalSubmission({
+					key: entry.key,
+					expectedStates: ["reserved"],
+					state: "prepared",
+					patch: {
+						signerRequestId: recovered.requestId,
+						signerIntentDigest: recovered.intentDigest,
+						transactionDigest: recovered.transactionDigest,
+						details: {
+							...entry.details,
+							order
+						}
+					},
+					env
+				});
+			} catch {}
+		}
+		const balance = await validateSolanaSwapInputBalance({
+			rpcUrl,
+			ownerAddress: taker,
+			inputMint: params.payload.inputMint,
+			amount: params.payload.amount
+		});
+		if (!balance.ok) {
+			return balance;
+		}
+		const reviewedOrder = params.autonomous ? undefined : reviewedSolanaSwapOrderFromPayload(params.payload);
+		order = order ?? reviewedOrder ?? await fetchJupiterSwapOrder({
+			inputMint: params.payload.inputMint,
+			outputMint: params.payload.outputMint,
+			amount: params.payload.amount,
+			slippageBps: params.payload.slippageBps,
+			taker,
+			env
+		});
+		const inspection = await inspectAndValidateSolanaSwapOrder({
+			order,
+			expectedSigner: taker,
+			rpcUrl,
+			config: effectiveConfig
+		});
+		if (!inspection.ok) {
+			return inspection;
+		}
+		if (!order.transaction) {
+			return {
+				ok: false,
+				code: "wallet_signer_v2_required",
+				message: "Jupiter signer review requires the exact serialized transaction"
+			};
+		}
+		let signerReviewRequestId;
+		if (params.autonomous && autonomousIdentity && entry) {
+			if (entry.state === "reserved") {
+				const prepared = await prepareSolanaSwapSignerReview({
+					provider,
+					walletId: params.payload.walletId,
+					owner: taker,
+					order,
+					inspection,
+					rpcUrl,
+					mode: "autonomous",
+					requestId: autonomousIdentity.key,
+					env
+				});
+				signerReviewRequestId = prepared.review.requestId;
+				entry = await updateExternalSubmission({
+					key: entry.key,
+					expectedStates: ["reserved"],
+					state: "prepared",
+					patch: {
+						signerRequestId: prepared.review.requestId,
+						signerIntentDigest: prepared.review.intentDigest,
+						transactionDigest: prepared.review.transactionDigest,
+						details: {
+							...entry.details,
+							order
+						}
+					},
+					env
+				});
+			} else {
+				signerReviewRequestId = entry.signerRequestId ?? "";
+			}
+			if (!signerReviewRequestId || signerReviewRequestId !== autonomousIdentity.key) {
+				return {
+					ok: false,
+					code: "wallet_provider_ambiguous",
+					message: "durable autonomous swap is not bound to its stable signer request"
+				};
+			}
+		} else {
+			const requestId = params.payload.signerReviewId?.trim();
+			if (!requestId) {
+				return {
+					ok: false,
+					code: "wallet_signer_review_missing",
+					message: "reviewed Jupiter swap is not bound to signer review.prepare"
+				};
+			}
+			signerReviewRequestId = requestId;
+		}
+		let executed;
+		try {
+			executed = await provider.executeJupiterReview({
+				walletId: params.payload.walletId,
+				requestId: signerReviewRequestId,
+				...params.reviewAuthorization ? { authorization: params.reviewAuthorization } : {}
+			});
+		} catch (error) {
+			if (entry) {
+				await updateExternalSubmission({
+					key: entry.key,
+					expectedStates: ["prepared"],
+					state: "unknown",
+					patch: { reason: `signer response was lost after exact review preparation: ${String(error)}` },
+					env
+				});
+				return {
+					ok: false,
+					code: "wallet_provider_ambiguous",
+					message: `signer response for ${signerReviewRequestId} is ambiguous; reconcile it before any new Jupiter order`
+				};
+			}
+			throw error;
+		}
+		const result = swapExecutionResult({
+			operation: executed.operation,
+			signer: executed.signer,
+			order,
+			inspection
+		});
+		if (entry) {
+			const confirmed = executed.operation.state === "confirmed" && Boolean(executed.operation.signature);
+			const failed = executed.operation.state === "failed";
+			await updateExternalSubmission({
+				key: entry.key,
+				expectedStates: ["prepared"],
+				state: confirmed ? "confirmed" : failed ? "failed" : "unknown",
+				patch: {
+					signerSignature: executed.operation.signature,
+					transactionDigest: executed.operation.transactionDigest,
+					result: {
+						operation: executed.operation,
+						signer: executed.signer
+					},
+					reason: result.ok ? undefined : result.message
+				},
+				env
+			});
+		}
+		return result;
+	} finally {
+		await releaseExecution?.();
+	}
 }
 
 //#endregion
-export { SOLANA_NATIVE_MINT, executeSolanaSwapApprovalPayload, fetchJupiterSwapOrder, inspectAndValidateSolanaSwapOrder, isSolanaSwapApprovalPayload, validateSolanaSwapInputBalance, validateSolanaSwapIntentPolicy };
+export { SOLANA_NATIVE_MINT, executeSolanaSwapApprovalPayload, fetchJupiterSwapOrder, inspectAndValidateSolanaSwapOrder, isSolanaSwapApprovalPayload, prepareSolanaSwapSignerReview, resolveJupiterMaxFeeLamports, validateSolanaSwapInputBalance, validateSolanaSwapIntentPolicy };