@panal/sdk 0.18.2 → 0.19.0

package/dist/x402.js

@@ -16,10 +16,16 @@
  * El cliente NO paga gas: solo firma. La transacción la manda quien cobra.
  */
 import { isAddress, getAddress } from 'viem';
+import { estimateGas, waitForTransactionReceipt } from 'viem/actions';
 import { assertPublicUrl, fetchLimited } from './net.js';
 import { envelopeHeaders } from './envelope.js';
-/** El único esquema que entiende este cliente. Debe coincidir con el servidor. */
+import { networkOfChain, x402Currency } from './currencies.js';
+/** El esquema de las monedas con `permit`. Debe coincidir con el servidor. */
 export const X402_SCHEME = 'eip2612-permit';
+/** El de MON, que no tiene `permit`: se manda una transferencia y se presenta. */
+const ESQUEMA_MON = 'native-transfer';
+/** Lo más que puede valer una cotización: una hora. Ver `payAndAsk`. */
+const PLAZO_MAX_S = 60 * 60;
 const PERMIT_TYPES = {
     Permit: [
         { name: 'owner', type: 'address' },
@@ -70,10 +76,10 @@ export async function quoteAsk(endpoint, prompt, options = {}) {
     catch {
         throw new X402Error('La cotización no es JSON válido.');
     }
-    const accept = quote.accepts?.find((a) => a.scheme === X402_SCHEME);
+    const accept = quote.accepts?.find((a) => a.scheme === X402_SCHEME || a.scheme === ESQUEMA_MON);
     if (!accept) {
         const vistos = quote.accepts?.map((a) => a.scheme).join(', ') || 'ninguno';
-        throw new X402Error(`Ese agente no acepta "${X402_SCHEME}". Esquemas que ofrece: ${vistos}.`);
+        throw new X402Error(`Ese agente no cobra con un esquema que sepamos pagar. Esquemas que ofrece: ${vistos}.`);
     }
     return accept;
 }
@@ -109,62 +115,56 @@ export async function payAndAsk(wallet, account, endpoint, prompt, options) {
     if (options.asset && getAddress(accept.asset) !== getAddress(options.asset)) {
         throw new X402Error(`La cotización pide pagar en ${accept.asset} y esperabas ${options.asset}.`);
     }
-    if (getAddress(accept.domain.verifyingContract) !== getAddress(accept.asset)) {
-        // El dominio EIP-712 tiene que ser el del propio token: si apunta a otro
-        // contrato, la firma valdría para algo distinto de lo que crees.
-        throw new X402Error('El dominio de firma no corresponde al token que se va a pagar.');
+    // Solo en las monedas de la lista de Panal. El nombre y los decimales que
+    // trae la cotización los escribe el agente, y fiarse de ellos permitía
+    // cobrar 1.000 USDC enseñando «0,000000001 $PANAL». Ver currencies.ts.
+    const moneda = x402Currency(accept.asset, networkOfChain(accept.chainId) ?? 'mainnet');
+    if (!moneda) {
+        throw new X402Error(`La cotización pide pagar en ${accept.asset}, que no es una moneda que Panal acepte: no se firma.`);
+    }
+    if (accept.scheme !== moneda.scheme) {
+        throw new X402Error(`${moneda.symbol} se paga con "${moneda.scheme}" y la cotización pide "${accept.scheme}".`);
     }
     const ahora = Math.floor(Date.now() / 1000);
     if (accept.deadline <= ahora + 30) {
         throw new X402Error('La cotización caduca de inmediato: pide otra.');
     }
-    if (accept.payerNonce === undefined) {
-        throw new X402Error('La cotización no trae el nonce del pagador. Vuelve a pedirla indicando `payer`, o léelo del token.');
+    // Y tampoco una que valga demasiado. El plazo lo pone el agente, y un permiso
+    // firmado con un plazo de años se puede cobrar cuando él quiera mientras no
+    // se use otro antes. Las cotizaciones de Panal duran 5 minutos.
+    if (accept.deadline > ahora + PLAZO_MAX_S) {
+        throw new X402Error(`La cotización vale hasta dentro de ${Math.round((accept.deadline - ahora) / 60)} minutos, y el máximo es una hora: no se firma.`);
     }
-    // ---- Firma (sin gas, sin transacción) -----------------------------------
-    const signature = await wallet.signTypedData({
-        account,
-        domain: accept.domain,
-        types: PERMIT_TYPES,
-        primaryType: 'Permit',
-        message: {
-            owner: account.address,
-            spender: getAddress(accept.payTo),
-            value: amount,
-            nonce: BigInt(accept.payerNonce),
-            deadline: BigInt(accept.deadline),
-        },
-    });
-    const header = toBase64(JSON.stringify({
-        scheme: X402_SCHEME,
-        payer: account.address,
-        value: amount.toString(),
-        deadline: accept.deadline.toString(),
-        signature,
-    }));
+    const header = moneda.scheme === ESQUEMA_MON
+        ? await pagarEnMon(wallet, account, accept, amount)
+        : await firmarPermit(wallet, account, accept, amount);
     // ---- Segunda llamada: se cobra y se responde en la misma ----------------
     const res = await fetchLimited(url, {
         method: 'POST',
         headers: {
             'content-type': 'application/json',
-            'x-payment': header,
+            'x-payment': header.value,
             ...(options.envelope ? envelopeHeaders(options.envelope) : {}),
         },
         body: JSON.stringify({ prompt }),
         timeoutMs: options.timeoutMs ?? (accept.maxTimeoutSeconds ?? 120) * 1000,
     });
+    // `paid` es como lo devuelve la plantilla de agentes; `payment`, como lo
+    // devolvía el bot de LexPanal. Se leen los dos para no perder el hash.
     let body;
     try {
         body = JSON.parse(res.text);
     }
     catch {
-        throw new X402Error(`Respuesta ilegible del agente (HTTP ${res.status}).`, res.status);
+        throw new X402Error(`Respuesta ilegible del agente (HTTP ${res.status}).${header.txHash ? ` Tu pago: tx ${header.txHash}.` : ''}`, res.status);
     }
     if (res.status !== 200) {
         // El 502 con `paymentTx` es el caso feo y hay que distinguirlo: te han
         // cobrado y no han respondido, así que el hash es tu prueba para reclamar.
-        if (body.paymentTx) {
-            throw new X402Error(`El agente cobró (tx ${body.paymentTx}) pero no entregó respuesta: ${body.error ?? 'sin detalle'}`, res.status);
+        // En MON el pago ya salió de tu wallet al mandarlo: el hash es el tuyo.
+        const pagado = body.paymentTx ?? header.txHash;
+        if (pagado) {
+            throw new X402Error(`Pagaste (tx ${pagado}) y el agente no entregó respuesta: ${body.error ?? `HTTP ${res.status}`}`, res.status);
         }
         if (res.status === 508) {
             throw new X402Error(`El agente rechazó la llamada por ciclo: ya había atendido esta cadena. ${body.error ?? ''}`.trim(), 508);
@@ -177,11 +177,85 @@ export async function payAndAsk(wallet, account, endpoint, prompt, options) {
     return {
         answer: body.answer,
         paid: amount,
+        currency: moneda,
         payee: getAddress(accept.payTo),
-        txHash: body.payment?.txHash,
+        txHash: body.payment?.txHash ?? body.paid?.txHash ?? header.txHash,
         endpoint: url.toString(),
     };
 }
+/**
+ * Las de `permit`: una firma, sin gas ni transacción. Quien cobra la ejecuta.
+ */
+async function firmarPermit(wallet, account, accept, amount) {
+    if (!accept.domain || getAddress(accept.domain.verifyingContract) !== getAddress(accept.asset)) {
+        // El dominio EIP-712 tiene que ser el del propio token: si apunta a otro
+        // contrato, la firma valdría para algo distinto de lo que crees.
+        throw new X402Error('El dominio de firma no corresponde al token que se va a pagar.');
+    }
+    if (accept.payerNonce === undefined) {
+        throw new X402Error('La cotización no trae el nonce del pagador. Vuelve a pedirla indicando `payer`, o léelo del token.');
+    }
+    // ---- Firma (sin gas, sin transacción) -----------------------------------
+    const signature = await wallet.signTypedData({
+        account,
+        domain: accept.domain,
+        types: PERMIT_TYPES,
+        primaryType: 'Permit',
+        message: {
+            owner: account.address,
+            spender: getAddress(accept.payTo),
+            value: amount,
+            nonce: BigInt(accept.payerNonce),
+            deadline: BigInt(accept.deadline),
+        },
+    });
+    return {
+        value: toBase64(JSON.stringify({
+            scheme: X402_SCHEME,
+            payer: account.address,
+            value: amount.toString(),
+            deadline: accept.deadline.toString(),
+            signature,
+        })),
+    };
+}
+/**
+ * MON: se MANDA la transferencia y se presenta su hash.
+ *
+ * El importe es exactamente el de la cotización —lleva unas unidades al azar
+ * que la hacen única— y el código de pago no va a la cadena: es lo que impide
+ * que otro presente esta transferencia como suya. Ver x402-server.ts.
+ *
+ * Aquí sí pagas tú el gas, una fracción de céntimo en Monad, y se espera a que
+ * entre en un bloque: el agente lo va a comprobar en la cadena.
+ */
+async function pagarEnMon(wallet, account, accept, amount) {
+    if (!accept.paymentId || !/^0x[0-9a-fA-F]{64}$/.test(accept.paymentId)) {
+        throw new X402Error('La cotización en MON no trae su código de pago: pide otra.');
+    }
+    const to = getAddress(accept.payTo);
+    // Monad cobra el límite de gas entero, no el gastado: se pide lo justo. Una
+    // transferencia a una wallet normal son 21.000 exactos; solo se deja margen
+    // si la estimación dice que el destino ejecuta código.
+    const estimado = await estimateGas(wallet, { account, to, value: amount });
+    const gas = estimado > 21000n ? (estimado * 11n) / 10n : estimado;
+    const txHash = await wallet.sendTransaction({ account, chain: wallet.chain ?? null, to, value: amount, gas });
+    const recibo = await waitForTransactionReceipt(wallet, { hash: txHash, timeout: 90_000 });
+    if (recibo.status !== 'success') {
+        throw new X402Error(`La transferencia de MON se revirtió (tx ${txHash}): no se ha preguntado nada.`);
+    }
+    return {
+        txHash,
+        value: toBase64(JSON.stringify({
+            scheme: ESQUEMA_MON,
+            payer: account.address,
+            value: amount.toString(),
+            deadline: accept.deadline.toString(),
+            paymentId: accept.paymentId,
+            txHash,
+        })),
+    };
+}
 /** base64 sin depender de Buffer, para que valga también en el navegador. */
 function toBase64(text) {
     const bytes = new TextEncoder().encode(text);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@panal/sdk",
-  "version": "0.18.2",
+  "version": "0.19.0",
   "description": "SDK de Panal: contrata agentes de IA autonomos on-chain en Monad",
   "type": "module",
   "license": "MIT",
@@ -45,7 +45,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "tsx test/sdk.test.ts && tsx test/x402.test.ts && tsx test/x402-server.test.ts && tsx test/envelope.test.ts && tsx test/files.test.ts && tsx test/attachments.test.ts && tsx test/llm.test.ts && tsx test/skill.test.ts && tsx test/agent-card.test.ts && tsx test/niveles.test.ts && tsx test/tablon.test.ts && tsx test/reserva.test.ts",
+    "test": "tsx test/sdk.test.ts && tsx test/currencies.test.ts && tsx test/x402.test.ts && tsx test/x402-server.test.ts && tsx test/envelope.test.ts && tsx test/files.test.ts && tsx test/attachments.test.ts && tsx test/llm.test.ts && tsx test/skill.test.ts && tsx test/agent-card.test.ts && tsx test/niveles.test.ts && tsx test/tablon.test.ts && tsx test/reserva.test.ts",
     "test:nombres": "tsx test/nombres.test.ts"
   }
 }