@fased/fased 0.1.61 → 0.1.64

package/dist/gateway/a2a-settlement.js

@@ -1,186 +1,292 @@
-import { loadConfig } from "../config/io.js";
-import "../config/config.js";
-import { resolveWalletRuntimeConfig } from "../wallet/wallet-runtime-config.js";
-import { appendWalletAuditEntry } from "../wallet/wallet-audit-log.js";
-import { createOrExecuteWalletSend } from "../wallet/wallet-send-approvals.js";
+import { isValidSolanaAddress } from "../wallet/solana-address.js";
+import { fetchSolanaRpc } from "../wallet/solana-assets.js";
+import { resolveScopedRpcUrlForWallet } from "../wallet/wallet-provider-resolver.js";
 
 //#region src/gateway/a2a-settlement.ts
+const A2A_PAYMENT_MEMO_PROGRAM = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
 function isRecord(value) {
-	return typeof value === "object" && value !== null;
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function asString(value) {
-	if (typeof value !== "string") {
-		return undefined;
-	}
-	const trimmed = value.trim();
-	return trimmed.length > 0 ? trimmed : undefined;
-}
-function asAmountString(value) {
-	if (typeof value === "number" && Number.isFinite(value)) {
-		return String(value);
-	}
-	return asString(value);
+function stringField(record, field) {
+	return typeof record[field] === "string" ? record[field].trim() : "";
 }
-function normalizeChain(value) {
-	const chain = asString(value)?.toLowerCase();
-	if (chain === "solana") {
-		return "solana";
-	}
-	return null;
+function recordsEqual(left, right) {
+	return JSON.stringify(left) === JSON.stringify(right);
 }
-function normalizeProviderId(value) {
-	const normalized = asString(value)?.toLowerCase();
-	if (normalized === "embedded-keystore" || normalized === "local-socket-signer" || normalized === "alchemy" || normalized === "turnkey" || normalized === "privy") {
-		return normalized;
+function canonicalAsset(value) {
+	if (!isRecord(value)) {
+		return null;
 	}
-	return undefined;
-}
-function pickString(...values) {
-	for (const value of values) {
-		const found = asString(value);
-		if (found) {
-			return found;
-		}
+	const kind = stringField(value, "kind").toLowerCase();
+	if (kind === "native") {
+		return { kind };
 	}
-	return undefined;
-}
-function extractCanonicalProgramAddress(assetValue) {
-	if (!isRecord(assetValue)) {
-		return undefined;
+	const address = stringField(value, "address");
+	if (kind === "spl-token" && isValidSolanaAddress(address)) {
+		return {
+			kind,
+			address
+		};
 	}
-	const kind = asString(assetValue.kind)?.toLowerCase();
-	const address = asString(assetValue.address);
-	return kind === "spl-token" && address ? address : undefined;
+	return null;
 }
-function extractA2aSettlementIntent(taskInput) {
-	if (!isRecord(taskInput)) {
+function canonicalWallet(value) {
+	if (!isRecord(value) || stringField(value, "chain").toLowerCase() !== "solana") {
 		return null;
 	}
-	const invoiceRecord = isRecord(taskInput.invoice) ? taskInput.invoice : null;
-	const paymentRecord = isRecord(taskInput.payment) ? taskInput.payment : isRecord(taskInput.settlement) ? taskInput.settlement : null;
-	const taskWalletRecord = isRecord(taskInput.wallet) ? taskInput.wallet : null;
-	const paymentWalletRecord = isRecord(paymentRecord?.wallet) ? paymentRecord.wallet : null;
-	const invoiceWalletRecord = isRecord(invoiceRecord?.wallet) ? invoiceRecord.wallet : null;
-	const paymentAssetRecord = isRecord(paymentRecord?.asset) ? paymentRecord.asset : null;
-	const invoiceAssetRecord = isRecord(invoiceRecord?.asset) ? invoiceRecord.asset : null;
-	const invoiceId = pickString(taskInput.invoiceId, taskInput.invoiceRef, taskInput.receiptRef, invoiceRecord?.id, invoiceRecord?.invoiceId, invoiceRecord?.invoiceRef, paymentRecord?.invoiceId, paymentRecord?.invoiceRef);
-	const chain = normalizeChain(taskInput.chain ?? paymentRecord?.chain ?? invoiceRecord?.chain ?? taskInput.network);
-	if (!chain) {
+	const address = stringField(value, "address");
+	return isValidSolanaAddress(address) ? {
+		chain: "solana",
+		address
+	} : null;
+}
+function positiveSafeInteger(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : null;
+}
+function offerAmountInBaseUnits(offer) {
+	const amount = offer.pricing.amount;
+	const decimals = offer.paymentDefaults?.assetDecimals;
+	if (typeof amount !== "number" || !Number.isFinite(amount) || amount <= 0 || typeof decimals !== "number" || !Number.isInteger(decimals) || decimals < 0 || decimals > 18) {
 		return null;
 	}
-	const amount = asAmountString(taskInput.amount ?? paymentRecord?.amount ?? invoiceRecord?.amount ?? taskInput.value);
-	if (!amount) {
+	const scaled = amount * 10 ** decimals;
+	const rounded = Math.round(scaled);
+	return Number.isSafeInteger(rounded) && Math.abs(scaled - rounded) < 1e-6 ? rounded : null;
+}
+function parseTimestamp(value) {
+	if (typeof value !== "string" || !value.trim()) {
 		return null;
 	}
-	const providerId = normalizeProviderId(taskInput.providerId ?? taskInput.walletProvider ?? paymentRecord?.providerId ?? paymentRecord?.walletProvider ?? invoiceRecord?.providerId);
-	const walletId = pickString(taskInput.walletId, taskWalletRecord?.id, paymentRecord?.walletId, paymentWalletRecord?.id, invoiceRecord?.walletId);
-	const walletName = pickString(taskInput.walletName, taskInput.wallet, taskWalletRecord?.name, paymentRecord?.walletName, paymentRecord?.wallet, paymentWalletRecord?.name, invoiceRecord?.walletName, invoiceWalletRecord?.name);
-	const payload = {
-		chain,
-		to: pickString(taskInput.to, paymentRecord?.to, paymentRecord?.recipient, invoiceRecord?.to),
-		amount,
-		program: pickString(taskInput.program, paymentRecord?.program, invoiceRecord?.program, extractCanonicalProgramAddress(paymentAssetRecord), extractCanonicalProgramAddress(invoiceAssetRecord)),
-		memo: pickString(taskInput.memo, paymentRecord?.memo, invoiceId),
-		providerId,
-		walletId,
-		walletName
-	};
-	return {
-		payload,
-		invoiceId
-	};
+	const parsed = Date.parse(value);
+	return Number.isFinite(parsed) ? parsed : null;
+}
+function accountKeyStrings(transaction) {
+	return (transaction.transaction?.message?.accountKeys ?? []).map((key) => typeof key === "string" ? key : String(key.pubkey ?? ""));
+}
+function parsedInstructions(transaction) {
+	return [...transaction.transaction?.message?.instructions ?? [], ...(transaction.meta?.innerInstructions ?? []).flatMap((entry) => entry.instructions ?? [])];
+}
+function hasExactNativeTransfer(params) {
+	return parsedInstructions(params.transaction).some((instruction) => {
+		const parsed = isRecord(instruction.parsed) ? instruction.parsed : null;
+		if (instruction.program !== "system" || parsed?.type !== "transfer") {
+			return false;
+		}
+		const info = isRecord(parsed.info) ? parsed.info : null;
+		return info?.source === params.payer && info?.destination === params.payee && positiveSafeInteger(info?.lamports) === params.amount;
+	});
+}
+function balanceAmount(entry) {
+	const value = entry?.uiTokenAmount?.amount;
+	return typeof value === "string" && /^\d+$/u.test(value) ? BigInt(value) : 0n;
+}
+function tokenBalanceFor(params) {
+	return params.balances.find((entry) => entry.accountIndex === params.accountIndex && entry.mint === params.mint && entry.owner === params.owner);
+}
+function hasExactTokenTransfer(params) {
+	const keys = accountKeyStrings(params.transaction);
+	const pre = params.transaction.meta?.preTokenBalances ?? [];
+	const post = params.transaction.meta?.postTokenBalances ?? [];
+	const expected = BigInt(params.amount);
+	return parsedInstructions(params.transaction).some((instruction) => {
+		if (instruction.program !== "spl-token") {
+			return false;
+		}
+		const parsed = isRecord(instruction.parsed) ? instruction.parsed : null;
+		const parsedType = parsed?.type;
+		if (parsedType !== "transfer" && parsedType !== "transferChecked") {
+			return false;
+		}
+		const info = isRecord(parsed?.info) ? parsed.info : null;
+		if (!info || info.authority !== params.payer) {
+			return false;
+		}
+		const instructionAmount = positiveSafeInteger(info.amount) ?? (isRecord(info.tokenAmount) ? positiveSafeInteger(Number(info.tokenAmount.amount)) : null);
+		if (instructionAmount !== params.amount) {
+			return false;
+		}
+		const sourceIndex = keys.indexOf(stringField(info, "source"));
+		const destinationIndex = keys.indexOf(stringField(info, "destination"));
+		if (sourceIndex < 0 || destinationIndex < 0) {
+			return false;
+		}
+		const sourcePre = tokenBalanceFor({
+			balances: pre,
+			accountIndex: sourceIndex,
+			mint: params.mint,
+			owner: params.payer
+		});
+		const sourcePost = tokenBalanceFor({
+			balances: post,
+			accountIndex: sourceIndex,
+			mint: params.mint,
+			owner: params.payer
+		});
+		const destinationPre = tokenBalanceFor({
+			balances: pre,
+			accountIndex: destinationIndex,
+			mint: params.mint,
+			owner: params.payee
+		});
+		const destinationPost = tokenBalanceFor({
+			balances: post,
+			accountIndex: destinationIndex,
+			mint: params.mint,
+			owner: params.payee
+		});
+		return Boolean(sourcePre && sourcePost && destinationPost) && balanceAmount(sourcePre) - balanceAmount(sourcePost) === expected && balanceAmount(destinationPost) - balanceAmount(destinationPre) === expected;
+	});
+}
+function hasExactPaymentMemo(transaction, expected) {
+	return parsedInstructions(transaction).some((instruction) => {
+		const isMemoProgram = instruction.program === "spl-memo" || instruction.programId === A2A_PAYMENT_MEMO_PROGRAM;
+		if (!isMemoProgram) {
+			return false;
+		}
+		if (typeof instruction.parsed === "string") {
+			return instruction.parsed === expected;
+		}
+		const parsed = isRecord(instruction.parsed) ? instruction.parsed : null;
+		return parsed?.memo === expected || parsed?.info === expected;
+	});
 }
 const DEFAULT_DEPS = {
-	loadConfig,
-	resolveWalletRuntimeConfig,
-	createOrExecuteWalletSend
+	fetchSolanaRpc,
+	now: Date.now,
+	resolveRpcUrl: (env) => resolveScopedRpcUrlForWallet({
+		env,
+		chains: ["solana"]
+	})
 };
 async function orchestrateA2aTaskSettlement(params) {
 	const deps = {
 		...DEFAULT_DEPS,
 		...params.deps
 	};
-	const intent = extractA2aSettlementIntent(params.taskInput);
-	if (!intent) {
-		return {
-			status: "skipped",
-			reason: "no settlement intent fields (requires chain + amount for paid-task settlement)"
-		};
+	const env = params.env ?? process.env;
+	const task = isRecord(params.taskInput) ? params.taskInput : null;
+	const invoice = isRecord(params.invoice) ? params.invoice : null;
+	const receipt = isRecord(params.receipt) ? params.receipt : null;
+	const offer = params.offer;
+	const fail = (reason) => ({
+		status: "failed",
+		reason
+	});
+	const challenge = params.challenge;
+	if (!task || !invoice || !receipt || !offer || !offer.paymentDefaults || !challenge) {
+		return fail("paid task requires a seller-issued challenge, known offer, and complete invoice and receipt evidence");
 	}
-	const cfg = deps.loadConfig();
-	const walletCfg = deps.resolveWalletRuntimeConfig(cfg, params.env ?? process.env);
-	if (!walletCfg.enabled) {
-		return {
-			status: "skipped",
-			invoiceId: intent.invoiceId,
-			providerId: intent.payload.providerId,
-			walletId: intent.payload.walletId,
-			walletName: intent.payload.walletName,
-			chain: intent.payload.chain,
-			amount: intent.payload.amount,
-			reason: "wallet is disabled"
-		};
+	if (stringField(task, "taskId") !== params.taskId) {
+		return fail("task.taskId must match the durable task identity");
 	}
-	const send = await deps.createOrExecuteWalletSend({
-		payload: intent.payload,
-		requestedBy: params.actor?.trim() || "a2a-settlement",
-		sendPath: "automation",
-		settlementContext: {
-			taskId: params.taskId,
-			invoiceId: intent.invoiceId,
-			senderHandle: params.senderHandle
-		},
-		config: walletCfg,
-		env: params.env
-	});
-	if (!send.ok) {
-		appendWalletAuditEntry({
-			action: "send_failed",
-			actor: params.actor?.trim() || "a2a-settlement",
-			details: {
-				taskId: params.taskId,
-				invoiceId: intent.invoiceId,
-				senderHandle: params.senderHandle,
-				reason: send.message
-			},
-			env: params.env
-		});
-		return {
-			status: "failed",
-			invoiceId: intent.invoiceId,
-			providerId: intent.payload.providerId,
-			walletId: intent.payload.walletId,
-			walletName: intent.payload.walletName,
-			chain: intent.payload.chain,
-			amount: intent.payload.amount,
-			reason: send.message,
-			requestId: send.requestId
-		};
+	const offerIds = [
+		task,
+		invoice,
+		receipt
+	].map((entry) => stringField(entry, "offerId"));
+	if (offerIds.some((value) => value !== offer.id)) {
+		return fail("task, invoice, and receipt must bind the exact seller offerId");
 	}
-	if (send.mode === "manual") {
-		return {
-			status: "queued",
-			mode: "manual",
-			requestId: send.request.id,
-			invoiceId: intent.invoiceId,
-			providerId: intent.payload.providerId,
-			walletId: intent.payload.walletId,
-			walletName: intent.payload.walletName,
-			chain: intent.payload.chain,
-			amount: intent.payload.amount
-		};
+	const invoiceId = stringField(invoice, "invoiceId");
+	const receiptId = stringField(receipt, "receiptId");
+	if (!invoiceId || !receiptId || stringField(task, "invoice") !== invoiceId || stringField(task, "receipt") !== receiptId || stringField(receipt, "invoiceId") !== invoiceId || stringField(invoice, "taskId") !== params.taskId || stringField(receipt, "taskId") !== params.taskId) {
+		return fail("invoice and receipt identities are not bound to the task");
+	}
+	if (challenge.taskId !== params.taskId || challenge.senderHandle !== params.senderHandle.trim().toLowerCase() || challenge.offerId !== offer.id || challenge.invoiceId !== invoiceId || challenge.receiptId !== receiptId || challenge.challengeId !== stringField(invoice, "challengeId") || challenge.challengeId !== stringField(receipt, "challengeId") || challenge.paymentMemo !== stringField(invoice, "paymentMemo") || challenge.paymentMemo !== stringField(receipt, "paymentMemo")) {
+		return fail("payment evidence does not match the seller-issued challenge");
+	}
+	const expectedAmount = offerAmountInBaseUnits(offer);
+	if (!expectedAmount) {
+		return fail("seller offer must define a positive fixed price before paid execution");
+	}
+	const invoiceAmount = positiveSafeInteger(invoice.amount);
+	const receiptAmount = positiveSafeInteger(receipt.amount);
+	if (invoiceAmount !== expectedAmount || receiptAmount !== expectedAmount) {
+		return fail("invoice and receipt amount must equal the seller offer price");
+	}
+	if (challenge.amount !== expectedAmount) {
+		return fail("seller-issued challenge amount no longer matches the offer");
+	}
+	const expectedCurrency = offer.paymentDefaults.currency.trim().toUpperCase();
+	if (stringField(invoice, "currency").toUpperCase() !== expectedCurrency || stringField(receipt, "currency").toUpperCase() !== expectedCurrency || stringField(invoice, "chain").toLowerCase() !== "solana" || stringField(receipt, "chain").toLowerCase() !== "solana") {
+		return fail("invoice and receipt payment rail does not match the seller offer");
+	}
+	if (challenge.currency !== expectedCurrency) {
+		return fail("seller-issued challenge currency no longer matches the offer");
+	}
+	const expectedAsset = canonicalAsset(offer.paymentDefaults.asset);
+	const invoiceAsset = canonicalAsset(invoice.asset);
+	const receiptAsset = canonicalAsset(receipt.asset);
+	if (!expectedAsset || !recordsEqual(invoiceAsset, expectedAsset) || !recordsEqual(receiptAsset, expectedAsset)) {
+		return fail("invoice and receipt asset does not match the seller offer");
+	}
+	if (!recordsEqual(challenge.asset, expectedAsset)) {
+		return fail("seller-issued challenge asset no longer matches the offer");
+	}
+	const expectedPayee = canonicalWallet(offer.paymentDefaults.payee);
+	const invoicePayee = canonicalWallet(invoice.payee);
+	const receiptPayee = canonicalWallet(receipt.payee);
+	const payer = canonicalWallet(receipt.payer);
+	if (!expectedPayee || !payer || !recordsEqual(invoicePayee, expectedPayee) || !recordsEqual(receiptPayee, expectedPayee) || payer.address === expectedPayee.address) {
+		return fail("invoice or receipt payer/payee is invalid");
+	}
+	if (challenge.payerAddress !== payer.address || challenge.payeeAddress !== expectedPayee.address) {
+		return fail("payment payer/payee does not match the seller-issued challenge");
+	}
+	const issuedAt = parseTimestamp(invoice.issuedAt);
+	const expiresAt = parseTimestamp(invoice.expiresAt);
+	const settledAt = parseTimestamp(receipt.settledAt);
+	const now = deps.now();
+	if (issuedAt === null || expiresAt === null || settledAt === null || issuedAt !== Date.parse(challenge.issuedAt) || expiresAt !== Date.parse(challenge.expiresAt) || issuedAt >= expiresAt || settledAt < issuedAt || settledAt > expiresAt || now > expiresAt) {
+		return fail("invoice or receipt timestamp is invalid or expired");
+	}
+	const txRef = stringField(receipt, "txRef");
+	if (!/^[1-9A-HJ-NP-Za-km-z]{80,100}$/u.test(txRef)) {
+		return fail("receipt.txRef must be a Solana transaction signature");
+	}
+	const rpcUrl = deps.resolveRpcUrl(env);
+	if (!rpcUrl) {
+		return fail("seller Solana RPC is not configured; payment cannot be verified");
+	}
+	const transaction = await deps.fetchSolanaRpc(rpcUrl, "getTransaction", [txRef, {
+		commitment: "finalized",
+		encoding: "jsonParsed",
+		maxSupportedTransactionVersion: 0
+	}]);
+	if (!transaction || !transaction.meta || transaction.meta.err != null) {
+		return fail("payment transaction is unavailable, not finalized, or failed");
+	}
+	const blockTimeMs = typeof transaction.blockTime === "number" && Number.isSafeInteger(transaction.blockTime) ? transaction.blockTime * 1e3 : null;
+	if (blockTimeMs === null || blockTimeMs < issuedAt || blockTimeMs > expiresAt || blockTimeMs > now + 6e4) {
+		return fail("finalized payment block time is outside the seller-issued challenge window");
+	}
+	if (!hasExactPaymentMemo(transaction, challenge.paymentMemo)) {
+		return fail("finalized payment does not contain the exact seller-issued challenge memo");
+	}
+	const paymentMatches = expectedAsset.kind === "native" ? hasExactNativeTransfer({
+		transaction,
+		payer: payer.address,
+		payee: expectedPayee.address,
+		amount: expectedAmount
+	}) : hasExactTokenTransfer({
+		transaction,
+		payer: payer.address,
+		payee: expectedPayee.address,
+		mint: expectedAsset.address,
+		amount: expectedAmount
+	});
+	if (!paymentMatches) {
+		return fail("finalized transaction does not contain the exact expected seller payment");
 	}
 	return {
 		status: "executed",
-		mode: "autonomous",
-		requestId: send.requestId,
-		txHash: send.tx.txHash,
-		invoiceId: intent.invoiceId,
-		providerId: intent.payload.providerId,
-		walletId: intent.payload.walletId,
-		walletName: intent.payload.walletName,
-		chain: intent.payload.chain,
-		amount: intent.payload.amount
+		txHash: txRef,
+		invoiceId,
+		chain: "solana",
+		amount: String(expectedAmount),
+		challengeId: challenge.challengeId,
+		payerAddress: payer.address,
+		paymentMemo: challenge.paymentMemo
 	};
 }