@panal/sdk 0.18.3 → 0.19.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Panal and Kreno (founder: Gustavo Chura C.)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/client.d.ts

@@ -152,8 +152,10 @@ export declare class PanalClient {
      * Hace falta porque viem no estima: le pide al nodo que rellene la
      * transacción (`eth_fillTransaction`), el de Monad a veces infla el límite, y
      * Monad cobra el límite ENTERO. Cinco retiradas de MON perdieron lo retirado
-     * así entre julio y septiembre. Se pasa explícito a todo lo que firma una
-     * cuenta local en nombre de un programa que nadie está mirando.
+     * así entre julio y septiembre. Se pasa explícito a TODO lo que firma una
+     * cuenta local en nombre de un programa que nadie está mirando: contratar,
+     * aprobar, entregar, disputar, darse de alta. Antes solo la retirada y el
+     * tablón, y un agente entrega en cada encargo.
      */
     private gasFijo;
     /**
@@ -445,6 +447,13 @@ export declare class PanalClient {
          * cuesta ni una petición.
          */
         skillsPermitidas?: string[];
+        /**
+         * En qué moneda se paga, y por tanto en qué unidades va `maxSpend`.
+         * Por defecto $PANAL. Solo se cotiza con quien cobre en ESTA: comparar
+         * precios de monedas distintas era comparar 1 USDC con 1 wei de $PANAL,
+         * y un tope en una moneda no dice nada de otra.
+         */
+        asset?: Address;
     }): Promise<AskResult & {
         agent: Address;
         skill: string;

package/dist/client.js

@@ -29,6 +29,13 @@ import { TaskStatus, formatAgentMetadata, parseAgentMetadata, } from './types.js
  * $PANAL 103.511. Ver `withdraw()` para lo que pasó sin este tope.
  */
 const TOPE_GAS_RETIRADA = 300000n;
+/**
+ * El tope para dar de alta o cambiar la ficha. Guardar texto en la cadena
+ * cuesta por cada 32 bytes, y una ficha con el logo dentro es grande: aquí el
+ * tope solo está para cortar un disparate, no para medir lo normal. Lo normal
+ * lo da `eth_estimateGas`, que es fiable; el que inflaba era `eth_fillTransaction`.
+ */
+const TOPE_GAS_FICHA = 30000000n;
 /** Cuántos agentes se leen por llamada al registry. */
 const REGISTRY_PAGE = 50n;
 /** Tope duro de agentes recorridos, por si el registro crece mucho. */
@@ -174,13 +181,15 @@ export class PanalClient {
      * Hace falta porque viem no estima: le pide al nodo que rellene la
      * transacción (`eth_fillTransaction`), el de Monad a veces infla el límite, y
      * Monad cobra el límite ENTERO. Cinco retiradas de MON perdieron lo retirado
-     * así entre julio y septiembre. Se pasa explícito a todo lo que firma una
-     * cuenta local en nombre de un programa que nadie está mirando.
+     * así entre julio y septiembre. Se pasa explícito a TODO lo que firma una
+     * cuenta local en nombre de un programa que nadie está mirando: contratar,
+     * aprobar, entregar, disputar, darse de alta. Antes solo la retirada y el
+     * tablón, y un agente entrega en cada encargo.
      */
-    async gasFijo(que, llamada) {
+    async gasFijo(que, llamada, tope = TOPE_GAS_RETIRADA) {
         const estimado = await this.publicClient.estimateContractGas({ ...llamada, account: this.account });
         const gas = (estimado * 11n + 9n) / 10n;
-        if (gas > TOPE_GAS_RETIRADA) {
+        if (gas > tope) {
             throw new Error(`${que}: la estimación de gas salió en ${estimado}, muy por encima de lo normal. ` +
                 'Monad cobra el límite entero: no se ha enviado nada.');
         }
@@ -475,22 +484,19 @@ export class PanalClient {
         if (!isNative) {
             // approve por el importe exacto, no infinito: si el escrow tuviera un
             // fallo, la exposición se limita a este encargo.
+            const aFirmar = { address: agent.currency, abi: erc20Abi, functionName: 'approve', args: [this.addresses.escrow, amount] };
             const approveHash = await wallet.writeContract({
-                address: agent.currency,
-                abi: erc20Abi,
-                functionName: 'approve',
-                args: [this.addresses.escrow, amount],
+                ...aFirmar,
+                gas: await this.gasFijo('El approve', aFirmar),
                 chain: chainFor(this.network),
                 account: this.account,
             });
             await this.publicClient.waitForTransactionReceipt({ hash: approveHash });
         }
+        const aFirmar = { address: this.addresses.escrow, abi: escrowAbi, functionName: 'createTask', args: [agent.address, taskHash, deadline, agent.currency, amount], value: isNative ? amount : 0n };
         const txHash = await wallet.writeContract({
-            address: this.addresses.escrow,
-            abi: escrowAbi,
-            functionName: 'createTask',
-            args: [agent.address, taskHash, deadline, agent.currency, amount],
-            value: isNative ? amount : 0n,
+            ...aFirmar,
+            gas: await this.gasFijo('El encargo', aFirmar),
             chain: chainFor(this.network),
             account: this.account,
         });
@@ -517,11 +523,10 @@ export class PanalClient {
         if (task.status !== TaskStatus.Delivered) {
             throw new Error(`La tarea #${taskId} está "${TaskStatus[task.status]}": solo se aprueba lo entregado.`);
         }
+        const aFirmar = { address: this.addresses.escrow, abi: escrowAbi, functionName: 'approveAndRelease', args: [taskId, rating] };
         const hash = await wallet.writeContract({
-            address: this.addresses.escrow,
-            abi: escrowAbi,
-            functionName: 'approveAndRelease',
-            args: [taskId, rating],
+            ...aFirmar,
+            gas: await this.gasFijo('La aprobación', aFirmar),
             chain: chainFor(this.network),
             account: this.account,
         });
@@ -550,11 +555,10 @@ export class PanalClient {
         if (task.status !== TaskStatus.Open) {
             throw new Error(`La tarea #${taskId} está "${TaskStatus[task.status]}": solo se cancela lo que sigue abierto.`);
         }
+        const aFirmar = { address: this.addresses.escrow, abi: escrowAbi, functionName: 'cancelTask', args: [taskId] };
         const hash = await wallet.writeContract({
-            address: this.addresses.escrow,
-            abi: escrowAbi,
-            functionName: 'cancelTask',
-            args: [taskId],
+            ...aFirmar,
+            gas: await this.gasFijo('La cancelación', aFirmar),
             chain: chainFor(this.network),
             account: this.account,
         });
@@ -578,11 +582,10 @@ export class PanalClient {
         if (task.status !== TaskStatus.Delivered) {
             throw new Error(`La tarea #${taskId} está "${TaskStatus[task.status]}": solo se disputa lo entregado.`);
         }
+        const aFirmar = { address: this.addresses.escrow, abi: escrowAbi, functionName: 'openDispute', args: [taskId] };
         const hash = await wallet.writeContract({
-            address: this.addresses.escrow,
-            abi: escrowAbi,
-            functionName: 'openDispute',
-            args: [taskId],
+            ...aFirmar,
+            gas: await this.gasFijo('La disputa', aFirmar),
             chain: chainFor(this.network),
             account: this.account,
         });
@@ -610,6 +613,7 @@ export class PanalClient {
             ...llamada,
             abi: registryAbi,
             functionName: 'registerAgent',
+            gas: await this.gasFijo('El alta', llamada, TOPE_GAS_FICHA),
             chain: chainFor(this.network),
             account: this.account,
         });
@@ -619,11 +623,10 @@ export class PanalClient {
     /** Cambia el nombre, la descripción, las skills o el endpoint publicados. */
     async updateMetadata(metadata) {
         const wallet = this.wallet();
+        const aFirmar = { address: this.addresses.registry, abi: registryAbi, functionName: 'updateMetadata', args: [formatAgentMetadata(metadata)] };
         const hash = await wallet.writeContract({
-            address: this.addresses.registry,
-            abi: registryAbi,
-            functionName: 'updateMetadata',
-            args: [formatAgentMetadata(metadata)],
+            ...aFirmar,
+            gas: await this.gasFijo('El cambio de ficha', aFirmar, TOPE_GAS_FICHA),
             chain: chainFor(this.network),
             account: this.account,
         });
@@ -633,11 +636,10 @@ export class PanalClient {
     /** Cambia el precio por tarea, y opcionalmente la moneda en la que cobras. */
     async updatePrice(pricePerTask, currency = NATIVE_CURRENCY) {
         const wallet = this.wallet();
+        const aFirmar = { address: this.addresses.registry, abi: registryAbi, functionName: 'updatePrice', args: [pricePerTask, currency] };
         const hash = await wallet.writeContract({
-            address: this.addresses.registry,
-            abi: registryAbi,
-            functionName: 'updatePrice',
-            args: [pricePerTask, currency],
+            ...aFirmar,
+            gas: await this.gasFijo('El cambio de precio', aFirmar),
             chain: chainFor(this.network),
             account: this.account,
         });
@@ -651,11 +653,10 @@ export class PanalClient {
      */
     async setActive(active) {
         const wallet = this.wallet();
+        const aFirmar = { address: this.addresses.registry, abi: registryAbi, functionName: 'setActive', args: [active] };
         const hash = await wallet.writeContract({
-            address: this.addresses.registry,
-            abi: registryAbi,
-            functionName: 'setActive',
-            args: [active],
+            ...aFirmar,
+            gas: await this.gasFijo('El cambio de estado', aFirmar),
             chain: chainFor(this.network),
             account: this.account,
         });
@@ -679,11 +680,10 @@ export class PanalClient {
             throw new Error(`La tarea #${taskId} está "${TaskStatus[task.status]}": solo se entrega lo que sigue abierto.`);
         }
         const resultHash = keccak256(toBytes(resultText));
+        const aFirmar = { address: this.addresses.escrow, abi: escrowAbi, functionName: 'deliverResult', args: [taskId, resultHash] };
         const txHash = await wallet.writeContract({
-            address: this.addresses.escrow,
-            abi: escrowAbi,
-            functionName: 'deliverResult',
-            args: [taskId, resultHash],
+            ...aFirmar,
+            gas: await this.gasFijo('La entrega', aFirmar),
             chain: chainFor(this.network),
             account: this.account,
         });
@@ -1016,6 +1016,7 @@ export class PanalClient {
                     ? ` Se probó también con ${variantesDeSkill(skill).slice(1).map((v) => `"${v}"`).join(' y ')}.`
                     : ''));
         }
+        const moneda = getAddress(options.asset ?? this.addresses.panalToken);
         const quotes = [];
         const rechazos = [];
         for (const agent of candidates) {
@@ -1026,7 +1027,10 @@ export class PanalClient {
                     ...options,
                     envelope: heredado,
                 });
-                if (BigInt(accept.amount) <= tope)
+                if (getAddress(accept.asset) !== moneda) {
+                    rechazos.push(`${agent.metadata.name || agent.address}: cobra en ${accept.asset}, no en ${moneda}`);
+                }
+                else if (BigInt(accept.amount) <= tope)
                     quotes.push({ agent, endpoint, accept });
                 else
                     rechazos.push(`${agent.metadata.name || agent.address}: pide ${accept.amount}, por encima del tope`);
@@ -1048,6 +1052,7 @@ export class PanalClient {
             maxSpend: tope,
             chainId: chainFor(this.network).id,
             expectedPayee: elegido.agent.address,
+            asset: moneda,
             quote: elegido.accept,
             envelope: siguiente,
         });

package/dist/currencies.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Las monedas con las que se paga una consulta x402 en Panal.
+ *
+ * POR QUÉ UNA LISTA CERRADA
+ *
+ * La cotización la escribe el agente: qué token, qué importe y cómo se llama.
+ * Fiarse de eso para enseñar el precio era el agujero. Un agente podía cobrar
+ * en un token de 6 decimales y llamarlo «$PANAL»: 1.000 USDC se pintaban
+ * «0,000000001 $PANAL» y la persona firmaba un permiso por 1.000 USDC creyendo
+ * que no pagaba nada.
+ *
+ * Aquí se fija, para cada red, qué tokens se aceptan y con qué nombre y
+ * decimales. El nombre y los decimales salen SIEMPRE de esta lista, nunca de
+ * la cotización, y un token que no está aquí no se paga. Es la misma lista
+ * para todas las capas —web, app, MCP y agentes— para que ninguna pueda
+ * enseñar un precio distinto del que se firma.
+ *
+ * Las cuatro de token cobran con `permit` (EIP-2612), comprobado en mainnet:
+ * firma gratis, y el gas lo pone el agente que cobra. MON, la moneda nativa,
+ * no tiene `permit`: quien paga MANDA una transferencia (paga él su gas, una
+ * fracción de céntimo) y la presenta. Ver `native-transfer` en x402-server.ts.
+ *
+ *   - MON    — la moneda de Monad. Nadie puede congelarla.
+ *   - $PANAL — el token de Panal.
+ *   - GHO    — de Aave. Respaldo cripto, sin lista negra ni pausa: nadie puede
+ *              congelarlo. La opción estable que no depende de una empresa.
+ *   - USDC   — de Circle. Respaldo en dólares; Circle puede congelar
+ *              direcciones y pausar el token.
+ *   - AUSD   — de Agora. Respaldo en dólares; Agora puede congelar
+ *              direcciones y pausar transferencias.
+ *
+ * En x402 que USDC y AUSD se puedan congelar pesa poco: Panal no guarda nada,
+ * el dinero va directo de quien paga al agente, y si alguien es congelado es
+ * en su propia wallet. Cada uno elige con qué paga o cobra.
+ */
+import { type Address } from 'viem';
+import type { PanalNetwork } from './chains.js';
+/**
+ * Cómo se cobra en una moneda: con una firma de `permit` que ejecuta quien
+ * cobra, o con una transferencia que manda quien paga.
+ */
+export type X402Scheme = 'eip2612-permit' | 'native-transfer';
+/** La moneda nativa, como la escribe Panal en todas partes: la dirección cero. */
+export declare const X402_NATIVE: Address;
+export interface X402Currency {
+    /** Como se enseña: `$PANAL`, `GHO`, `USDC`, `AUSD`. */
+    symbol: string;
+    address: Address;
+    decimals: number;
+    scheme: X402Scheme;
+    /** Si su emisor puede congelar direcciones o pausar el token. */
+    issuerCanFreeze: boolean;
+}
+/** Las monedas aceptadas en una red, en el orden en que se ofrecen. */
+export declare function x402Currencies(network?: PanalNetwork): readonly X402Currency[];
+/** La red de un chainId de Monad, o `null` si no es ninguna de las dos. */
+export declare function networkOfChain(chainId: number): PanalNetwork | null;
+/**
+ * La moneda de un token, o `null` si Panal no acepta pagar en él.
+ *
+ * Por dirección: el nombre lo puede escribir cualquiera, la dirección no.
+ */
+export declare function x402Currency(token: string, network?: PanalNetwork): X402Currency | null;
+/**
+ * Lo mismo, admitiendo también el símbolo: `USDC`, `gho`, `$PANAL` o `PANAL`.
+ * Es para configurar un agente a mano (`X402_TOKEN=USDC`), no para leer lo que
+ * llega de fuera: eso va siempre por dirección.
+ */
+export declare function x402CurrencyByName(name: string, network?: PanalNetwork): X402Currency | null;
+/** Un importe en unidades mínimas, en texto legible: `0.05`. */
+export declare function formatX402Amount(amount: bigint | string, currency: X402Currency): string;
+/** `0.05` → unidades mínimas de esa moneda. Lanza si el texto no es un número. */
+export declare function parseX402Amount(text: string, currency: X402Currency): bigint;

package/dist/currencies.js

@@ -0,0 +1,112 @@
+/**
+ * Las monedas con las que se paga una consulta x402 en Panal.
+ *
+ * POR QUÉ UNA LISTA CERRADA
+ *
+ * La cotización la escribe el agente: qué token, qué importe y cómo se llama.
+ * Fiarse de eso para enseñar el precio era el agujero. Un agente podía cobrar
+ * en un token de 6 decimales y llamarlo «$PANAL»: 1.000 USDC se pintaban
+ * «0,000000001 $PANAL» y la persona firmaba un permiso por 1.000 USDC creyendo
+ * que no pagaba nada.
+ *
+ * Aquí se fija, para cada red, qué tokens se aceptan y con qué nombre y
+ * decimales. El nombre y los decimales salen SIEMPRE de esta lista, nunca de
+ * la cotización, y un token que no está aquí no se paga. Es la misma lista
+ * para todas las capas —web, app, MCP y agentes— para que ninguna pueda
+ * enseñar un precio distinto del que se firma.
+ *
+ * Las cuatro de token cobran con `permit` (EIP-2612), comprobado en mainnet:
+ * firma gratis, y el gas lo pone el agente que cobra. MON, la moneda nativa,
+ * no tiene `permit`: quien paga MANDA una transferencia (paga él su gas, una
+ * fracción de céntimo) y la presenta. Ver `native-transfer` en x402-server.ts.
+ *
+ *   - MON    — la moneda de Monad. Nadie puede congelarla.
+ *   - $PANAL — el token de Panal.
+ *   - GHO    — de Aave. Respaldo cripto, sin lista negra ni pausa: nadie puede
+ *              congelarlo. La opción estable que no depende de una empresa.
+ *   - USDC   — de Circle. Respaldo en dólares; Circle puede congelar
+ *              direcciones y pausar el token.
+ *   - AUSD   — de Agora. Respaldo en dólares; Agora puede congelar
+ *              direcciones y pausar transferencias.
+ *
+ * En x402 que USDC y AUSD se puedan congelar pesa poco: Panal no guarda nada,
+ * el dinero va directo de quien paga al agente, y si alguien es congelado es
+ * en su propia wallet. Cada uno elige con qué paga o cobra.
+ */
+import { formatUnits, getAddress, parseUnits } from 'viem';
+/** La moneda nativa, como la escribe Panal en todas partes: la dirección cero. */
+export const X402_NATIVE = '0x0000000000000000000000000000000000000000';
+const MON = {
+    symbol: 'MON',
+    address: X402_NATIVE,
+    decimals: 18,
+    scheme: 'native-transfer',
+    issuerCanFreeze: false,
+};
+const MAINNET = [
+    {
+        symbol: '$PANAL',
+        address: getAddress('0x2e2e44e7fa6178822d4397299f719e89d1a67777'),
+        decimals: 18,
+        scheme: 'eip2612-permit',
+        issuerCanFreeze: false,
+    },
+    MON,
+    {
+        symbol: 'GHO',
+        address: getAddress('0xfc421ad3c883bf9e7c4f42de845c4e4405799e73'),
+        decimals: 18,
+        scheme: 'eip2612-permit',
+        issuerCanFreeze: false,
+    },
+    {
+        symbol: 'USDC',
+        address: getAddress('0x754704bc059f8c67012fed69bc8a327a5aafb603'),
+        decimals: 6,
+        scheme: 'eip2612-permit',
+        issuerCanFreeze: true,
+    },
+    {
+        symbol: 'AUSD',
+        address: getAddress('0x00000000efe302beaa2b3e6e1b18d08d69a9012a'),
+        decimals: 6,
+        scheme: 'eip2612-permit',
+        issuerCanFreeze: true,
+    },
+];
+/** En testnet no hay ninguno de estos tokens, pero MON sí. */
+const TESTNET = [MON];
+/** Las monedas aceptadas en una red, en el orden en que se ofrecen. */
+export function x402Currencies(network = 'mainnet') {
+    return network === 'mainnet' ? MAINNET : TESTNET;
+}
+/** La red de un chainId de Monad, o `null` si no es ninguna de las dos. */
+export function networkOfChain(chainId) {
+    return chainId === 143 ? 'mainnet' : chainId === 10143 ? 'testnet' : null;
+}
+/**
+ * La moneda de un token, o `null` si Panal no acepta pagar en él.
+ *
+ * Por dirección: el nombre lo puede escribir cualquiera, la dirección no.
+ */
+export function x402Currency(token, network = 'mainnet') {
+    const t = token.trim().toLowerCase();
+    return x402Currencies(network).find((c) => c.address.toLowerCase() === t) ?? null;
+}
+/**
+ * Lo mismo, admitiendo también el símbolo: `USDC`, `gho`, `$PANAL` o `PANAL`.
+ * Es para configurar un agente a mano (`X402_TOKEN=USDC`), no para leer lo que
+ * llega de fuera: eso va siempre por dirección.
+ */
+export function x402CurrencyByName(name, network = 'mainnet') {
+    const n = name.trim().replace(/^\$/, '').toUpperCase();
+    return x402Currencies(network).find((c) => c.symbol.replace(/^\$/, '').toUpperCase() === n) ?? x402Currency(name, network);
+}
+/** Un importe en unidades mínimas, en texto legible: `0.05`. */
+export function formatX402Amount(amount, currency) {
+    return formatUnits(BigInt(amount), currency.decimals);
+}
+/** `0.05` → unidades mínimas de esa moneda. Lanza si el texto no es un número. */
+export function parseX402Amount(text, currency) {
+    return parseUnits(text.trim(), currency.decimals);
+}

package/dist/index.d.ts

@@ -27,14 +27,16 @@ export { TaskStatus, TASK_STATUS_LABEL, formatAgentMetadata, normalizeAgentLink,
 export type { Agent, AgentLinkKey, AgentLinks, AgentMetadata, Task } from './types.js';
 export { erc20Abi, escrowAbi, registryAbi } from './abis.js';
 export { X402_SCHEME, X402Error, payAndAsk, quoteAsk } from './x402.js';
+export { X402_NATIVE, formatX402Amount, networkOfChain, parseX402Amount, x402Currencies, x402Currency, x402CurrencyByName, } from './currencies.js';
+export type { X402Currency, X402Scheme } from './currencies.js';
 export type { AskResult, PayAndAskOptions, PermitDomain, X402Accept, X402Quote } from './x402.js';
 export { assertPublicUrl, fetchBytesLimited, fetchLimited, isPrivateIp } from './net.js';
 export { ATTACH_BLOCK, FILES_BLOCK, MAX_FILE_BYTES, FileVerificationError, appendAttachmentsManifest, appendFilesManifest, attachmentFrom, buildAttachmentsManifest, buildFilesManifest, downloadDeliveredFile, fileUrl, matchAttachment, parseAttachmentsManifest, parseFilesManifest, sanitizeFileName, stripFilesManifest, verifyFileBytes, } from './files.js';
 export type { AttachedFile, DeliveredFile, DownloadOptions, HashedFile } from './files.js';
 export { MAX_IMAGEN_BYTES, MIMES_IMAGEN, PROVEEDORES, LlmError, dialectoDe, esImagenSoportada, llmChat, resolverLlm, } from './llm.js';
 export type { LlmConfig, LlmDialecto, LlmImagen, LlmPeticion, LlmProveedor } from './llm.js';
-export { X402_VERSION, X402_SERVER_SCHEME, buildQuote, enqueueByPayer, parsePaymentHeader, permitNonce, permitTypedData, readPermitDomain, resourceId, splitSignature, verifyAndSettle, } from './x402-server.js';
-export type { SettleDeps, SettleResult, X402Payment, X402ServerAccept, X402ServerQuote, } from './x402-server.js';
+export { X402_VERSION, X402_SERVER_SCHEME, X402_NATIVE_SCHEME, buildNativeQuote, buildQuote, enqueueByPayer, newQuoteSecret, parsePaymentHeader, parseX402Header, permitNonce, permitTypedData, readPermitDomain, resourceId, splitSignature, verifyAndSettle, verifyNativePayment, } from './x402-server.js';
+export type { NativeReplayGuard, SettleDeps, SettleResult, X402NativeAccept, X402NativePayment, X402Payment, X402ServerAccept, X402ServerQuote, } from './x402-server.js';
 export { ENVELOPE_HEADERS, DEFAULT_DEPTH, MAX_DEPTH, BudgetExhausted, DepthExhausted, LoopDetected, assertCanServe, descend, envelopeHeaders, newEnvelope, parseEnvelope, remainingBudget, } from './envelope.js';
 export type { CallEnvelope } from './envelope.js';
 export type { UrlGuardOptions } from './net.js';

package/dist/index.js

@@ -25,6 +25,7 @@ export { TaskStatus, TASK_STATUS_LABEL, formatAgentMetadata, normalizeAgentLink,
 export { erc20Abi, escrowAbi, registryAbi } from './abis.js';
 // x402: pagar a otro agente por una consulta, sin escrow y sin humano.
 export { X402_SCHEME, X402Error, payAndAsk, quoteAsk } from './x402.js';
+export { X402_NATIVE, formatX402Amount, networkOfChain, parseX402Amount, x402Currencies, x402Currency, x402CurrencyByName, } from './currencies.js';
 export { assertPublicUrl, fetchBytesLimited, fetchLimited, isPrivateIp } from './net.js';
 // Archivos: entregar un PDF o un vídeo anclando SU hash, no el del enlace.
 // Y en la otra dirección, adjuntar una foto al encargo con la misma garantía.
@@ -34,7 +35,7 @@ export { ATTACH_BLOCK, FILES_BLOCK, MAX_FILE_BYTES, FileVerificationError, appen
 export { MAX_IMAGEN_BYTES, MIMES_IMAGEN, PROVEEDORES, LlmError, dialectoDe, esImagenSoportada, llmChat, resolverLlm, } from './llm.js';
 // x402: la otra mitad, cobrar por llamada. Portada del bot de LexPanal, donde
 // lleva meses cobrando en produccion.
-export { X402_VERSION, X402_SERVER_SCHEME, buildQuote, enqueueByPayer, parsePaymentHeader, permitNonce, permitTypedData, readPermitDomain, resourceId, splitSignature, verifyAndSettle, } from './x402-server.js';
+export { X402_VERSION, X402_SERVER_SCHEME, X402_NATIVE_SCHEME, buildNativeQuote, buildQuote, enqueueByPayer, newQuoteSecret, parsePaymentHeader, parseX402Header, permitNonce, permitTypedData, readPermitDomain, resourceId, splitSignature, verifyAndSettle, verifyNativePayment, } from './x402-server.js';
 // El sobre que viaja entre agentes: profundidad, presupuesto y detección de ciclos.
 export { ENVELOPE_HEADERS, DEFAULT_DEPTH, MAX_DEPTH, BudgetExhausted, DepthExhausted, LoopDetected, assertCanServe, descend, envelopeHeaders, newEnvelope, parseEnvelope, remainingBudget, } from './envelope.js';
 // La ficha de GET /agent.json: un solo formato, y lectores que perdonan el

package/dist/x402-server.d.ts

@@ -40,6 +40,8 @@ import type { PermitDomain } from './x402.js';
 export type { PermitDomain };
 export declare const X402_VERSION = 1;
 export declare const X402_SERVER_SCHEME = "eip2612-permit";
+/** El esquema de MON: quien paga manda una transferencia y la presenta. */
+export declare const X402_NATIVE_SCHEME = "native-transfer";
 export declare function permitTypedData(domain: PermitDomain, message: {
     owner: Address;
     spender: Address;
@@ -76,12 +78,18 @@ export declare function permitTypedData(domain: PermitDomain, message: {
     };
 };
 /**
- * Lee el dominio EIP-712 del token en cadena (ERC-5267), con respaldo a
- * `name()` + version "1", que es lo que usan las implementaciones habituales.
+ * Lee el dominio EIP-712 del token en cadena.
  *
  * Se lee de la cadena en vez de escribirlo a mano porque un dominio mal
  * construido produce firmas que verifican en local y revierten al llegar al
  * contrato: el fallo aparecería solo en producción y con dinero de por medio.
+ *
+ * Y no basta con una sola fuente. ERC-5267 (`eip712Domain()`) lo tienen
+ * $PANAL y AUSD, pero no GHO ni USDC; y la versión no es siempre "1": USDC usa
+ * "2". Antes se suponía "1" si faltaba `eip712Domain()`, y TODAS las firmas de
+ * USDC salían inválidas. Ahora se reúnen los candidatos —ERC-5267, `name()`
+ * con `version()`, con "1" y con "2"— y se elige el que da exactamente el
+ * `DOMAIN_SEPARATOR()` del token. Si el token no lo expone, se usa el primero.
  */
 export declare function readPermitDomain(publicClient: PublicClient, token: Address, network?: PanalNetwork): Promise<PermitDomain>;
 /** Nonce de permit actual del pagador. Cambia con cada pago consumido. */
@@ -122,7 +130,7 @@ export declare function buildQuote(params: {
     nowS?: number;
 }): X402ServerQuote;
 export interface X402Payment {
-    scheme: string;
+    scheme: typeof X402_SERVER_SCHEME;
     payer: Address;
     value: bigint;
     deadline: bigint;
@@ -169,3 +177,86 @@ export declare function enqueueByPayer<T>(payer: Address, fn: () => Promise<T>):
 export declare function verifyAndSettle(deps: SettleDeps, payment: X402Payment, price: bigint): Promise<SettleResult>;
 /** Identificador estable del recurso pagado, para trazas y recibos. */
 export declare function resourceId(method: string, path: string, body: string): Hex;
+/** Un secreto nuevo para firmar cotizaciones. Uno por arranque basta. */
+export declare function newQuoteSecret(): Hex;
+export interface X402NativeAccept {
+    scheme: typeof X402_NATIVE_SCHEME;
+    network: string;
+    chainId: number;
+    asset: Address;
+    assetSymbol: 'MON';
+    /** El precio más unas unidades al azar: la transferencia tiene que ser de ESTO exactamente. */
+    amount: string;
+    payTo: Address;
+    resource: string;
+    description: string;
+    deadline: number;
+    maxTimeoutSeconds: number;
+    /** Secreto de esta cotización: se presenta con el pago, nunca va a la cadena. */
+    paymentId: Hex;
+}
+/**
+ * La cotización de una pregunta en MON.
+ *
+ * @param resource `resourceId()` de la petición: ata el pago a ESTA pregunta.
+ * @param payer    Quien dijo que iba a pagar (cabecera X-Payment-Payer). Sin
+ *                 él, la cotización vale para cualquier pagador, y lo que la
+ *                 protege es el importe único y el secreto.
+ */
+export declare function buildNativeQuote(params: {
+    secret: Hex;
+    price: bigint;
+    payTo: Address;
+    resource: Hex;
+    description: string;
+    payer?: Address | null;
+    network?: PanalNetwork;
+    nowS?: number;
+}): {
+    x402Version: typeof X402_VERSION;
+    accepts: X402NativeAccept[];
+    hint: string;
+};
+export interface X402NativePayment {
+    scheme: typeof X402_NATIVE_SCHEME;
+    payer: Address;
+    value: bigint;
+    deadline: bigint;
+    paymentId: Hex;
+    txHash: Hex;
+}
+/**
+ * Lee X-Payment de los dos esquemas. Nunca lanza: devuelve el motivo.
+ *
+ * `parsePaymentHeader` sigue aceptando solo el permit, como antes, para que un
+ * agente que no sabe cobrar en MON no reciba un pago que no sabe comprobar.
+ */
+export declare function parseX402Header(header: string): {
+    ok: true;
+    payment: X402Payment | X402NativePayment;
+} | {
+    ok: false;
+    error: string;
+};
+/** Las transacciones ya cobradas. Basta en memoria: una cotización caduca a los 5 minutos. */
+export interface NativeReplayGuard {
+    has(txHash: string): boolean;
+    add(txHash: string): void;
+}
+/**
+ * Comprueba en la cadena un pago en MON. El recurso NO debe servirse hasta
+ * que esto salga bien. No hace falta wallet: el pago ya lo mandó el cliente.
+ */
+export declare function verifyNativePayment(deps: {
+    publicClient: PublicClient;
+    payee: Address;
+    secret: Hex;
+    used: NativeReplayGuard;
+    /** Para las pruebas. */
+    nowS?: number;
+    /** Cuánto esperar a que el nodo vea la transacción. */
+    waitMs?: number;
+}, payment: X402NativePayment, params: {
+    price: bigint;
+    resource: Hex;
+}): Promise<SettleResult>;

package/dist/x402-server.js

@@ -34,11 +34,13 @@
  *
  * Portado del bot de LexPanal, donde llevaba meses cobrando en producción.
  */
-import { getAddress, hexToNumber, isAddress, isHex, keccak256, slice, toHex, verifyTypedData, } from 'viem';
+import { encodeAbiParameters, getAddress, hashDomain, hexToNumber, isAddress, isAddressEqual, isHex, keccak256, slice, toHex, verifyTypedData, } from 'viem';
 import { chainFor } from './chains.js';
 import { erc20Abi } from './abis.js';
 export const X402_VERSION = 1;
 export const X402_SERVER_SCHEME = 'eip2612-permit';
+/** El esquema de MON: quien paga manda una transferencia y la presenta. */
+export const X402_NATIVE_SCHEME = 'native-transfer';
 /** Margen mínimo de vigencia que se exige a la firma al llegar. */
 const MIN_DEADLINE_MARGIN_S = 30;
 /** Vigencia que se sugiere en el presupuesto. */
@@ -59,47 +61,81 @@ export function permitTypedData(domain, message) {
     return { domain, types: PERMIT_TYPES, primaryType: 'Permit', message };
 }
 /**
- * Lee el dominio EIP-712 del token en cadena (ERC-5267), con respaldo a
- * `name()` + version "1", que es lo que usan las implementaciones habituales.
+ * Lee el dominio EIP-712 del token en cadena.
  *
  * Se lee de la cadena en vez de escribirlo a mano porque un dominio mal
  * construido produce firmas que verifican en local y revierten al llegar al
  * contrato: el fallo aparecería solo en producción y con dinero de por medio.
+ *
+ * Y no basta con una sola fuente. ERC-5267 (`eip712Domain()`) lo tienen
+ * $PANAL y AUSD, pero no GHO ni USDC; y la versión no es siempre "1": USDC usa
+ * "2". Antes se suponía "1" si faltaba `eip712Domain()`, y TODAS las firmas de
+ * USDC salían inválidas. Ahora se reúnen los candidatos —ERC-5267, `name()`
+ * con `version()`, con "1" y con "2"— y se elige el que da exactamente el
+ * `DOMAIN_SEPARATOR()` del token. Si el token no lo expone, se usa el primero.
  */
 export async function readPermitDomain(publicClient, token, network = 'mainnet') {
-    try {
-        const d = (await publicClient.readContract({
-            address: token,
-            abi: [
-                {
-                    type: 'function',
-                    name: 'eip712Domain',
-                    stateMutability: 'view',
-                    inputs: [],
-                    outputs: [
-                        { name: 'fields', type: 'bytes1' },
-                        { name: 'name', type: 'string' },
-                        { name: 'version', type: 'string' },
-                        { name: 'chainId', type: 'uint256' },
-                        { name: 'verifyingContract', type: 'address' },
-                        { name: 'salt', type: 'bytes32' },
-                        { name: 'extensions', type: 'uint256[]' },
-                    ],
-                },
-            ],
-            functionName: 'eip712Domain',
-        }));
-        return { name: d[1], version: d[2], chainId: Number(d[3]), verifyingContract: getAddress(d[4]) };
+    const leer = (functionName) => publicClient
+        .readContract({ address: token, abi: dominioAbi, functionName: functionName })
+        .then((v) => v, () => null);
+    const [erc5267, nombre, version, separador] = await Promise.all([
+        leer('eip712Domain'),
+        leer('name'),
+        leer('version'),
+        leer('DOMAIN_SEPARATOR'),
+    ]);
+    const chainId = chainFor(network).id;
+    const verifyingContract = getAddress(token);
+    const candidatos = [];
+    if (erc5267) {
+        candidatos.push({ name: erc5267[1], version: erc5267[2], chainId: Number(erc5267[3]), verifyingContract: getAddress(erc5267[4]) });
     }
-    catch {
-        const name = (await publicClient.readContract({
-            address: token,
-            abi: tokenExtraAbi,
-            functionName: 'name',
-        }));
-        return { name, version: '1', chainId: chainFor(network).id, verifyingContract: getAddress(token) };
+    if (nombre !== null) {
+        for (const v of [version, '1', '2']) {
+            if (v !== null)
+                candidatos.push({ name: nombre, version: v, chainId, verifyingContract });
+        }
+    }
+    if (!candidatos.length)
+        throw new Error(`no se pudo leer el dominio EIP-712 de ${token}`);
+    if (!separador)
+        return candidatos[0];
+    const bueno = candidatos.find((d) => hashDomain({
+        domain: { ...d, chainId: BigInt(d.chainId) },
+        types: {
+            EIP712Domain: [
+                { name: 'name', type: 'string' },
+                { name: 'version', type: 'string' },
+                { name: 'chainId', type: 'uint256' },
+                { name: 'verifyingContract', type: 'address' },
+            ],
+        },
+    }) === separador);
+    if (!bueno) {
+        throw new Error(`ningún dominio candidato de ${token} coincide con su DOMAIN_SEPARATOR: no se puede firmar con seguridad`);
     }
+    return bueno;
 }
+const dominioAbi = [
+    {
+        type: 'function',
+        name: 'eip712Domain',
+        stateMutability: 'view',
+        inputs: [],
+        outputs: [
+            { name: 'fields', type: 'bytes1' },
+            { name: 'name', type: 'string' },
+            { name: 'version', type: 'string' },
+            { name: 'chainId', type: 'uint256' },
+            { name: 'verifyingContract', type: 'address' },
+            { name: 'salt', type: 'bytes32' },
+            { name: 'extensions', type: 'uint256[]' },
+        ],
+    },
+    { type: 'function', name: 'name', stateMutability: 'view', inputs: [], outputs: [{ name: '', type: 'string' }] },
+    { type: 'function', name: 'version', stateMutability: 'view', inputs: [], outputs: [{ name: '', type: 'string' }] },
+    { type: 'function', name: 'DOMAIN_SEPARATOR', stateMutability: 'view', inputs: [], outputs: [{ name: '', type: 'bytes32' }] },
+];
 /** Nonce de permit actual del pagador. Cambia con cada pago consumido. */
 export async function permitNonce(publicClient, token, owner) {
     return publicClient.readContract({
@@ -273,28 +309,34 @@ export async function verifyAndSettle(deps, payment, price) {
         const wallet = deps.walletClient;
         // permit + transferFrom. Se simula antes para no quemar gas en una
         // transacción condenada (firma consumida, deadline pasado, saldo movido).
-        await deps.publicClient.simulateContract({
+        const permitCall = {
             address: deps.token,
             abi: permitAbi,
             functionName: 'permit',
             args: [payment.payer, deps.payee, payment.value, payment.deadline, v, r, s],
             account: wallet.account,
-        });
+        };
+        await deps.publicClient.simulateContract(permitCall);
+        // Con el gas FIJADO: Monad cobra el límite entero, y si se deja a viem lo
+        // rellena con `eth_fillTransaction`, que el nodo a veces infla. Así se
+        // perdieron retiradas enteras; aquí sería el agente pagando de más en
+        // cada cobro.
         const permitTx = await wallet.writeContract({
-            address: deps.token,
-            abi: permitAbi,
-            functionName: 'permit',
-            args: [payment.payer, deps.payee, payment.value, payment.deadline, v, r, s],
-            account: wallet.account,
+            ...permitCall,
+            gas: await gasDeCobro(deps.publicClient, permitCall),
             chain,
         });
         await deps.publicClient.waitForTransactionReceipt({ hash: permitTx });
-        const transferTx = await wallet.writeContract({
+        const transferCall = {
             address: deps.token,
             abi: tokenExtraAbi,
             functionName: 'transferFrom',
             args: [payment.payer, deps.payee, payment.value],
             account: wallet.account,
+        };
+        const transferTx = await wallet.writeContract({
+            ...transferCall,
+            gas: await gasDeCobro(deps.publicClient, transferCall),
             chain,
         });
         const receipt = await deps.publicClient.waitForTransactionReceipt({ hash: transferTx });
@@ -304,6 +346,18 @@ export async function verifyAndSettle(deps, payment, price) {
         return { ok: true, txHash: transferTx, amount: payment.value };
     });
 }
+/**
+ * El gas de un paso del cobro: `eth_estimateGas` + 10 %. Un permit o un
+ * transferFrom gastan unos 50.000–90.000; por encima de 300.000 algo va mal y
+ * no se manda, en vez de pagarlo entero.
+ */
+async function gasDeCobro(publicClient, llamada) {
+    const estimado = await publicClient.estimateContractGas(llamada);
+    const gas = (estimado * 11n + 9n) / 10n;
+    if (gas > 300000n)
+        throw new Error(`el gas estimado para cobrar (${estimado}) es anormal: no se manda`);
+    return gas;
+}
 /** Trozos del ERC-20 que no están en el `erc20Abi` del SDK. */
 const tokenExtraAbi = [
     {
@@ -346,3 +400,198 @@ const permitAbi = [
 export function resourceId(method, path, body) {
     return keccak256(toHex(`${method} ${path}\n${body}`));
 }
+// ---------------------------------------------------------------------------
+// MON: el esquema `native-transfer`.
+//
+// La moneda nativa no tiene `permit`, así que no se puede cobrar con una firma.
+// Quien paga MANDA el MON al agente (paga él su gas: una fracción de céntimo
+// en Monad) y repite la petición con el hash de esa transacción.
+//
+// Lo difícil es que una transferencia es pública: cualquiera la ve en la
+// cadena en cuanto entra. Sin cuidado, otro podría presentarla como suya y
+// llevarse la respuesta que pagó un tercero. Lo impiden dos cosas:
+//
+//   1. EL IMPORTE ES ÚNICO. La cotización pide el precio más unas pocas
+//      unidades al azar (menos de una millonésima de céntimo). La transferencia
+//      tiene que ser EXACTAMENTE de ese importe, así que solo vale para la
+//      cotización que lo pidió: quien pida otra recibe otro importe.
+//   2. EL CÓDIGO DE PAGO ES SECRETO. La cotización lleva un `paymentId` que
+//      solo conoce quien la pidió (va por HTTPS, no por la cadena) y que ata
+//      pagador, agente, importe, caducidad y la pregunta exacta. Sin él, una
+//      transferencia vista en la cadena no se puede presentar.
+//
+// El `paymentId` es un keccak256 de un secreto del agente con esos datos: el
+// agente no tiene que guardar las cotizaciones que da, solo rehacer la cuenta.
+// Y cada transacción se acepta UNA vez.
+// ---------------------------------------------------------------------------
+/** Un secreto nuevo para firmar cotizaciones. Uno por arranque basta. */
+export function newQuoteSecret() {
+    return toHex(crypto.getRandomValues(new Uint8Array(32)));
+}
+/** Margen tras la caducidad para que la transferencia llegue a minarse. */
+const NATIVE_GRACE_S = 120;
+function nativePaymentId(secret, q) {
+    return keccak256(encodeAbiParameters([
+        { type: 'bytes32' },
+        { type: 'address' },
+        { type: 'address' },
+        { type: 'uint256' },
+        { type: 'uint256' },
+        { type: 'bytes32' },
+    ], [secret, getAddress(q.payer), getAddress(q.payTo), q.amount, BigInt(q.deadline), q.resource]));
+}
+/**
+ * La cotización de una pregunta en MON.
+ *
+ * @param resource `resourceId()` de la petición: ata el pago a ESTA pregunta.
+ * @param payer    Quien dijo que iba a pagar (cabecera X-Payment-Payer). Sin
+ *                 él, la cotización vale para cualquier pagador, y lo que la
+ *                 protege es el importe único y el secreto.
+ */
+export function buildNativeQuote(params) {
+    const now = params.nowS ?? Math.floor(Date.now() / 1000);
+    const deadline = now + QUOTE_TTL_S;
+    // De 1 a 1.048.576 unidades (2²⁰): menos de una millonésima de céntimo, y
+    // basta para que dos cotizaciones no pidan el mismo importe.
+    //
+    // Con una máscara y no con `%`: el rango es una potencia de dos, así que
+    // cada valor sale con la misma probabilidad. Con `% 999999` unos salían un
+    // poco más que otros (lo marcó CodeQL); aquí no importaba, porque solo hace
+    // falta que no se repita ni se adivine, pero sin sesgo no hay que pensarlo.
+    const azar = BigInt(1 + (crypto.getRandomValues(new Uint32Array(1))[0] & 0xfffff));
+    const amount = params.price + azar;
+    const payer = params.payer ? getAddress(params.payer) : ZERO;
+    return {
+        x402Version: X402_VERSION,
+        accepts: [
+            {
+                scheme: X402_NATIVE_SCHEME,
+                network: 'monad',
+                chainId: chainFor(params.network ?? 'mainnet').id,
+                asset: ZERO,
+                assetSymbol: 'MON',
+                amount: amount.toString(),
+                payTo: getAddress(params.payTo),
+                resource: params.resource,
+                description: params.description,
+                deadline,
+                maxTimeoutSeconds: 120,
+                paymentId: nativePaymentId(params.secret, { payer, payTo: params.payTo, amount, deadline, resource: params.resource }),
+            },
+        ],
+        hint: 'Send EXACTLY `amount` MON to `payTo` before `deadline`, then repeat the request with the header ' +
+            'X-Payment: base64({scheme:"native-transfer",payer,value,deadline,paymentId,txHash}).',
+    };
+}
+const ZERO = '0x0000000000000000000000000000000000000000';
+/**
+ * Lee X-Payment de los dos esquemas. Nunca lanza: devuelve el motivo.
+ *
+ * `parsePaymentHeader` sigue aceptando solo el permit, como antes, para que un
+ * agente que no sabe cobrar en MON no reciba un pago que no sabe comprobar.
+ */
+export function parseX402Header(header) {
+    const encoded = header.trim();
+    if (!/^[A-Za-z0-9+/_-]+={0,2}$/.test(encoded))
+        return { ok: false, error: 'the X-Payment header is not base64' };
+    let raw;
+    try {
+        raw = JSON.parse(Buffer.from(encoded, 'base64').toString('utf8'));
+    }
+    catch {
+        return { ok: false, error: 'the contents of X-Payment are not JSON' };
+    }
+    if (raw.scheme !== X402_NATIVE_SCHEME)
+        return parsePaymentHeader(header);
+    const { payer, value, deadline, paymentId, txHash } = raw;
+    if (typeof payer !== 'string' || !isAddress(payer))
+        return { ok: false, error: 'payer is not an address' };
+    const es32 = (x) => typeof x === 'string' && isHex(x) && x.length === 66;
+    if (!es32(paymentId))
+        return { ok: false, error: 'paymentId must be the 32-byte hex from the quote' };
+    if (!es32(txHash))
+        return { ok: false, error: 'txHash must be a 32-byte transaction hash' };
+    let valueBig;
+    let deadlineBig;
+    try {
+        valueBig = BigInt(String(value));
+        deadlineBig = BigInt(String(deadline));
+    }
+    catch {
+        return { ok: false, error: 'value and deadline must be integers' };
+    }
+    if (valueBig <= 0n)
+        return { ok: false, error: 'value must be greater than zero' };
+    return {
+        ok: true,
+        payment: {
+            scheme: X402_NATIVE_SCHEME,
+            payer: getAddress(payer),
+            value: valueBig,
+            deadline: deadlineBig,
+            paymentId: paymentId.toLowerCase(),
+            txHash: txHash.toLowerCase(),
+        },
+    };
+}
+/**
+ * Comprueba en la cadena un pago en MON. El recurso NO debe servirse hasta
+ * que esto salga bien. No hace falta wallet: el pago ya lo mandó el cliente.
+ */
+export async function verifyNativePayment(deps, payment, params) {
+    if (payment.value < params.price) {
+        return { ok: false, status: 402, error: `the payment (${payment.value}) is less than the price (${params.price})` };
+    }
+    // El código de pago se rehace con lo que dice el pago. Si alguien cambia el
+    // importe, la caducidad o el pagador, o presenta una cotización de otra
+    // pregunta, no cuadra. Se prueba también sin pagador: la cotización se pudo
+    // pedir sin decir quién pagaría.
+    const datos = { payTo: deps.payee, amount: payment.value, deadline: Number(payment.deadline), resource: params.resource };
+    const esperado = [payment.payer, ZERO].map((payer) => nativePaymentId(deps.secret, { ...datos, payer }));
+    if (!esperado.includes(payment.paymentId.toLowerCase())) {
+        return { ok: false, status: 402, error: 'unknown or altered quote: ask for a new one and pay exactly what it says' };
+    }
+    const nowS = deps.nowS ?? Math.floor(Date.now() / 1000);
+    if (BigInt(nowS) > payment.deadline + BigInt(NATIVE_GRACE_S)) {
+        return { ok: false, status: 402, error: 'the quote has expired' };
+    }
+    if (deps.used.has(payment.txHash)) {
+        return { ok: false, status: 409, error: 'this payment was already used' };
+    }
+    // El nodo puede tardar un instante en ver una transacción recién minada.
+    const hasta = Date.now() + (deps.waitMs ?? 6_000);
+    let recibo = null;
+    for (;;) {
+        recibo = await deps.publicClient.getTransactionReceipt({ hash: payment.txHash }).catch(() => null);
+        if (recibo || Date.now() >= hasta)
+            break;
+        await new Promise((r) => setTimeout(r, 750));
+    }
+    if (!recibo)
+        return { ok: false, status: 402, error: 'the payment transaction is not on chain yet' };
+    if (recibo.status !== 'success')
+        return { ok: false, status: 402, error: 'the payment transaction reverted' };
+    const tx = await deps.publicClient.getTransaction({ hash: payment.txHash });
+    if (!isAddressEqual(tx.from, payment.payer)) {
+        return { ok: false, status: 402, error: 'the payment was sent by someone else' };
+    }
+    if (!tx.to || !isAddressEqual(tx.to, deps.payee)) {
+        return { ok: false, status: 402, error: 'the payment was not sent to this agent' };
+    }
+    if (tx.value !== payment.value) {
+        return { ok: false, status: 402, error: `the payment sent ${tx.value}, and the quote asked for exactly ${payment.value}` };
+    }
+    const bloque = await deps.publicClient.getBlock({ blockNumber: recibo.blockNumber });
+    if (bloque.timestamp > payment.deadline) {
+        return { ok: false, status: 402, error: 'the payment arrived after the quote expired' };
+    }
+    if (bloque.timestamp + BigInt(QUOTE_TTL_S + 60) < payment.deadline) {
+        return { ok: false, status: 402, error: 'the payment is older than the quote' };
+    }
+    // Se marca ANTES de servir: dos peticiones con la misma transacción a la
+    // vez no pueden pasar las dos.
+    if (deps.used.has(payment.txHash))
+        return { ok: false, status: 409, error: 'this payment was already used' };
+    deps.used.add(payment.txHash);
+    return { ok: true, txHash: payment.txHash, amount: tx.value };
+}

package/dist/x402.d.ts

@@ -18,7 +18,8 @@
 import type { Account, Address, Hex, WalletClient } from 'viem';
 import { type UrlGuardOptions } from './net.js';
 import { type CallEnvelope } from './envelope.js';
-/** El único esquema que entiende este cliente. Debe coincidir con el servidor. */
+import { type X402Currency } from './currencies.js';
+/** El esquema de las monedas con `permit`. Debe coincidir con el servidor. */
 export declare const X402_SCHEME = "eip2612-permit";
 export interface PermitDomain {
     name: string;
@@ -40,7 +41,10 @@ export interface X402Accept {
     deadline: number;
     maxTimeoutSeconds?: number;
     payerNonce?: string;
-    domain: PermitDomain;
+    /** Solo en las de `permit`: el dominio con el que firmar. */
+    domain?: PermitDomain;
+    /** Solo en MON: el código de esta cotización, que se presenta con el pago. */
+    paymentId?: Hex;
 }
 export interface X402Quote {
     x402Version?: number;
@@ -88,6 +92,8 @@ export interface AskResult {
     answer: string;
     /** Lo que se ha pagado de verdad, en unidades mínimas. */
     paid: bigint;
+    /** En qué, con su nombre y decimales de la lista de Panal (no de la cotización). */
+    currency: X402Currency;
     /** Quién ha cobrado. */
     payee: Address;
     /** Transacción del cobro, si el servidor la reporta. */

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.3",
+  "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"
   }
 }