@fased/fased 0.1.61 → 0.1.64

package/dist/wallet/native-signer-wallet-id.js

@@ -0,0 +1,25 @@
+//#region src/wallet/native-signer-wallet-id.ts
+function normalizeNativeSignerWalletId(value) {
+	const normalized = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+	return normalized || "default";
+}
+function resolveNativeSignerWalletId(wallet) {
+	if (wallet.providerId !== "local-socket-signer") {
+		throw new Error(`wallet ${wallet.id} is not owned by the native signer`);
+	}
+	const recorded = typeof wallet.metadata?.signerWalletId === "string" ? wallet.metadata.signerWalletId.trim() : "";
+	if (recorded) {
+		if (recorded.length > 64 || normalizeNativeSignerWalletId(recorded) !== recorded) {
+			throw new Error(`wallet ${wallet.id} has a non-canonical native signer wallet ID`);
+		}
+		return recorded;
+	}
+	const fallback = normalizeNativeSignerWalletId(wallet.id);
+	if (fallback.length > 64) {
+		throw new Error(`wallet ${wallet.id} has an overlong native signer wallet ID`);
+	}
+	return fallback;
+}
+
+//#endregion
+export { normalizeNativeSignerWalletId, resolveNativeSignerWalletId };

package/dist/wallet/providers/alchemy-adapter.js

@@ -18,6 +18,9 @@ var AlchemyAdapter = class {
 			supportsRotateKeys: false,
 			supportsResetKeys: false,
 			supportsPasskeyGate: false,
+			signingLocation: "unavailable",
+			supportsSignTransaction: false,
+			supportsSignMessage: false,
 			supportedExecutionModes: ["manual"],
 			supportedChains: chains
 		};

package/dist/wallet/providers/local-socket-signer-adapter.js

@@ -1,27 +1,38 @@
 import { ensureWalletStateDir } from "../wallet-runtime-config.js";
-import { fetchSolanaMintInfoViaRpc } from "../solana-assets.js";
 import { WalletProviderError } from "../wallet-provider-adapter.js";
-import { buildCreateAssociatedTokenAccountIdempotentInstruction, buildTransferCheckedInstruction, deriveAssociatedTokenAddress } from "../solana-spl-transfer.js";
+import { LOCAL_SIGNER_NATIVE_FEE_RESERVATION_LAMPORTS_V2, parseLocalSocketSignerRequest, parseLocalSocketSignerResponseEnvelope, validateLocalSocketSignerResult } from "../local-socket-signer-protocol.js";
+import { SIGNER_PROTOCOL_V2_REQUIRED_CLIENT_FEATURES } from "../signer-protocol-v2.generated.js";
 import { redactWalletDiagnosticText, walletDiagnosticErrorMessage, walletDiagnosticErrorString } from "../wallet-redaction.js";
-import { parseLocalSocketSignerResponseEnvelope, validateLocalSocketSignerResult } from "../local-socket-signer-protocol.js";
-import fs from "node:fs";
+import syncFs from "node:fs";
 import path from "node:path";
 import net from "node:net";
 
 //#region src/wallet/providers/local-socket-signer-adapter.ts
+const SOLANA_TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
 const MAX_SIGNER_RESPONSE_BYTES = 1 << 20;
+const REQUIRED_PROTOCOL_V2_FEATURES = SIGNER_PROTOCOL_V2_REQUIRED_CLIENT_FEATURES;
 const SIGNER_SOCKET_TIMEOUT_MS = {
 	health: 2e3,
+	"v2.capabilities": 2e3,
+	"v2.jupiter.trigger.history": 3e4,
+	"v2.policy.get": 5e3,
+	"v2.policy.put": 5e3,
+	"v2.policy.tighten": 5e3,
+	"v2.wallet.get": 5e3,
+	"v2.wallet.create": 1e4,
+	"v2.wallet.import": 2e4,
+	"v2.wallet.importLegacy": 3e4,
+	"v2.wallet.reencrypt": 1e4,
+	"v2.execute": 12e4,
+	"v2.review.get": 5e3,
+	"v2.review.prepare": 15e3,
+	"v2.review.execute": 12e4,
+	"v2.review.authorization.begin": 15e3,
+	"v2.review.authorization.finish": 3e4,
+	"v2.operation.get": 5e3,
+	"v2.operation.reconcile": 2e4,
 	getAddresses: 1e4,
-	getBalance: 15e3,
-	prepareTx: 15e3,
-	signTx: 2e4,
-	sendTx: 12e4,
-	sendSolanaInstruction: 12e4,
-	sendSolanaInstructions: 12e4,
-	custodyStatus: 5e3,
-	unlockCustody: 1e4,
-	lockCustody: 1e4
+	getBalance: 15e3
 };
 function signerTimeoutFor(payload) {
 	return SIGNER_SOCKET_TIMEOUT_MS[payload.op] ?? 3e4;
@@ -29,7 +40,7 @@ function signerTimeoutFor(payload) {
 function assertSecureLocalSignerSocket(socketPath) {
 	let stat;
 	try {
-		stat = fs.lstatSync(socketPath);
+		stat = syncFs.lstatSync(socketPath);
 	} catch (err) {
 		throw new WalletProviderError({
 			code: "wallet_provider_unavailable",
@@ -68,12 +79,13 @@ function assertSecureLocalSignerSocket(socketPath) {
 	}
 }
 async function callSocket(socketPath, payload, options) {
+	const checkedPayload = parseLocalSocketSignerRequest(payload);
 	return await new Promise((resolve, reject) => {
 		const socket = net.createConnection(socketPath);
 		let buf = "";
 		let settled = false;
 		const maxResponseBytes = options?.maxResponseBytes ?? MAX_SIGNER_RESPONSE_BYTES;
-		const timeoutMs = options?.timeoutMs ?? signerTimeoutFor(payload);
+		const timeoutMs = options?.timeoutMs ?? signerTimeoutFor(checkedPayload);
 		const finish = (err, value) => {
 			if (settled) {
 				return;
@@ -92,11 +104,11 @@ async function callSocket(socketPath, payload, options) {
 		};
 		const timer = setTimeout(() => {
 			socket.destroy();
-			finish(new Error(`local socket signer timeout after ${timeoutMs}ms for op=${payload.op}`));
+			finish(new Error(`local socket signer timeout after ${timeoutMs}ms for op=${checkedPayload.op}`));
 		}, timeoutMs);
 		socket.setEncoding("utf8");
 		socket.on("connect", () => {
-			socket.write(`${JSON.stringify(payload)}\n`);
+			socket.write(`${JSON.stringify(checkedPayload)}\n`);
 		});
 		socket.on("data", (chunk) => {
 			buf += chunk;
@@ -116,8 +128,8 @@ async function callSocket(socketPath, payload, options) {
 					finish(new Error(parsed.error || "local socket signer error"));
 					return;
 				}
-				if (!validateLocalSocketSignerResult(payload.op, parsed.result)) {
-					finish(new Error(`invalid local socket signer result for op=${payload.op}`));
+				if (!validateLocalSocketSignerResult(checkedPayload.op, parsed.result)) {
+					finish(new Error(`invalid local socket signer result for op=${checkedPayload.op}`));
 					return;
 				}
 				finish(undefined, parsed.result);
@@ -139,7 +151,17 @@ async function probeLocalSocketSignerHealth(socketPath) {
 			details: result?.details ? redactWalletDiagnosticText(result.details) : undefined,
 			readOnly: result?.readOnly,
 			keystoreType: result?.keystoreType,
-			chains: Array.isArray(result?.chains) ? result.chains : undefined
+			chains: Array.isArray(result?.chains) ? result.chains : undefined,
+			ready: result?.ready,
+			release: result?.release,
+			schema: result?.schema,
+			network: result?.network,
+			capabilities: result?.capabilities,
+			policies: result?.policies,
+			webAuthn: result?.webAuthn,
+			jupiter: result?.jupiter,
+			audit: result?.audit,
+			state: result?.state
 		};
 	} catch (err) {
 		return {
@@ -148,6 +170,24 @@ async function probeLocalSocketSignerHealth(socketPath) {
 		};
 	}
 }
+async function requireLocalSocketSignerProtocolV2(socketPath, intentType) {
+	const result = await callSocket(socketPath, { op: "v2.capabilities" });
+	const capabilities = result.capabilities;
+	const protocol = capabilities?.protocol;
+	const missingFeatures = REQUIRED_PROTOCOL_V2_FEATURES.filter((feature) => !capabilities?.features.includes(feature));
+	const intentReviewFeatures = intentType === "solana.vaultBondAction" ? [
+		"reviewedVaultBondActions",
+		"signerOwnedStateRecheck",
+		"durableReviewAuthorization"
+	] : intentType === "federation.bondChallenge" ? ["reviewedFederationBondChallenges", "durableReviewAuthorization"] : [];
+	const missingIntentFeatures = intentReviewFeatures.filter((feature) => !capabilities?.features.includes(feature));
+	if (result.ready !== true || !protocol || protocol.current !== 2 || protocol.min > 2 || protocol.max < 2 || capabilities.nativeFeeReservationLamports !== LOCAL_SIGNER_NATIVE_FEE_RESERVATION_LAMPORTS_V2 || missingFeatures.length > 0 || missingIntentFeatures.length > 0 || intentType && !capabilities?.intentTypes.includes(intentType)) {
+		throw new WalletProviderError({
+			code: "wallet_provider_unavailable",
+			message: `local-socket-signer protocol-v2 capability negotiation failed${missingFeatures.length > 0 ? `; missing ${missingFeatures.join(",")}` : ""}${missingIntentFeatures.length > 0 ? `; missing intent features ${missingIntentFeatures.join(",")}` : ""}${intentType && !capabilities?.intentTypes.includes(intentType) ? `; unsupported intent ${intentType}` : ""}`
+		});
+	}
+}
 var LocalSocketSignerAdapter = class {
 	constructor(socketPath, options) {
 		this.socketPath = socketPath;
@@ -157,11 +197,14 @@ var LocalSocketSignerAdapter = class {
 		this.capabilities = {
 			custodyModel: "self-hosted",
 			supportsCreateWallet: false,
-			supportsPrepare: true,
+			supportsPrepare: false,
 			supportsSend: true,
 			supportsRotateKeys: false,
 			supportsResetKeys: false,
 			supportsPasskeyGate: false,
+			signingLocation: "server",
+			supportsSignTransaction: false,
+			supportsSignMessage: false,
 			supportedExecutionModes: ["manual", "autonomous"],
 			supportedChains: ["solana"]
 		};
@@ -169,6 +212,9 @@ var LocalSocketSignerAdapter = class {
 	supportsChain(chain) {
 		return this.capabilities.supportedChains.includes(chain);
 	}
+	async requireProtocolV2(intentType) {
+		await requireLocalSocketSignerProtocolV2(this.socketPath, intentType);
+	}
 	async health() {
 		try {
 			const details = await probeLocalSocketSignerHealth(this.socketPath);
@@ -180,10 +226,15 @@ var LocalSocketSignerAdapter = class {
 				provider: this.id,
 				configured: true,
 				checkedAt: new Date().toISOString(),
-				details: details?.details ?? [
-					details?.readOnly ? "read-only" : "read-write",
-					details?.keystoreType ? `keystore=${details.keystoreType}` : "",
-					Array.isArray(details?.chains) ? `chains=${details.chains.join(",")}` : ""
+				details: [
+					details?.details ?? "",
+					...!details?.details ? [
+						details?.readOnly ? "read-only" : "read-write",
+						details?.keystoreType ? `keystore=${details.keystoreType}` : "",
+						Array.isArray(details?.chains) ? `chains=${details.chains.join(",")}` : ""
+					] : [],
+					details?.jupiter ? `jupiter-trigger=${details.jupiter.triggerConfigured ? "configured" : "not-configured"} jupiter-live=${details.jupiter.liveEnabled === true ? "enabled" : "preview-only"}` : "",
+					...details?.state?.capacityWarnings ?? []
 				].filter(Boolean).join(" ")
 			};
 		} catch (err) {
@@ -198,127 +249,351 @@ var LocalSocketSignerAdapter = class {
 	}
 	async getAddresses(options) {
 		const walletId = options?.walletId?.trim() || this.options?.scopedWalletId?.trim();
-		return await callSocket(this.socketPath, {
-			op: "getAddresses",
-			...walletId ? { walletId } : {}
-		});
-	}
-	async getBalance(chain, options) {
-		const walletId = options?.walletId?.trim() || this.options?.scopedWalletId?.trim();
-		return await callSocket(this.socketPath, {
-			op: "getBalance",
-			chain,
-			...walletId ? { walletId } : {}
+		if (!walletId) {
+			throw new WalletProviderError({
+				code: "wallet_provider_invalid_config",
+				message: "local-socket-signer requires an explicit walletId"
+			});
+		}
+		await this.requireProtocolV2();
+		const wallet = await callSocket(this.socketPath, {
+			op: "v2.wallet.get",
+			walletId
 		});
+		return { solana: wallet.publicKey };
 	}
-	async prepareTx(request) {
+	async getSignerPolicy(walletIdRaw) {
+		const walletId = walletIdRaw.trim();
+		if (!walletId) {
+			throw new WalletProviderError({
+				code: "wallet_provider_invalid_config",
+				message: "local-socket-signer policy lookup requires an explicit walletId"
+			});
+		}
+		assertSecureLocalSignerSocket(this.socketPath);
+		await this.requireProtocolV2();
 		return await callSocket(this.socketPath, {
-			op: "prepareTx",
-			request
+			op: "v2.policy.get",
+			walletId
 		});
 	}
-	async sendTx(request) {
+	async tightenSignerPolicy(params) {
+		const walletId = params.walletId.trim();
+		if (!walletId || !Number.isSafeInteger(params.expectedVersion) || params.expectedVersion < 1) {
+			throw new WalletProviderError({
+				code: "wallet_provider_invalid_config",
+				message: "local-socket-signer policy tightening requires a walletId and positive expected version"
+			});
+		}
 		assertSecureLocalSignerSocket(this.socketPath);
-		if (request.chain === "solana" && request.program?.trim()) {
-			return await this.sendSplTokenTx(request);
+		await this.requireProtocolV2();
+		const acknowledged = await callSocket(this.socketPath, {
+			op: "v2.policy.tighten",
+			walletId,
+			request: {
+				expectedVersion: params.expectedVersion,
+				policy: params.policy
+			}
+		});
+		if (acknowledged.walletId !== walletId || acknowledged.role !== params.policy.role || acknowledged.version !== params.expectedVersion + 1) {
+			throw new WalletProviderError({
+				code: "wallet_provider_unavailable",
+				message: "local-socket-signer did not acknowledge the exact next policy version and wallet role",
+				retryable: false
+			});
 		}
-		return await callSocket(this.socketPath, {
-			op: "sendTx",
-			request
+		const durable = await callSocket(this.socketPath, {
+			op: "v2.policy.get",
+			walletId
 		});
+		if (JSON.stringify(durable) !== JSON.stringify(acknowledged)) {
+			throw new WalletProviderError({
+				code: "wallet_provider_unavailable",
+				message: "local-socket-signer policy acknowledgement does not match durable signer state",
+				retryable: false
+			});
+		}
+		return acknowledged;
 	}
-	async signTx(request) {
+	async getBalance(chain, options) {
+		if (chain !== "solana") {
+			throw new WalletProviderError({
+				code: "wallet_provider_unsupported_chain",
+				message: "local-socket-signer supports Solana only"
+			});
+		}
+		const walletId = options?.walletId?.trim() || this.options?.scopedWalletId?.trim();
+		if (!walletId) {
+			throw new WalletProviderError({
+				code: "wallet_provider_invalid_config",
+				message: "local-socket-signer balance lookup requires an explicit walletId"
+			});
+		}
 		assertSecureLocalSignerSocket(this.socketPath);
+		await this.requireProtocolV2();
 		return await callSocket(this.socketPath, {
-			op: "signTx",
-			request
+			op: "getBalance",
+			chain,
+			walletId
 		});
 	}
-	async sendSplTokenTx(request) {
-		const mint = request.program?.trim();
-		const destinationOwner = request.to?.trim();
-		const amountRaw = request.amount?.trim();
-		if (!mint || !destinationOwner || !amountRaw) {
+	async sendTx(request) {
+		assertSecureLocalSignerSocket(this.socketPath);
+		if (request.chain !== "solana") {
 			throw new WalletProviderError({
-				code: "wallet_provider_invalid_config",
-				message: "local-socket-signer SPL send requires mint, destination, and amount"
+				code: "wallet_provider_unsupported_chain",
+				message: "local-socket-signer supports Solana only"
 			});
 		}
-		const rpcUrl = this.options?.rpcUrl?.trim();
-		if (!rpcUrl) {
+		const untypedSerializedTransaction = request.serializedTxBase64;
+		if (typeof untypedSerializedTransaction === "string" && untypedSerializedTransaction.trim()) {
 			throw new WalletProviderError({
 				code: "wallet_provider_invalid_config",
-				message: "local-socket-signer SPL send requires a Solana RPC URL"
+				message: "local-socket-signer accepts typed SOL/SPL intents, not serialized transactions"
 			});
 		}
-		const walletId = this.options?.scopedWalletId?.trim();
-		const addresses = await this.getAddresses(walletId ? { walletId } : undefined);
-		const authority = addresses.solana?.trim();
-		if (!authority) {
+		const memo = request.memo?.trim();
+		if (memo && !/^fased:a2a-(?:payment|refund):v1:[0-9a-f]{64}$/u.test(memo)) {
 			throw new WalletProviderError({
-				code: "wallet_provider_unavailable",
-				message: "local-socket-signer wallet has no Solana address"
+				code: "wallet_provider_invalid_config",
+				message: "local-socket-signer accepts only typed Fased A2A payment or refund memos"
 			});
 		}
-		const mintInfo = await fetchSolanaMintInfoViaRpc({
-			rpcUrl,
-			mint
+		return await this.executeTypedTransfer(request);
+	}
+	async prepareJupiterReview(request) {
+		return await this.prepareSignerReview(request);
+	}
+	async getSignerReview(request) {
+		assertSecureLocalSignerSocket(this.socketPath);
+		await this.requireProtocolV2();
+		return await callSocket(this.socketPath, {
+			op: "v2.review.get",
+			walletId: request.walletId,
+			request: { requestId: request.requestId }
 		});
-		if (!mintInfo) {
+	}
+	async prepareSignerReview(request) {
+		assertSecureLocalSignerSocket(this.socketPath);
+		await this.requireProtocolV2(request.intent.type);
+		const policy = await callSocket(this.socketPath, {
+			op: "v2.policy.get",
+			walletId: request.walletId
+		});
+		return await callSocket(this.socketPath, {
+			op: "v2.review.prepare",
+			walletId: request.walletId,
+			request: {
+				requestId: request.requestId,
+				policyHash: policy.hash,
+				mode: request.mode,
+				intent: request.intent,
+				...request.transaction ? { transaction: request.transaction } : {}
+			}
+		});
+	}
+	async executeJupiterReview(request) {
+		return await this.executeSignerReview(request);
+	}
+	async executeSignerIntent(request) {
+		assertSecureLocalSignerSocket(this.socketPath);
+		await this.requireProtocolV2(request.intent.type);
+		const policy = await callSocket(this.socketPath, {
+			op: "v2.policy.get",
+			walletId: request.walletId
+		});
+		return await callSocket(this.socketPath, {
+			op: "v2.execute",
+			walletId: request.walletId,
+			request: {
+				requestId: request.requestId,
+				policyHash: policy.hash,
+				intent: request.intent
+			}
+		});
+	}
+	async listJupiterTriggerOrders(request) {
+		assertSecureLocalSignerSocket(this.socketPath);
+		await this.requireProtocolV2();
+		const history = await callSocket(this.socketPath, {
+			op: "v2.jupiter.trigger.history",
+			walletId: request.walletId
+		});
+		const orders = request.state ? history.orders.filter((order) => request.state === "active" ? order.orderState === "open" : order.orderState !== "open") : history.orders;
+		return { orders };
+	}
+	async prepareTypedTransferReview(request) {
+		assertSecureLocalSignerSocket(this.socketPath);
+		const mint = request.mint?.trim();
+		const memo = request.memo?.trim();
+		if (memo && !/^fased:a2a-(?:payment|refund):v1:[0-9a-f]{64}$/u.test(memo)) {
 			throw new WalletProviderError({
-				code: "wallet_provider_unavailable",
-				message: "failed to resolve SPL mint metadata from Solana RPC"
+				code: "wallet_provider_invalid_config",
+				message: "local-socket-signer accepts only typed Fased A2A payment or refund memos"
 			});
 		}
-		const sourceTokenAccount = await deriveAssociatedTokenAddress({
-			owner: authority,
-			mint,
-			tokenProgramId: mintInfo.tokenProgramId
+		let intent;
+		if (mint) {
+			intent = {
+				type: "solana.splTransferChecked",
+				tokenProgram: request.tokenProgram?.trim() || SOLANA_TOKEN_PROGRAM_ID,
+				mint,
+				destination: request.destination,
+				amount: request.amount,
+				...memo ? { memo } : {}
+			};
+		} else {
+			intent = {
+				type: "solana.nativeTransfer",
+				destination: request.destination,
+				lamports: request.amount,
+				...memo ? { memo } : {}
+			};
+		}
+		await this.requireProtocolV2(intent.type);
+		const policy = await callSocket(this.socketPath, {
+			op: "v2.policy.get",
+			walletId: request.walletId
 		});
-		const destinationTokenAccount = await deriveAssociatedTokenAddress({
-			owner: destinationOwner,
-			mint,
-			tokenProgramId: mintInfo.tokenProgramId
+		return await callSocket(this.socketPath, {
+			op: "v2.review.prepare",
+			walletId: request.walletId,
+			request: {
+				requestId: request.requestId,
+				policyHash: policy.hash,
+				mode: "reviewed",
+				intent
+			}
 		});
-		const createAta = await buildCreateAssociatedTokenAccountIdempotentInstruction({
-			payer: authority,
-			owner: destinationOwner,
-			mint,
-			tokenProgramId: mintInfo.tokenProgramId
+	}
+	async executeSignerReview(request) {
+		assertSecureLocalSignerSocket(this.socketPath);
+		await this.requireProtocolV2();
+		return await callSocket(this.socketPath, {
+			op: "v2.review.execute",
+			walletId: request.walletId,
+			request: {
+				requestId: request.requestId,
+				...request.authorization ? { authorization: request.authorization } : {}
+			}
 		});
-		const transfer = buildTransferCheckedInstruction({
-			sourceTokenAccount,
-			mint,
-			destinationTokenAccount,
-			authority,
-			amountRaw,
-			decimals: mintInfo.decimals,
-			tokenProgramId: mintInfo.tokenProgramId
+	}
+	async beginJupiterReviewAuthorization(request) {
+		return await this.beginSignerReviewAuthorization(request);
+	}
+	async beginSignerReviewAuthorization(request) {
+		assertSecureLocalSignerSocket(this.socketPath);
+		await this.requireProtocolV2();
+		return await callSocket(this.socketPath, {
+			op: "v2.review.authorization.begin",
+			walletId: request.walletId,
+			request: { requestId: request.requestId }
 		});
-		const preTx = await this.sendSolanaInstruction({
-			walletId,
-			...createAta
+	}
+	async finishJupiterReviewAuthorization(request) {
+		return await this.finishSignerReviewAuthorization(request);
+	}
+	async getSignerOperation(request) {
+		assertSecureLocalSignerSocket(this.socketPath);
+		await this.requireProtocolV2();
+		return await callSocket(this.socketPath, {
+			op: "v2.operation.get",
+			walletId: request.walletId,
+			request: { requestId: request.requestId }
+		});
+	}
+	async reconcileSignerOperation(request) {
+		assertSecureLocalSignerSocket(this.socketPath);
+		await this.requireProtocolV2();
+		return await callSocket(this.socketPath, {
+			op: "v2.operation.reconcile",
+			walletId: request.walletId,
+			request: { requestId: request.requestId }
+		});
+	}
+	async finishSignerReviewAuthorization(request) {
+		assertSecureLocalSignerSocket(this.socketPath);
+		await this.requireProtocolV2();
+		return await callSocket(this.socketPath, {
+			op: "v2.review.authorization.finish",
+			walletId: request.walletId,
+			request: {
+				challengeId: request.challengeId,
+				credential: request.credential
+			}
 		});
-		const sent = await this.sendSolanaInstruction({
+	}
+	async executeTypedTransfer(request) {
+		const walletId = request.walletId?.trim() || this.options?.scopedWalletId?.trim();
+		const requestId = request.requestId?.trim();
+		const destination = request.to?.trim();
+		const amount = request.amount?.trim();
+		if (!walletId || !requestId || !destination || !amount) {
+			throw new WalletProviderError({
+				code: "wallet_provider_invalid_config",
+				message: "local-socket-signer typed send requires walletId, stable requestId, destination, and raw-unit amount"
+			});
+		}
+		const intentType = request.program?.trim() ? "solana.splTransferChecked" : "solana.nativeTransfer";
+		await this.requireProtocolV2(intentType);
+		const wallet = await callSocket(this.socketPath, {
+			op: "v2.wallet.get",
+			walletId
+		});
+		const policy = await callSocket(this.socketPath, {
+			op: "v2.policy.get",
+			walletId
+		});
+		const mint = request.program?.trim();
+		let intent;
+		if (mint) {
+			intent = {
+				type: "solana.splTransferChecked",
+				destination,
+				mint,
+				amount,
+				...request.memo?.trim() ? { memo: request.memo.trim() } : {}
+			};
+		} else {
+			intent = {
+				type: "solana.nativeTransfer",
+				destination,
+				lamports: amount,
+				...request.memo?.trim() ? { memo: request.memo.trim() } : {}
+			};
+		}
+		const operation = await callSocket(this.socketPath, {
+			op: "v2.execute",
 			walletId,
-			...transfer
+			request: {
+				requestId,
+				policyHash: policy.hash,
+				intent
+			}
 		});
+		if (operation.state !== "confirmed" || !operation.signature) {
+			const ambiguous = operation.state === "broadcast" || operation.state === "unknown";
+			throw new WalletProviderError({
+				code: ambiguous ? "wallet_provider_ambiguous" : "wallet_provider_unavailable",
+				message: ambiguous ? `signer operation ${requestId} has an ambiguous ${operation.state} result; reconcile it before any new attempt` : `signer operation ${requestId} ended in state=${operation.state}${operation.error ? `: ${operation.error}` : ""}`,
+				retryable: false
+			});
+		}
 		return {
-			...sent,
+			ok: true,
+			chain: "solana",
+			txHash: operation.signature,
+			signer: wallet.publicKey,
 			metadata: {
-				...sent.metadata,
 				provider: this.id,
-				associatedTokenTxHash: preTx.txHash
+				requestId: operation.requestId,
+				intentDigest: operation.intentDigest,
+				transactionDigest: operation.transactionDigest,
+				policyHash: operation.policyHash,
+				operationState: operation.state
 			}
 		};
 	}
-	async sendSolanaInstruction(request) {
-		assertSecureLocalSignerSocket(this.socketPath);
-		return await callSocket(this.socketPath, {
-			op: "sendSolanaInstruction",
-			request
-		});
-	}
 };
 function resolveLocalSocketSignerPath(env) {
 	const socketPath = String(env.FASED_WALLET_LOCAL_SIGNER_SOCKET ?? "").trim();
@@ -332,4 +607,4 @@ function requireLocalSocketSignerPath(env) {
 }
 
 //#endregion
-export { LocalSocketSignerAdapter, callLocalSocketSigner, probeLocalSocketSignerHealth, requireLocalSocketSignerPath };
+export { LocalSocketSignerAdapter, assertSecureLocalSignerSocket, callLocalSocketSigner, probeLocalSocketSignerHealth, requireLocalSocketSignerPath };