@fased/fased 0.1.62 → 0.1.64

package/dist/wallet/solana-trigger.js

@@ -1,418 +1,756 @@
-import { enforceWalletDailyCap } from "./wallet-policy.js";
-import { inspectSerializedSolanaSwapTransaction } from "./solana-transaction-inspection.js";
-import { SOLANA_NATIVE_MINT, validateSolanaSwapInputBalance, validateSolanaSwapIntentPolicy } from "./solana-swap.js";
+import { SOLANA_ASSET_CONSTANTS, fetchSolanaMintInfoViaRpc } from "./solana-assets.js";
+import { beginExternalSubmission, claimExternalSubmissionExecution, createExternalSubmissionKey, externalSubmissionIntentDigest, getExternalSubmission, getExternalSubmissionByExplicitIntent, updateExternalSubmission } from "./external-submission-ledger.js";
+import { SOLANA_NATIVE_MINT, resolveJupiterMaxFeeLamports, validateSolanaSwapInputBalance, validateSolanaSwapIntentPolicy } from "./solana-swap.js";
+import { createHash } from "node:crypto";
 
 //#region src/wallet/solana-trigger.ts
-const JUPITER_TRIGGER_DEFAULT_BASE_URL = "https://api.jup.ag/trigger/v2";
 const JUPITER_TRIGGER_MAX_EXPIRY_MS = 30 * 24 * 60 * 60 * 1e3;
 const JUPITER_TRIGGER_DEFAULT_EXPIRY_MS = 7 * 24 * 60 * 60 * 1e3;
+const SOLANA_SYSTEM_PROGRAM_ID = "11111111111111111111111111111111";
 function stringValue(value) {
 	return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
-function positiveNumber(value) {
-	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+function positiveBaseUnits(value, field) {
+	const normalized = stringValue(value);
+	if (!normalized || normalized.length > 32 || !/^[1-9][0-9]*$/.test(normalized)) {
+		throw new Error(`${field} must be a positive base-unit integer`);
+	}
+	const parsed = BigInt(normalized);
+	if (parsed > 18446744073709551615n) {
+		throw new Error(`${field} must fit an unsigned 64-bit integer`);
+	}
+	return parsed.toString();
 }
-function resolveTriggerApiBaseUrl(env = process.env) {
-	return (env.FASED_JUPITER_TRIGGER_API_BASE_URL?.trim() || env.JUPITER_TRIGGER_API_BASE_URL?.trim() || JUPITER_TRIGGER_DEFAULT_BASE_URL).replace(/\/+$/, "");
+function expandScientificDecimal(value) {
+	const match = /^(\d+)(?:\.(\d+))?[eE]([+-]?\d+)$/.exec(value);
+	if (!match) {
+		return value;
+	}
+	const integer = match[1] ?? "";
+	const fraction = match[2] ?? "";
+	const exponent = Number.parseInt(match[3] ?? "0", 10);
+	const digits = integer + fraction;
+	const decimalIndex = integer.length + exponent;
+	if (decimalIndex <= 0) {
+		return `0.${"0".repeat(-decimalIndex)}${digits}`;
+	}
+	if (decimalIndex >= digits.length) {
+		return `${digits}${"0".repeat(decimalIndex - digits.length)}`;
+	}
+	return `${digits.slice(0, decimalIndex)}.${digits.slice(decimalIndex)}`;
 }
-function resolveTriggerApiKey(env = process.env) {
-	return env.FASED_JUPITER_API_KEY?.trim() || env.JUPITER_API_KEY?.trim() || "";
+function canonicalJupiterTriggerPrice(value) {
+	const raw = typeof value === "number" && Number.isFinite(value) ? expandScientificDecimal(String(value)) : typeof value === "string" ? value.trim() : "";
+	if (!/^(?:0|[1-9][0-9]*)(?:\.[0-9]+)?$/.test(raw)) {
+		throw new Error("limit order triggerPriceUsd must be a positive plain decimal string");
+	}
+	const [integer = "", rawFraction] = raw.split(".");
+	const fraction = rawFraction?.replace(/0+$/, "");
+	const normalized = fraction ? `${integer}.${fraction}` : integer;
+	if (!normalized || normalized === "0") {
+		throw new Error("limit order triggerPriceUsd must be positive");
+	}
+	return normalized;
 }
-async function triggerJson(params) {
-	const response = await fetch(`${resolveTriggerApiBaseUrl(params.env)}/${params.path.replace(/^\/+/, "")}`, {
-		method: params.method ?? "GET",
-		headers: {
-			accept: "application/json",
-			"x-api-key": params.apiKey,
-			...params.body ? { "content-type": "application/json" } : {},
-			...params.token ? { authorization: `Bearer ${params.token}` } : {}
-		},
-		body: params.body ? JSON.stringify(params.body) : undefined
-	});
-	const json = await response.json().catch(() => null);
-	if (!response.ok || !json || typeof json !== "object") {
-		const message = stringValue(json?.error) ?? stringValue(json?.message) ?? response.statusText;
-		throw new Error(`jupiter trigger ${params.path} failed: ${response.status} ${message}`);
+function readJupiterTriggerPositiveNumber(value) {
+	try {
+		return canonicalJupiterTriggerPrice(value);
+	} catch {
+		return undefined;
+	}
+}
+function normalizeTriggerSlippage(value) {
+	const slippageBps = value === undefined ? 50 : Math.floor(value);
+	if (!Number.isFinite(slippageBps) || slippageBps < 1 || slippageBps > 1e3) {
+		throw new Error("limit order slippageBps must be between 1 and 1000");
 	}
-	return json;
+	return slippageBps;
 }
 function normalizeTriggerExpiry(params) {
-	const now = Date.now();
-	const fromSeconds = typeof params.expirySeconds === "number" && Number.isFinite(params.expirySeconds) ? now + Math.max(60, Math.floor(params.expirySeconds)) * 1e3 : undefined;
-	const expiresAt = Math.floor(params.expiresAt ?? fromSeconds ?? now + JUPITER_TRIGGER_DEFAULT_EXPIRY_MS);
-	if (expiresAt <= now + 6e4) {
-		throw new Error("limit order expiry must be at least 60 seconds in the future");
+	const now = params.now ?? Date.now();
+	let expiresAtMs;
+	let callerExpiry;
+	if (typeof params.expiresAt === "string") {
+		if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(params.expiresAt)) {
+			throw new Error("limit order expiresAt must use exact UTC millisecond format");
+		}
+		expiresAtMs = Date.parse(params.expiresAt);
+		callerExpiry = { expiresAt: params.expiresAt };
+	} else if (typeof params.expiresAt === "number" && Number.isFinite(params.expiresAt)) {
+		expiresAtMs = Math.floor(params.expiresAt);
+		callerExpiry = { expiresAtMs };
+	} else if (typeof params.expirySeconds === "number" && Number.isFinite(params.expirySeconds)) {
+		const expirySeconds = Math.floor(params.expirySeconds);
+		if (expirySeconds < 60 || expirySeconds > JUPITER_TRIGGER_MAX_EXPIRY_MS / 1e3) {
+			throw new Error("limit order expirySeconds must be between 60 and 2592000");
+		}
+		expiresAtMs = now + expirySeconds * 1e3;
+		callerExpiry = { expirySeconds };
+	} else {
+		expiresAtMs = now + JUPITER_TRIGGER_DEFAULT_EXPIRY_MS;
+		callerExpiry = { defaultExpiry: "7d" };
+	}
+	if (!Number.isFinite(expiresAtMs) || expiresAtMs <= now + 6e4) {
+		throw new Error("limit order expiry must be more than 60 seconds in the future");
 	}
-	if (expiresAt > now + JUPITER_TRIGGER_MAX_EXPIRY_MS) {
+	if (expiresAtMs > now + JUPITER_TRIGGER_MAX_EXPIRY_MS) {
 		throw new Error("limit order expiry must be 30 days or less");
 	}
-	return expiresAt;
-}
-async function signSerializedSolanaTx(params) {
-	if (!params.provider.signTx) {
-		throw new Error("wallet provider cannot sign Jupiter Trigger deposit transactions");
-	}
-	const signed = await params.provider.signTx({
-		chain: "solana",
-		walletId: params.walletId,
-		serializedTxBase64: params.serializedTxBase64,
-		amount: params.amount ?? "0",
-		tokenMint: params.tokenMint
-	});
-	if (!signed.ok || !signed.signedTxBase64) {
-		throw new Error("wallet provider failed to sign Jupiter Trigger transaction");
+	const expiresAt = new Date(expiresAtMs).toISOString();
+	if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(expiresAt)) {
+		throw new Error("limit order expiry is outside the supported timestamp range");
 	}
 	return {
-		signedTxBase64: signed.signedTxBase64,
-		signer: signed.signer
+		expiresAt,
+		callerExpiry
 	};
 }
-async function authenticateJupiterTrigger(params) {
-	const challenge = await triggerJson({
-		path: "/auth/challenge",
-		method: "POST",
-		apiKey: params.apiKey,
-		body: {
-			walletPubkey: params.walletAddress,
-			type: "transaction"
-		},
-		env: params.env
+function triggerExpiryIdentity(params) {
+	if (typeof params.expiresAt === "string") {
+		return { expiresAt: params.expiresAt.trim() };
+	}
+	if (typeof params.expiresAt === "number" && Number.isFinite(params.expiresAt)) {
+		return { expiresAtMs: Math.floor(params.expiresAt) };
+	}
+	if (typeof params.expirySeconds === "number" && Number.isFinite(params.expirySeconds)) {
+		return { expirySeconds: Math.floor(params.expirySeconds) };
+	}
+	return { defaultExpiry: "7d" };
+}
+async function resolveTriggerTransferProgram(params) {
+	if (params.mint === SOLANA_NATIVE_MINT) {
+		return SOLANA_SYSTEM_PROGRAM_ID;
+	}
+	if (!params.rpcUrl?.trim()) {
+		throw new Error("Solana RPC is required to resolve the exact Trigger token program");
+	}
+	const mint = await fetchSolanaMintInfoViaRpc({
+		rpcUrl: params.rpcUrl,
+		mint: params.mint
 	});
-	const transaction = stringValue(challenge.transaction);
-	if (!transaction) {
-		throw new Error("jupiter trigger did not return an auth transaction");
-	}
-	const inspection = await inspectSerializedSolanaSwapTransaction({
-		serializedTxBase64: transaction,
-		expectedSigner: params.walletAddress,
-		rpcUrl: params.rpcUrl
+	if (!mint || mint.tokenProgramId !== SOLANA_ASSET_CONSTANTS.tokenProgramId && mint.tokenProgramId !== SOLANA_ASSET_CONSTANTS.token2022ProgramId) {
+		throw new Error(`unable to resolve a supported SPL token program for ${params.mint}`);
+	}
+	return mint.tokenProgramId;
+}
+function validateJupiterTriggerLimitOrderIntent(params) {
+	const swapPolicy = validateSolanaSwapIntentPolicy({
+		config: params.config,
+		inputMint: params.inputMint,
+		outputMint: params.outputMint,
+		amount: params.amount,
+		autonomous: params.autonomous
 	});
-	if (!inspection.ok) {
-		throw new Error(inspection.message);
+	if (!swapPolicy.ok) {
+		return {
+			ok: false,
+			code: swapPolicy.code ?? "wallet_trigger_policy_rejected",
+			message: swapPolicy.message ?? "wallet Trigger policy rejected"
+		};
 	}
-	if (inspection.routeProgramIds.length > 0) {
-		throw new Error(`jupiter trigger auth uses unexpected program ${inspection.routeProgramIds[0]}`);
+	if (params.triggerCondition !== "above" && params.triggerCondition !== "below") {
+		return {
+			ok: false,
+			code: "wallet_trigger_condition_invalid",
+			message: "limit order triggerCondition must be above or below"
+		};
 	}
-	const signed = await signSerializedSolanaTx({
-		provider: params.provider,
+	try {
+		canonicalJupiterTriggerPrice(params.triggerPriceUsd);
+		normalizeTriggerSlippage(params.slippageBps);
+	} catch (error) {
+		return {
+			ok: false,
+			code: "wallet_trigger_terms_invalid",
+			message: String(error)
+		};
+	}
+	return { ok: true };
+}
+function triggerRequestId(params) {
+	const digest = createHash("sha256").update(`${params.action}\0${params.mode}\0${params.walletId}\0${params.intentId}`).digest("hex");
+	return `jupiter-trigger-${params.action}:${digest}`;
+}
+function triggerExplicitIntentId(params) {
+	return `${params.action}:${params.mode}:${createHash("sha256").update(params.intentId).digest("hex")}`;
+}
+function isStoredTriggerIntent(value, action) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return false;
+	}
+	const intent = value;
+	return intent.type === `solana.jupiter.trigger.${action}` && Boolean(intent.jupiter && typeof intent.jupiter === "object") && intent.jupiter?.trigger?.operation === action;
+}
+async function bindTriggerIntent(params) {
+	if (!params.intentId.trim()) {
+		throw new Error("Jupiter Trigger requires a stable caller-owned intentId");
+	}
+	const explicitIntentId = triggerExplicitIntentId(params);
+	const callerIntentDigest = externalSubmissionIntentDigest(params.callerIntent);
+	const reuse = (entry) => {
+		if (entry.details?.callerIntentDigest !== callerIntentDigest) {
+			throw new Error("Jupiter Trigger intentId is already bound to different immutable terms");
+		}
+		const intent = entry.details?.semanticIntent;
+		if (!isStoredTriggerIntent(intent, params.action)) {
+			throw new Error("Jupiter Trigger durable intent record is incomplete; refusing execution");
+		}
+		return {
+			entry,
+			intent
+		};
+	};
+	const existing = getExternalSubmissionByExplicitIntent({
+		kind: params.kind,
 		walletId: params.walletId,
-		serializedTxBase64: transaction,
-		amount: "0"
-	});
-	const verified = await triggerJson({
-		path: "/auth/verify",
-		method: "POST",
-		apiKey: params.apiKey,
-		body: {
-			type: "transaction",
-			walletPubkey: params.walletAddress,
-			signedTransaction: signed.signedTxBase64
-		},
+		explicitIntentId,
 		env: params.env
 	});
-	const token = stringValue(verified.token);
-	if (!token) {
-		throw new Error("jupiter trigger auth did not return a token");
+	if (existing) {
+		return reuse(existing);
+	}
+	const intent = await params.buildIntent();
+	const identity = createExternalSubmissionKey({
+		kind: params.kind,
+		walletId: params.walletId,
+		explicitIntentId,
+		intent
+	});
+	try {
+		const begun = await beginExternalSubmission({
+			...identity,
+			kind: params.kind,
+			walletId: params.walletId,
+			details: {
+				callerIntentDigest,
+				semanticIntent: intent
+			},
+			env: params.env
+		});
+		return {
+			entry: begun.entry,
+			intent
+		};
+	} catch (error) {
+		const raced = getExternalSubmissionByExplicitIntent({
+			kind: params.kind,
+			walletId: params.walletId,
+			explicitIntentId,
+			env: params.env
+		});
+		if (raced) {
+			return reuse(raced);
+		}
+		throw error;
+	}
+}
+function storedOperation(entry) {
+	const value = entry.result?.operation;
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return null;
+	}
+	const operation = value;
+	if (typeof operation.requestId !== "string" || typeof operation.walletId !== "string" || typeof operation.intentDigest !== "string" || typeof operation.policyHash !== "string" || typeof operation.state !== "string") {
+		return null;
 	}
-	return token;
+	return operation;
 }
-async function getOrRegisterJupiterVault(params) {
+function ensureTriggerReview(params) {
+	const { review } = params;
+	if (review.walletId !== params.walletId || review.requestId !== params.requestId || review.mode !== "reviewed" || review.state !== "prepared" || review.intentType !== params.intent.type || review.artifactKind !== "jupiter-trigger-state" || review.transaction !== undefined || review.messageBase64 !== undefined || externalSubmissionIntentDigest(review.semanticIntent) !== externalSubmissionIntentDigest(params.intent)) {
+		throw new Error("signer returned a mismatched Jupiter Trigger review");
+	}
+	return review;
+}
+async function prepareReviewedTrigger(params) {
+	if (!params.provider.prepareSignerReview || !params.provider.getSignerReview) {
+		throw new Error("Jupiter Trigger review requires protocol-v2 local-socket-signer review.prepare support");
+	}
+	const release = await claimExternalSubmissionExecution(params.entry.key, params.env);
 	try {
-		return await triggerJson({
-			path: "/vault",
-			apiKey: params.apiKey,
-			token: params.token,
+		const entry = getExternalSubmission({
+			key: params.entry.key,
 			env: params.env
 		});
-	} catch {
-		try {
-			return await triggerJson({
-				path: "/vault/register",
-				apiKey: params.apiKey,
-				token: params.token,
-				env: params.env
+		if (!entry) {
+			throw new Error("Jupiter Trigger durable intent record disappeared; refusing review");
+		}
+		if (entry.state === "prepared") {
+			return ensureTriggerReview({
+				review: await params.provider.getSignerReview({
+					walletId: params.walletId,
+					requestId: params.requestId
+				}),
+				walletId: params.walletId,
+				requestId: params.requestId,
+				intent: params.intent
 			});
-		} catch {
-			return await triggerJson({
-				path: "/vault",
-				apiKey: params.apiKey,
-				token: params.token,
-				env: params.env
+		}
+		if (entry.state !== "reserved") {
+			throw new Error(`reviewed Jupiter Trigger intent is ${entry.state}; it cannot be prepared again`);
+		}
+		let review;
+		try {
+			review = await params.provider.prepareSignerReview({
+				walletId: params.walletId,
+				requestId: params.requestId,
+				mode: "reviewed",
+				intent: params.intent
 			});
+		} catch (error) {
+			try {
+				review = await params.provider.getSignerReview({
+					walletId: params.walletId,
+					requestId: params.requestId
+				});
+			} catch {
+				throw error;
+			}
 		}
+		const checked = ensureTriggerReview({
+			review,
+			walletId: params.walletId,
+			requestId: params.requestId,
+			intent: params.intent
+		});
+		await updateExternalSubmission({
+			key: entry.key,
+			expectedStates: ["reserved"],
+			state: "prepared",
+			patch: {
+				signerRequestId: checked.requestId,
+				signerIntentDigest: checked.intentDigest,
+				details: entry.details
+			},
+			env: params.env
+		});
+		return checked;
+	} finally {
+		await release();
 	}
 }
-function validateJupiterTriggerLimitOrderIntent(params) {
-	const condition = params.triggerCondition.trim();
-	if (condition !== "above" && condition !== "below") {
-		return {
-			ok: false,
-			code: "wallet_limit_trigger_condition_invalid",
-			message: "limit order triggerCondition must be above or below"
-		};
+async function persistAutonomousOperation(params) {
+	const state = params.operation.state === "confirmed" ? "confirmed" : params.operation.state === "failed" ? "failed" : "unknown";
+	return await updateExternalSubmission({
+		key: params.entry.key,
+		expectedStates: ["submitting", "unknown"],
+		state,
+		patch: {
+			signerRequestId: params.operation.requestId,
+			signerIntentDigest: params.operation.intentDigest,
+			signerSignature: params.operation.signature,
+			transactionDigest: params.operation.transactionDigest,
+			reason: params.operation.error,
+			details: params.entry.details,
+			result: { operation: params.operation }
+		},
+		env: params.env
+	});
+}
+function requireConfirmedTriggerOperation(params) {
+	const operation = params.operation;
+	if (operation.requestId !== params.requestId || operation.walletId !== params.walletId || operation.intentType !== `solana.jupiter.trigger.${params.action}`) {
+		throw new Error("signer returned a Jupiter Trigger operation for different immutable terms");
 	}
-	if (!Number.isFinite(params.triggerPriceUsd) || params.triggerPriceUsd <= 0) {
-		return {
-			ok: false,
-			code: "wallet_limit_trigger_price_invalid",
-			message: "limit order triggerPriceUsd must be positive"
-		};
+	if (operation.state !== "confirmed" || !operation.signature) {
+		const ambiguous = operation.state === "reserved" || operation.state === "broadcast" || operation.state === "unknown";
+		throw new Error(ambiguous ? `Jupiter Trigger signer operation ${operation.requestId} is ${operation.state}; reconcile it and do not submit again` : operation.error ?? `Jupiter Trigger signer operation failed in state=${operation.state}`);
+	}
+	const external = operation.externalResult;
+	if (external?.provider !== "jupiter-trigger-v2" || external.action !== params.action || !external.orderId || (params.action === "create" ? external.orderState !== "open" : external.orderState !== "cancelled")) {
+		throw new Error("confirmed Jupiter Trigger operation omitted its sanitized exact order result");
 	}
-	const slippage = params.slippageBps ?? 100;
-	if (!Number.isFinite(slippage) || slippage < 1 || slippage > 1e3) {
+	return {
+		id: external.orderId,
+		txSignature: operation.signature,
+		state: external.orderState,
+		provider: external.provider
+	};
+}
+function assertTriggerOperationIdentity(params) {
+	if (params.operation.requestId !== params.requestId || params.operation.walletId !== params.walletId || params.operation.intentType !== `solana.jupiter.trigger.${params.action}` || params.signerIntentDigest && params.operation.intentDigest !== params.signerIntentDigest) {
+		throw new Error("signer returned a Jupiter Trigger operation for different immutable terms");
+	}
+}
+async function executeAutonomousTrigger(params) {
+	if (!params.provider.executeSignerIntent || !params.provider.reconcileSignerOperation) {
+		throw new Error("autonomous Jupiter Trigger requires protocol-v2 local-socket-signer execute/reconcile support");
+	}
+	const release = await claimExternalSubmissionExecution(params.entry.key, params.env);
+	try {
+		let entry = getExternalSubmission({
+			key: params.entry.key,
+			env: params.env
+		});
+		if (!entry) {
+			throw new Error("Jupiter Trigger durable intent record disappeared; refusing execution");
+		}
+		if (entry.state === "confirmed" || entry.state === "failed") {
+			const operation = storedOperation(entry);
+			if (!operation) {
+				throw new Error("Jupiter Trigger durable result is incomplete; refusing another submission");
+			}
+			return {
+				operation,
+				order: requireConfirmedTriggerOperation({
+					...params,
+					operation
+				})
+			};
+		}
+		let operation;
+		if (entry.state === "submitting" || entry.state === "unknown") {
+			operation = await params.provider.reconcileSignerOperation({
+				walletId: params.walletId,
+				requestId: params.requestId
+			});
+		} else if (entry.state === "reserved") {
+			entry = await updateExternalSubmission({
+				key: entry.key,
+				expectedStates: ["reserved"],
+				state: "submitting",
+				patch: {
+					signerRequestId: params.requestId,
+					details: entry.details
+				},
+				env: params.env
+			});
+			try {
+				operation = await params.provider.executeSignerIntent({
+					walletId: params.walletId,
+					requestId: params.requestId,
+					intent: params.intent
+				});
+			} catch (error) {
+				await updateExternalSubmission({
+					key: entry.key,
+					expectedStates: ["submitting"],
+					state: "unknown",
+					patch: {
+						signerRequestId: params.requestId,
+						reason: "signer response was lost; reconcile the existing request without re-executing",
+						details: entry.details
+					},
+					env: params.env
+				});
+				throw new Error("Jupiter Trigger execution result is unknown; reconcile the signer request and do not retry it", { cause: error });
+			}
+		} else {
+			throw new Error(`autonomous Jupiter Trigger intent cannot execute from ${entry.state}`);
+		}
+		assertTriggerOperationIdentity({
+			...params,
+			operation,
+			signerIntentDigest: entry.signerIntentDigest
+		});
+		entry = await persistAutonomousOperation({
+			entry,
+			operation,
+			env: params.env
+		});
+		const stored = storedOperation(entry);
+		if (!stored) {
+			throw new Error("Jupiter Trigger durable operation result was not persisted");
+		}
 		return {
-			ok: false,
-			code: "wallet_limit_slippage_invalid",
-			message: "limit order slippageBps must be between 1 and 1000"
+			operation: stored,
+			order: requireConfirmedTriggerOperation({
+				...params,
+				operation: stored
+			})
 		};
+	} finally {
+		await release();
 	}
-	const policy = validateSolanaSwapIntentPolicy({
-		config: params.config,
-		inputMint: params.inputMint,
-		outputMint: params.outputMint,
-		amount: params.amount,
-		autonomous: params.autonomous
-	});
-	return policy.ok ? { ok: true } : {
-		ok: false,
-		code: policy.code ?? "wallet_limit_policy_rejected",
-		message: policy.message ?? "limit order rejected by wallet policy"
-	};
 }
 async function createJupiterTriggerLimitOrder(params) {
 	const env = params.env ?? process.env;
-	const apiKey = resolveTriggerApiKey(env);
-	if (!apiKey) {
-		throw new Error("Jupiter Trigger requires FASED_JUPITER_API_KEY or JUPITER_API_KEY");
+	const mode = params.autonomous ? "autonomous" : "reviewed";
+	const intentId = params.intentId?.trim();
+	if (!intentId) {
+		throw new Error("Jupiter Trigger create requires a stable caller-owned intentId");
 	}
+	const inputMint = params.inputMint.trim();
+	const outputMint = params.outputMint.trim();
+	const triggerMint = params.triggerMint.trim();
+	const amount = positiveBaseUnits(params.amount, "limit order amount");
+	const triggerPriceUsd = canonicalJupiterTriggerPrice(params.triggerPriceUsd);
+	const slippageBps = normalizeTriggerSlippage(params.slippageBps);
+	const callerExpiry = triggerExpiryIdentity(params);
 	const policy = validateJupiterTriggerLimitOrderIntent({
 		config: params.config,
-		inputMint: params.inputMint,
-		outputMint: params.outputMint,
-		amount: params.amount,
+		inputMint,
+		outputMint,
+		amount,
 		triggerCondition: params.triggerCondition,
-		triggerPriceUsd: params.triggerPriceUsd,
-		slippageBps: params.slippageBps,
+		triggerPriceUsd,
+		slippageBps,
 		autonomous: params.autonomous
 	});
 	if (!policy.ok) {
 		throw new Error(policy.message);
 	}
-	const balance = await validateSolanaSwapInputBalance({
-		rpcUrl: params.rpcUrl,
-		ownerAddress: params.walletAddress,
-		inputMint: params.inputMint,
-		amount: params.amount
-	});
-	if (!balance.ok) {
-		throw new Error(balance.message);
+	if (!triggerMint) {
+		throw new Error("Jupiter Trigger create requires an exact trigger mint");
 	}
-	const token = await authenticateJupiterTrigger({
-		provider: params.provider,
+	const requestId = triggerRequestId({
+		action: "create",
+		mode,
 		walletId: params.walletId,
-		walletAddress: params.walletAddress,
-		apiKey,
-		rpcUrl: params.rpcUrl,
-		env
-	});
-	const vault = await getOrRegisterJupiterVault({
-		apiKey,
-		token,
-		env
-	});
-	const deposit = await triggerJson({
-		path: "/deposit/craft",
-		method: "POST",
-		apiKey,
-		token,
-		body: {
-			inputMint: params.inputMint,
-			outputMint: params.outputMint,
-			userAddress: params.walletAddress,
-			amount: params.amount
-		},
-		env
-	});
-	const depositTx = stringValue(deposit.transaction);
-	const depositRequestId = stringValue(deposit.requestId);
-	if (!depositTx || !depositRequestId) {
-		throw new Error("jupiter trigger did not return a deposit transaction");
-	}
-	const depositInspection = await inspectSerializedSolanaSwapTransaction({
-		serializedTxBase64: depositTx,
-		expectedSigner: params.walletAddress,
-		rpcUrl: params.rpcUrl
+		intentId
 	});
-	if (!depositInspection.ok) {
-		throw new Error(depositInspection.message);
-	}
-	if (depositInspection.routeProgramIds.length > 0) {
-		throw new Error(`jupiter trigger deposit uses unexpected program ${depositInspection.routeProgramIds[0]}`);
-	}
-	const daily = enforceWalletDailyCap({
-		config: params.config,
-		chain: "solana",
-		amount: params.amount,
-		tokenMint: params.inputMint === SOLANA_NATIVE_MINT ? undefined : params.inputMint,
+	const bound = await bindTriggerIntent({
+		kind: "jupiter-trigger-create",
+		action: "create",
+		mode,
 		walletId: params.walletId,
+		intentId,
+		callerIntent: {
+			owner: params.walletAddress,
+			inputMint,
+			outputMint,
+			inputAmount: amount,
+			triggerMint,
+			condition: params.triggerCondition,
+			targetPriceUsd: triggerPriceUsd,
+			slippageBps,
+			expiry: callerExpiry
+		},
+		buildIntent: async () => {
+			const expiry = normalizeTriggerExpiry({
+				expiresAt: params.expiresAt,
+				expirySeconds: params.expirySeconds
+			});
+			if (params.rpcUrl?.trim()) {
+				const balance = await validateSolanaSwapInputBalance({
+					rpcUrl: params.rpcUrl,
+					ownerAddress: params.walletAddress,
+					inputMint,
+					amount
+				});
+				if (!balance.ok) {
+					throw new Error(balance.message);
+				}
+			}
+			const program = await resolveTriggerTransferProgram({
+				mint: inputMint,
+				rpcUrl: params.rpcUrl
+			});
+			return {
+				type: "solana.jupiter.trigger.create",
+				jupiter: {
+					owner: params.walletAddress,
+					inputMint,
+					outputMint,
+					inputAmount: amount,
+					maxInputAmount: amount,
+					minimumOutputAmount: "0",
+					maxFeeLamports: resolveJupiterMaxFeeLamports(env),
+					programs: [program],
+					trigger: {
+						operation: "create",
+						program,
+						triggerMint,
+						condition: params.triggerCondition,
+						targetPriceUsd: triggerPriceUsd,
+						slippageBps,
+						expiresAt: expiry.expiresAt,
+						expectedOrderState: "new"
+					}
+				}
+			};
+		},
 		env
 	});
-	if (!daily.ok) {
-		throw new Error(daily.message ?? daily.code ?? "wallet daily cap exceeded");
+	if (mode === "reviewed") {
+		const review = await prepareReviewedTrigger({
+			provider: params.provider,
+			walletId: params.walletId,
+			requestId,
+			entry: bound.entry,
+			intent: bound.intent,
+			env
+		});
+		return {
+			ok: true,
+			mode,
+			review,
+			intent: bound.intent
+		};
 	}
-	const signedDeposit = await signSerializedSolanaTx({
+	const executed = await executeAutonomousTrigger({
 		provider: params.provider,
 		walletId: params.walletId,
-		serializedTxBase64: depositTx,
-		amount: params.amount,
-		tokenMint: params.inputMint === SOLANA_NATIVE_MINT ? undefined : params.inputMint
-	});
-	const orderBody = {
-		orderType: "single",
-		depositRequestId,
-		depositSignedTx: signedDeposit.signedTxBase64,
-		userPubkey: params.walletAddress,
-		inputMint: params.inputMint,
-		inputAmount: params.amount,
-		outputMint: params.outputMint,
-		triggerMint: params.triggerMint || params.inputMint,
-		triggerCondition: params.triggerCondition,
-		triggerPriceUsd: params.triggerPriceUsd,
-		slippageBps: params.slippageBps ?? 100,
-		expiresAt: normalizeTriggerExpiry({
-			expiresAt: params.expiresAt,
-			expirySeconds: params.expirySeconds
-		})
-	};
-	const raw = await triggerJson({
-		path: "/orders/price",
-		method: "POST",
-		apiKey,
-		token,
-		body: orderBody,
+		requestId,
+		entry: bound.entry,
+		intent: bound.intent,
+		action: "create",
 		env
 	});
 	return {
 		ok: true,
-		vault,
-		order: {
-			id: stringValue(raw.id),
-			txSignature: stringValue(raw.txSignature),
-			raw
-		}
+		mode,
+		...executed
 	};
 }
 async function listJupiterTriggerOrders(params) {
-	const env = params.env ?? process.env;
-	const apiKey = resolveTriggerApiKey(env);
-	if (!apiKey) {
-		throw new Error("Jupiter Trigger requires FASED_JUPITER_API_KEY or JUPITER_API_KEY");
+	if (!params.provider.listJupiterTriggerOrders) {
+		throw new Error("Jupiter Trigger history requires the signer-owned sanitized history capability");
 	}
-	const token = await authenticateJupiterTrigger({
-		provider: params.provider,
+	const history = await params.provider.listJupiterTriggerOrders({
 		walletId: params.walletId,
-		walletAddress: params.walletAddress,
-		apiKey,
-		rpcUrl: params.rpcUrl,
-		env
-	});
-	const search = new URLSearchParams();
-	if (params.state) {
-		search.set("state", params.state);
-	}
-	if (params.mint?.trim()) {
-		search.set("mint", params.mint.trim());
-	}
-	search.set("limit", String(Math.max(1, Math.min(100, Math.floor(params.limit ?? 20)))));
-	search.set("offset", String(Math.max(0, Math.floor(params.offset ?? 0))));
-	const raw = await triggerJson({
-		path: `/orders/history?${search.toString()}`,
-		apiKey,
-		token,
-		env
+		state: params.state
 	});
+	const mint = params.mint?.trim();
+	const matching = mint ? history.orders.filter((order) => order.inputMint === mint || order.outputMint === mint || order.triggerMint === mint) : history.orders;
+	const offset = Math.max(0, Math.floor(params.offset ?? 0));
+	const limit = Math.max(1, Math.min(100, Math.floor(params.limit ?? 20)));
 	return {
-		orders: Array.isArray(raw.orders) ? raw.orders : [],
-		pagination: raw.pagination,
-		raw
+		orders: matching.slice(offset, offset + limit),
+		pagination: {
+			total: matching.length,
+			limit,
+			offset
+		}
 	};
 }
 async function cancelJupiterTriggerOrder(params) {
 	const env = params.env ?? process.env;
-	const apiKey = resolveTriggerApiKey(env);
-	if (!apiKey) {
-		throw new Error("Jupiter Trigger requires FASED_JUPITER_API_KEY or JUPITER_API_KEY");
-	}
+	const mode = params.autonomous ? "autonomous" : "reviewed";
 	const orderId = params.orderId.trim();
-	if (!orderId) {
-		throw new Error("orderId is required");
+	const intentId = params.intentId?.trim();
+	if (!orderId || !intentId) {
+		throw new Error("Jupiter Trigger cancel requires exact orderId and stable caller-owned intentId");
 	}
-	const token = await authenticateJupiterTrigger({
-		provider: params.provider,
+	const requestId = triggerRequestId({
+		action: "cancel",
+		mode,
 		walletId: params.walletId,
-		walletAddress: params.walletAddress,
-		apiKey,
-		rpcUrl: params.rpcUrl,
-		env
+		intentId
 	});
-	const cancel = await triggerJson({
-		path: `/orders/price/cancel/${encodeURIComponent(orderId)}`,
-		method: "POST",
-		apiKey,
-		token,
+	const existing = getExternalSubmissionByExplicitIntent({
+		kind: "jupiter-trigger-cancel",
+		walletId: params.walletId,
+		explicitIntentId: triggerExplicitIntentId({
+			action: "cancel",
+			mode,
+			intentId
+		}),
 		env
 	});
-	const transaction = stringValue(cancel.transaction);
-	const cancelRequestId = stringValue(cancel.requestId);
-	if (!transaction || !cancelRequestId) {
-		throw new Error("jupiter trigger did not return a cancel withdrawal transaction");
-	}
-	const inspection = await inspectSerializedSolanaSwapTransaction({
-		serializedTxBase64: transaction,
-		expectedSigner: params.walletAddress,
-		rpcUrl: params.rpcUrl
-	});
-	if (!inspection.ok) {
-		throw new Error(inspection.message);
+	if (existing) {
+		const intent = existing.details?.semanticIntent;
+		if (!isStoredTriggerIntent(intent, "cancel") || intent.jupiter.owner !== params.walletAddress || intent.jupiter.trigger?.order !== orderId) {
+			throw new Error("Jupiter Trigger intentId is already bound to different immutable terms");
+		}
+		if (mode === "reviewed") {
+			const review = await prepareReviewedTrigger({
+				provider: params.provider,
+				walletId: params.walletId,
+				requestId,
+				entry: existing,
+				intent,
+				env
+			});
+			return {
+				ok: true,
+				mode,
+				review,
+				intent
+			};
+		}
+		const executed = await executeAutonomousTrigger({
+			provider: params.provider,
+			walletId: params.walletId,
+			requestId,
+			entry: existing,
+			intent,
+			action: "cancel",
+			env
+		});
+		return {
+			ok: true,
+			mode,
+			...executed
+		};
 	}
-	if (inspection.routeProgramIds.length > 0) {
-		throw new Error(`jupiter trigger cancel uses unexpected program ${inspection.routeProgramIds[0]}`);
+	if (!params.provider.listJupiterTriggerOrders) {
+		throw new Error("Jupiter Trigger cancel requires signer-owned sanitized order history and exact refund terms");
 	}
-	const signed = await signSerializedSolanaTx({
-		provider: params.provider,
+	const history = await params.provider.listJupiterTriggerOrders({
 		walletId: params.walletId,
-		serializedTxBase64: transaction,
-		amount: "0"
+		state: "active"
 	});
-	const raw = await triggerJson({
-		path: `/orders/price/confirm-cancel/${encodeURIComponent(orderId)}`,
-		method: "POST",
-		apiKey,
-		token,
-		body: {
-			signedTransaction: signed.signedTxBase64,
-			cancelRequestId
+	const order = history.orders.find((candidate) => candidate.orderId === orderId);
+	if (!order || order.orderType !== "single" || order.orderState !== "open" || !order.cancel) {
+		throw new Error("Jupiter Trigger order is not an exact open cancellable single order");
+	}
+	const refundAmount = positiveBaseUnits(order.cancel.refundAmount, "Trigger refund amount");
+	const bound = await bindTriggerIntent({
+		kind: "jupiter-trigger-cancel",
+		action: "cancel",
+		mode,
+		walletId: params.walletId,
+		intentId,
+		callerIntent: {
+			owner: params.walletAddress,
+			orderId,
+			orderState: order.orderState,
+			refundMint: order.cancel.refundMint,
+			refundAmount,
+			destinationTokenAccount: order.cancel.destinationTokenAccount,
+			program: order.cancel.program
 		},
+		buildIntent: async () => ({
+			type: "solana.jupiter.trigger.cancel",
+			jupiter: {
+				owner: params.walletAddress,
+				outputMint: order.cancel?.refundMint,
+				minimumOutputAmount: refundAmount,
+				maxFeeLamports: resolveJupiterMaxFeeLamports(env),
+				destinationTokenAccount: order.cancel?.destinationTokenAccount,
+				programs: [order.cancel?.program ?? ""],
+				trigger: {
+					operation: "cancel",
+					program: order.cancel?.program ?? "",
+					order: order.orderId,
+					expectedOrderState: order.cancel?.expectedOrderState ?? "open"
+				}
+			}
+		}),
+		env
+	});
+	if (mode === "reviewed") {
+		const review = await prepareReviewedTrigger({
+			provider: params.provider,
+			walletId: params.walletId,
+			requestId,
+			entry: bound.entry,
+			intent: bound.intent,
+			env
+		});
+		return {
+			ok: true,
+			mode,
+			review,
+			intent: bound.intent
+		};
+	}
+	const executed = await executeAutonomousTrigger({
+		provider: params.provider,
+		walletId: params.walletId,
+		requestId,
+		entry: bound.entry,
+		intent: bound.intent,
+		action: "cancel",
 		env
 	});
 	return {
 		ok: true,
-		raw,
-		tx: {
-			ok: true,
-			chain: "solana",
-			txHash: stringValue(raw.txSignature) ?? "",
-			signer: params.walletAddress,
-			metadata: {
-				provider: "jupiter-trigger",
-				orderId
-			}
-		}
+		mode,
+		...executed
 	};
 }
-function readJupiterTriggerPositiveNumber(value) {
-	return positiveNumber(value);
-}
 
 //#endregion
 export { cancelJupiterTriggerOrder, createJupiterTriggerLimitOrder, listJupiterTriggerOrders, readJupiterTriggerPositiveNumber, validateJupiterTriggerLimitOrderIntent };