panal-mcp 0.7.0 → 0.8.0

package/README.md

@@ -66,7 +66,9 @@ Las herramientas de escritura mueven dinero real en mainnet, así que están **a
         "MCP_ENABLE_WRITES": "true",
         "MCP_PRIVATE_KEY": "0x…",
         "MCP_MAX_PER_TASK_WEI": "1000000000000000000",
-        "MCP_DAILY_BUDGET_WEI": "5000000000000000000"
+        "MCP_DAILY_BUDGET_WEI": "5000000000000000000",
+        "MCP_MAX_PER_TASK_PANAL_WEI": "3000000000000000000",
+        "MCP_DAILY_BUDGET_PANAL_WEI": "10000000000000000000"
       }
     }
   }
@@ -79,8 +81,17 @@ Las herramientas de escritura mueven dinero real en mainnet, así que están **a
 |---|---|---|
 | `MCP_ENABLE_WRITES` | `false` | Interruptor general |
 | `MCP_PRIVATE_KEY` | — | Wallet del cliente que paga |
-| `MCP_MAX_PER_TASK_WEI` | `1e18` (1 MON) | Tope por encargo |
-| `MCP_DAILY_BUDGET_WEI` | `5e18` (5 MON) | Tope por día UTC, persistido en disco |
+| `MCP_MAX_PER_TASK_WEI` | `1e18` (1 MON) | Tope por encargo, **en MON** |
+| `MCP_DAILY_BUDGET_WEI` | `5e18` (5 MON) | Tope por día UTC **en MON**, persistido en disco |
+| `MCP_MAX_PER_TASK_PANAL_WEI` | `1e18` (1 $PANAL) | Tope por encargo, **en $PANAL** |
+| `MCP_DAILY_BUDGET_PANAL_WEI` | `5e18` (5 $PANAL) | Tope por día UTC **en $PANAL** |
+
+**Cada moneda lleva su cuenta.** Panal cobra en MON nativo y en $PANAL, que no valen lo
+mismo y no tienen tipo de cambio entre sí: sumarlos en un solo número sería inventarse
+la conversión. Con un contador único, tres consultas pagadas en $PANAL agotaban un
+presupuesto puesto pensando en MON y bloqueaban una contratación que iba sobrada. Si un
+agente cobra en un token que no es ninguno de los dos, el servidor **se niega** en vez de
+tirar del presupuesto de otra moneda.
 | `MCP_TASK_DEADLINE_HOURS` | `24` | Plazo de entrega |
 | `MCP_SPEND_FILE` | `.panal-mcp/spend.json` | Dónde se guarda el gasto del día |
 | `RPC_URL` | RPC público de Monad | Tu propio RPC |

package/dist/limits.d.ts

@@ -52,11 +52,20 @@ export declare class QuoteBook {
     private prune;
 }
 /**
- * Registro de gasto diario, persistido en disco.
+ * Registro de gasto diario, persistido en disco y SEPARADO POR MONEDA.
  *
  * Un tope que se borra al reiniciar no es un tope: bastaría con reiniciar el
  * servidor para volver a gastar el presupuesto entero. Se guarda el día UTC
- * junto al importe, así que el contador se reinicia solo al cambiar de día.
+ * junto a los importes, así que el contador se reinicia solo al cambiar de día.
+ *
+ * POR QUÉ POR MONEDA
+ *
+ * Antes había un solo número. Panal cobra en dos monedas —MON nativo y $PANAL—
+ * y no hay tipo de cambio entre ellas, así que sumarlas era inventárselo: tres
+ * consultas de $PANAL agotaban un presupuesto puesto pensando en MON, y al
+ * revés, un tope generoso en $PANAL abría la mano con el MON sin que nadie lo
+ * hubiera decidido. La cuenta protegía de más, que es el lado bueno del fallo,
+ * pero un tope que no significa lo que dice no se puede ajustar.
  */
 export declare class SpendLedger {
     private readonly file;
@@ -64,12 +73,31 @@ export declare class SpendLedger {
     constructor(file: string, onWarn: (msg: string) => void);
     static defaultFile(): string;
     private static utcDay;
-    spentToday(): bigint;
-    record(wei: bigint): void;
+    /** Todo lo gastado hoy, por moneda. Vacío si el archivo es de otro día. */
+    private leer;
+    spentToday(currency: Address): bigint;
+    record(currency: Address, wei: bigint): void;
 }
-export interface Limits {
+/** El tope de una moneda concreta. */
+export interface CurrencyLimit {
     maxPerTaskWei: bigint;
     dailyBudgetWei: bigint;
+    /** El nombre de la variable de entorno, para poder decirle a alguien cuál subir. */
+    envMaxPerTask: string;
+    envDailyBudget: string;
+}
+export interface Limits {
     deadlineHours: number;
+    /** Topes por moneda, indexados por dirección en minúsculas. */
+    porMoneda: Map<string, CurrencyLimit>;
 }
+/**
+ * El tope de una moneda, o `null` si no hay ninguno puesto para ella.
+ *
+ * `null` significa NO HAY PRESUPUESTO, y quien llame debe negarse. Es
+ * deliberado: la alternativa sería reutilizar el tope de otra moneda, y eso
+ * exige un tipo de cambio que nadie tiene. Un agente que cobre en un token
+ * desconocido no se contrata hasta que alguien decida cuánto vale.
+ */
+export declare function limitFor(limits: Limits, currency: Address): CurrencyLimit | null;
 export declare function limitsFromEnv(): Limits;

package/dist/limits.js

@@ -57,12 +57,25 @@ export class QuoteBook {
                 this.quotes.delete(id);
     }
 }
+/** Clave de un contador: la dirección de la moneda, en minúsculas. */
+function clave(currency) {
+    return currency.toLowerCase();
+}
 /**
- * Registro de gasto diario, persistido en disco.
+ * Registro de gasto diario, persistido en disco y SEPARADO POR MONEDA.
  *
  * Un tope que se borra al reiniciar no es un tope: bastaría con reiniciar el
  * servidor para volver a gastar el presupuesto entero. Se guarda el día UTC
- * junto al importe, así que el contador se reinicia solo al cambiar de día.
+ * junto a los importes, así que el contador se reinicia solo al cambiar de día.
+ *
+ * POR QUÉ POR MONEDA
+ *
+ * Antes había un solo número. Panal cobra en dos monedas —MON nativo y $PANAL—
+ * y no hay tipo de cambio entre ellas, así que sumarlas era inventárselo: tres
+ * consultas de $PANAL agotaban un presupuesto puesto pensando en MON, y al
+ * revés, un tope generoso en $PANAL abría la mano con el MON sin que nadie lo
+ * hubiera decidido. La cuenta protegía de más, que es el lado bueno del fallo,
+ * pero un tope que no significa lo que dice no se puede ajustar.
  */
 export class SpendLedger {
     file;
@@ -77,27 +90,55 @@ export class SpendLedger {
     static utcDay() {
         return new Date().toISOString().slice(0, 10);
     }
-    spentToday() {
+    /** Todo lo gastado hoy, por moneda. Vacío si el archivo es de otro día. */
+    leer() {
+        const out = new Map();
         try {
             const raw = JSON.parse(readFileSync(this.file, 'utf8'));
             if (raw.day !== SpendLedger.utcDay())
-                return 0n;
-            return BigInt(raw.spentWei ?? '0');
+                return out;
+            // Formato antiguo: un solo número, sin moneda. Era el gasto de todo, pero
+            // en la práctica el que llevaba la cuenta era el nativo, así que se
+            // adopta ahí. Perderlo dejaría el tope del día a cero tras actualizar.
+            if (typeof raw.spentWei === 'string' && !raw.spent) {
+                try {
+                    out.set(clave(NATIVO), BigInt(raw.spentWei));
+                }
+                catch {
+                    /* ilegible: se ignora */
+                }
+                return out;
+            }
+            for (const [k, v] of Object.entries(raw.spent ?? {})) {
+                try {
+                    out.set(k.toLowerCase(), BigInt(v));
+                }
+                catch {
+                    /* una entrada corrupta no invalida las demás */
+                }
+            }
         }
         catch {
             // Sin archivo, ilegible o corrupto: se empieza de cero. Nunca lanza,
             // porque un ledger roto no debe dejar el servidor inservible.
-            return 0n;
         }
+        return out;
     }
-    record(wei) {
-        const total = this.spentToday() + wei;
+    spentToday(currency) {
+        return this.leer().get(clave(currency)) ?? 0n;
+    }
+    record(currency, wei) {
+        const todo = this.leer();
+        todo.set(clave(currency), (todo.get(clave(currency)) ?? 0n) + wei);
+        const spent = {};
+        for (const [k, v] of todo)
+            spent[k] = v.toString();
         try {
             mkdirSync(dirname(this.file), { recursive: true });
             // Escritura atómica: un corte a media escritura dejaría un JSON truncado
             // que se leería como 0 y borraría el tope del día.
             const tmp = `${this.file}.tmp`;
-            writeFileSync(tmp, JSON.stringify({ day: SpendLedger.utcDay(), spentWei: total.toString() }, null, 2));
+            writeFileSync(tmp, JSON.stringify({ day: SpendLedger.utcDay(), spent }, null, 2));
             renameSync(tmp, this.file);
         }
         catch (err) {
@@ -106,6 +147,21 @@ export class SpendLedger {
         }
     }
 }
+/** La moneda nativa en el escrow de Panal: la dirección cero. */
+const NATIVO = '0x0000000000000000000000000000000000000000';
+/** $PANAL en Monad mainnet. */
+const PANAL = '0x2e2e44e7fa6178822d4397299f719e89d1a67777';
+/**
+ * El tope de una moneda, o `null` si no hay ninguno puesto para ella.
+ *
+ * `null` significa NO HAY PRESUPUESTO, y quien llame debe negarse. Es
+ * deliberado: la alternativa sería reutilizar el tope de otra moneda, y eso
+ * exige un tipo de cambio que nadie tiene. Un agente que cobre en un token
+ * desconocido no se contrata hasta que alguien decida cuánto vale.
+ */
+export function limitFor(limits, currency) {
+    return limits.porMoneda.get(clave(currency)) ?? null;
+}
 export function limitsFromEnv() {
     const parse = (name, fallback) => {
         const raw = process.env[name]?.trim();
@@ -120,9 +176,22 @@ export function limitsFromEnv() {
         }
     };
     const hours = Number(process.env.MCP_TASK_DEADLINE_HOURS?.trim() || '24');
-    return {
-        maxPerTaskWei: parse('MCP_MAX_PER_TASK_WEI', 10n ** 18n), // 1 MON / $PANAL
+    const porMoneda = new Map();
+    // MON conserva los nombres de siempre: quien ya tenía un .env sigue
+    // significando exactamente lo que creía.
+    porMoneda.set(clave(NATIVO), {
+        maxPerTaskWei: parse('MCP_MAX_PER_TASK_WEI', 10n ** 18n),
         dailyBudgetWei: parse('MCP_DAILY_BUDGET_WEI', 5n * 10n ** 18n),
-        deadlineHours: Number.isFinite(hours) && hours > 0 ? hours : 24,
-    };
+        envMaxPerTask: 'MCP_MAX_PER_TASK_WEI',
+        envDailyBudget: 'MCP_DAILY_BUDGET_WEI',
+    });
+    // $PANAL estrena las suyas, con los mismos números de antes. No se copian de
+    // MON porque no valen lo mismo: son dos presupuestos que se ajustan aparte.
+    porMoneda.set(clave(PANAL), {
+        maxPerTaskWei: parse('MCP_MAX_PER_TASK_PANAL_WEI', 10n ** 18n),
+        dailyBudgetWei: parse('MCP_DAILY_BUDGET_PANAL_WEI', 5n * 10n ** 18n),
+        envMaxPerTask: 'MCP_MAX_PER_TASK_PANAL_WEI',
+        envDailyBudget: 'MCP_DAILY_BUDGET_PANAL_WEI',
+    });
+    return { deadlineHours: Number.isFinite(hours) && hours > 0 ? hours : 24, porMoneda };
 }

package/dist/server.d.ts

@@ -13,8 +13,14 @@
  *   MCP_PRIVATE_KEY=0x…      wallet dedicada del CLIENTE, con fondos
  *
  * Topes (todos opcionales, con valores conservadores por defecto):
- *   MCP_MAX_PER_TASK_WEI     por encargo    (default 1e18 = 1 MON/$PANAL)
- *   MCP_DAILY_BUDGET_WEI     por día UTC    (default 5e18)
+ *   MCP_MAX_PER_TASK_WEI          por encargo, en MON      (default 1e18)
+ *   MCP_DAILY_BUDGET_WEI          por día UTC, en MON      (default 5e18)
+ *   MCP_MAX_PER_TASK_PANAL_WEI    por encargo, en $PANAL   (default 1e18)
+ *   MCP_DAILY_BUDGET_PANAL_WEI    por día UTC, en $PANAL   (default 5e18)
+ *
+ * Cada moneda lleva su cuenta. MON y $PANAL no valen lo mismo y no hay tipo de
+ * cambio entre ellos, así que un solo contador para los dos era una suma
+ * inventada: gastar en una agotaba el presupuesto de la otra.
  *   MCP_TASK_DEADLINE_HOURS  plazo de entrega (default 24)
  *   MCP_SPEND_FILE           dónde persistir el gasto del día
  *

package/dist/server.js

@@ -13,8 +13,14 @@
  *   MCP_PRIVATE_KEY=0x…      wallet dedicada del CLIENTE, con fondos
  *
  * Topes (todos opcionales, con valores conservadores por defecto):
- *   MCP_MAX_PER_TASK_WEI     por encargo    (default 1e18 = 1 MON/$PANAL)
- *   MCP_DAILY_BUDGET_WEI     por día UTC    (default 5e18)
+ *   MCP_MAX_PER_TASK_WEI          por encargo, en MON      (default 1e18)
+ *   MCP_DAILY_BUDGET_WEI          por día UTC, en MON      (default 5e18)
+ *   MCP_MAX_PER_TASK_PANAL_WEI    por encargo, en $PANAL   (default 1e18)
+ *   MCP_DAILY_BUDGET_PANAL_WEI    por día UTC, en $PANAL   (default 5e18)
+ *
+ * Cada moneda lleva su cuenta. MON y $PANAL no valen lo mismo y no hay tipo de
+ * cambio entre ellos, así que un solo contador para los dos era una suma
+ * inventada: gastar en una agotaba el presupuesto de la otra.
  *   MCP_TASK_DEADLINE_HOURS  plazo de entrega (default 24)
  *   MCP_SPEND_FILE           dónde persistir el gasto del día
  *
@@ -29,7 +35,7 @@ import { fileURLToPath } from 'node:url';
 import { formatEther, isAddress, keccak256, parseEther, toBytes } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 import { NATIVE_CURRENCY, TaskStatus, createPanalClient, } from '@panal/sdk';
-import { QuoteBook, SpendLedger, limitsFromEnv } from './limits.js';
+import { QuoteBook, SpendLedger, limitFor, limitsFromEnv } from './limits.js';
 import { briefSignMessage, expiraEn, fetchAgentLimits, fetchResultText, pushBrief, resultSignMessage, } from './fetch-result.js';
 const SERVER_NAME = 'panal';
 /**
@@ -91,6 +97,34 @@ function writesBlockedReason() {
 function symbolOf(currency) {
     return currency.toLowerCase() === NATIVE_CURRENCY.toLowerCase() ? 'MON' : '$PANAL';
 }
+/**
+ * ¿Cabe este gasto en el presupuesto de SU moneda? Devuelve el motivo, o null.
+ *
+ * Cada moneda lleva su cuenta. Sumar MON y $PANAL en un solo número exigiría un
+ * tipo de cambio que nadie tiene, y el resultado era que tres consultas de
+ * $PANAL agotaban un tope puesto pensando en MON.
+ *
+ * Sin presupuesto para una moneda, se dice que no. La alternativa —tirar del
+ * tope de otra— es exactamente la conversión a ojo que este cambio elimina.
+ */
+function revisarPresupuesto(currency, amount, symbol) {
+    const lim = limitFor(limits, currency);
+    if (!lim) {
+        return (`That agent charges in a token this server has no budget for (${currency}). ` +
+            'Only MON and $PANAL have caps configured; there is no exchange rate to reuse another one.');
+    }
+    if (amount > lim.maxPerTaskWei) {
+        return (`That costs ${formatEther(amount)} ${symbol} and the per-item cap for ${symbol} is ` +
+            `${formatEther(lim.maxPerTaskWei)}. Raise ${lim.envMaxPerTask} if that is intended.`);
+    }
+    const spent = ledger.spentToday(currency);
+    if (spent + amount > lim.dailyBudgetWei) {
+        return (`That would blow today's ${symbol} budget: ${formatEther(spent)} of ` +
+            `${formatEther(lim.dailyBudgetWei)} spent and this costs ${formatEther(amount)} ${symbol}. ` +
+            `Raise ${lim.envDailyBudget} if that is intended.`);
+    }
+    return null;
+}
 /** Días desde un timestamp en segundos. */
 function daysSince(ts) {
     return Math.max(0, Math.floor(Date.now() / 1000 - ts) / 86_400);
@@ -344,8 +378,16 @@ const WRITE_TOOLS = [
             if (blocked)
                 return blocked;
             const address = account.address;
-            const [balance, spent] = [await panal.publicClient.getBalance({ address }), ledger.spentToday()];
-            const left = limits.dailyBudgetWei > spent ? limits.dailyBudgetWei - spent : 0n;
+            const balance = await panal.publicClient.getBalance({ address });
+            // Un presupuesto por moneda: MON y $PANAL no valen lo mismo y no hay
+            // tipo de cambio, así que se enseñan por separado o no se entienden.
+            const presupuestos = [...limits.porMoneda.entries()].map(([moneda, lim]) => {
+                const spent = ledger.spentToday(moneda);
+                const left = lim.dailyBudgetWei > spent ? lim.dailyBudgetWei - spent : 0n;
+                const sym = symbolOf(moneda);
+                return (`  ${sym}: per job ${formatEther(lim.maxPerTaskWei)} · today ${formatEther(spent)} of ` +
+                    `${formatEther(lim.dailyBudgetWei)} spent · ${formatEther(left)} left`);
+            });
             // Lo acreditado en el escrow no aparece en el balance de la wallet: es
             // pull payment, así que un reembolso se queda ahí quieto hasta que se
             // reclama. Sin decirlo, el dinero devuelto es indistinguible del perdido.
@@ -353,8 +395,8 @@ const WRITE_TOOLS = [
             return [
                 `Wallet: ${address}`,
                 `Balance: ${formatEther(balance)} MON`,
-                `Per-job cap: ${formatEther(limits.maxPerTaskWei)}`,
-                `Today's budget: spent ${formatEther(spent)} of ${formatEther(limits.dailyBudgetWei)} · ${formatEther(left)} left`,
+                'Caps and budgets (each currency is counted on its own):',
+                ...presupuestos,
                 pending > 0n
                     ? `Waiting in the escrow: ${formatEther(pending)} MON — collect it with panal_withdraw`
                     : null,
@@ -390,15 +432,9 @@ const WRITE_TOOLS = [
                 return `${agent.metadata.name || address} is delisted and does not take jobs.`;
             const amount = agent.pricePerTask;
             const symbol = symbolOf(agent.currency);
-            if (amount > limits.maxPerTaskWei) {
-                return (`That agent charges ${formatEther(amount)} ${symbol} and this server per-job cap is ` +
-                    `${formatEther(limits.maxPerTaskWei)}. It cannot be hired unless the person raises MCP_MAX_PER_TASK_WEI.`);
-            }
-            const spent = ledger.spentToday();
-            if (spent + amount > limits.dailyBudgetWei) {
-                return (`That would blow today's budget: ${formatEther(spent)} of ${formatEther(limits.dailyBudgetWei)} spent ` +
-                    `and this costs ${formatEther(amount)} ${symbol}.`);
-            }
+            const negativa = revisarPresupuesto(agent.currency, amount, symbol);
+            if (negativa)
+                return negativa;
             // El tope del brief se pregunta ANTES de presupuestar. Si no cabe, el
             // agente lo rechazaría con un 400 al recibirlo — pero eso ocurre ya con
             // el pago bloqueado, porque el encargo se entrega después de crear la
@@ -476,22 +512,17 @@ const WRITE_TOOLS = [
             const quote = redeemed.quote;
             // Los mismos topes que contratar. Una consulta es barata, pero nada
             // impide encadenar mil: el presupuesto del día es lo que lo impide.
-            if (quote.amount > limits.maxPerTaskWei) {
-                return (`That question costs ${formatEther(quote.amount)} ${quote.symbol} and this server per-item cap is ` +
-                    `${formatEther(limits.maxPerTaskWei)}. Raise MCP_MAX_PER_TASK_WEI if that is intended.`);
-            }
-            const spent = ledger.spentToday();
-            if (spent + quote.amount > limits.dailyBudgetWei) {
-                return (`That would blow today's budget: ${formatEther(spent)} of ${formatEther(limits.dailyBudgetWei)} spent ` +
-                    `and this costs ${formatEther(quote.amount)} ${quote.symbol}.`);
-            }
+            const negativa = revisarPresupuesto(quote.currency, quote.amount, quote.symbol);
+            if (negativa)
+                return negativa;
             try {
                 // `maxSpend` va atado al importe del presupuesto que la persona
                 // aprobó, no al tope del servidor: si el agente sube el precio entre
                 // el presupuesto y el sí, la firma no se produce.
                 const res = await panal.askAgent(quote.worker, quote.brief, { maxSpend: quote.amount });
-                // Se registra lo REALMENTE pagado, que es lo que devuelve el SDK.
-                ledger.record(res.paid);
+                // Se registra lo REALMENTE pagado, y en SU moneda: un gasto anotado en
+                // el contador equivocado agota un presupuesto que nadie tocó.
+                ledger.record(quote.currency, res.paid);
                 log(`consulta pagada a ${quote.worker}: ${formatEther(res.paid)} ${quote.symbol}`);
                 return [
                     `Paid ${formatEther(res.paid)} ${quote.symbol} to ${quote.agentName}.`,
@@ -541,14 +572,13 @@ const WRITE_TOOLS = [
             const quote = redeemed.quote;
             // Los topes se re-evalúan al contratar: entre el presupuesto y el "sí"
             // pueden haber pasado minutos y otros encargos.
-            const spent = ledger.spentToday();
-            if (spent + quote.amount > limits.dailyBudgetWei) {
-                return `Today's budget ran out in the meantime (${formatEther(spent)} of ${formatEther(limits.dailyBudgetWei)}).`;
-            }
+            const negativa = revisarPresupuesto(quote.currency, quote.amount, quote.symbol);
+            if (negativa)
+                return negativa;
             const deadline = BigInt(Math.floor(Date.now() / 1000) + limits.deadlineHours * 3600);
             try {
                 const result = await panal.hire({ agent: quote.worker, brief: quote.brief, deadline });
-                ledger.record(result.amount);
+                ledger.record(quote.currency, result.amount);
                 log(`contratada #${result.taskId} a ${quote.worker} por ${formatEther(result.amount)} ${quote.symbol}`);
                 // Contratar sin entregar el encargo deja la tarea a medias: el pago
                 // bloqueado y el agente esperando un texto que nadie le manda. Se hace

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "panal-mcp",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Servidor MCP de Panal: busca y contrata agentes de IA on-chain desde Claude",
   "type": "module",
   "license": "MIT",
@@ -41,7 +41,7 @@
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "start": "tsx src/server.ts",
-    "test": "tsx test/mcp.test.ts",
+    "test": "tsx test/mcp.test.ts && tsx test/limites.test.ts && tsx test/monedas.test.ts",
     "test:limites": "tsx test/limites.test.ts"
   }
 }