@panal/sdk 0.19.1 → 0.21.0

package/dist/ejemplos.js

@@ -0,0 +1,160 @@
+/**
+ * Panal — los encargos de ejemplo de un agente.
+ *
+ * Un token más de los que viven en el `metadataURI` on-chain, junto a `bot:`,
+ * los de marca, los de nivel y el de tipo:
+ *
+ *     Lint · Revisa código · solidity · bot:https://… · ejemplo:Revisa este contrato ERC-20
+ *
+ * POR QUÉ EXISTE
+ *
+ * Al contratar, debajo de la caja del encargo salían cuatro ejemplos fijos
+ * («Audita este contrato», «Resume este PDF»…) para CUALQUIER agente: a uno de
+ * traducción le proponían auditar un contrato. Se quitaron. Lo que los
+ * sustituye son los del propio agente, escritos por quien sabe qué hace.
+ *
+ * POR QUÉ EN LA CADENA Y NO SOLO EN LA FICHA DEL BOT
+ *
+ * Por lo mismo que los niveles (ver `niveles.ts`): así los escribe también
+ * quien no programa —una persona que trabaja desde el buzón no tiene servidor
+ * donde ponerlos—, se editan desde el panel o desde la app, y siguen ahí con
+ * el bot caído. La ficha del bot los repite traducidos (`examples`), porque la
+ * cadena guarda una sola versión y la traducción solo puede vivir allí.
+ *
+ * POR QUÉ LA CLAVE SE RECONOCE TAN ESTRICTA
+ *
+ * Un ejemplo es texto libre, así que no hay valor que validar como el precio
+ * de un nivel. Lo que separa un token de una frase es la forma de la clave:
+ * `ejemplo:` en minúsculas y pegada al texto, que es como la escribe
+ * `componerEjemplo`. Una descripción que diga «Ejemplo: traduzco tu web» —con
+ * mayúscula, o con espacio tras los dos puntos— se queda como descripción. Si
+ * bastara con ver la palabra, esa frase desaparecería de la ficha de su dueño
+ * y saldría como un botón.
+ *
+ * LO QUE UN EJEMPLO NO ES
+ *
+ * No es un encargo ya escrito que se pague tal cual. Al pulsarlo se copia en
+ * la caja para que el cliente lo complete con lo suyo —el contrato, el texto,
+ * los datos—, y lo que se ancla en la cadena es lo que el cliente envía.
+ */
+/** Cuántos ofrece el formulario, y cuántos se leen. Más no caben bajo la caja. */
+export const EJEMPLOS_EDITABLES = 3;
+/** Tope de cada ejemplo, en caracteres. Una frase, no un encargo. */
+export const MAX_EJEMPLO = 140;
+/** La clave tal y como se escribe. Ver arriba por qué se compara exacta. */
+const CLAVE = 'ejemplo:';
+/** Espacios colapsados y recortado: va a un botón de un escaparate. */
+function limpiar(texto) {
+    return texto.replace(/\s+/g, ' ').trim();
+}
+/**
+ * `ejemplo:Revisa este contrato` → `'Revisa este contrato'`, o `null` si el
+ * segmento no es un ejemplo.
+ *
+ * Devolver `null` es lo normal: por aquí pasan TODOS los segmentos de la
+ * ficha, incluida la descripción libre del agente.
+ */
+export function leerEjemploDeSegmento(segmento) {
+    const s = segmento.trim();
+    if (!s.startsWith(CLAVE))
+        return null;
+    const resto = s.slice(CLAVE.length);
+    // Con espacio tras los dos puntos es prosa, no un token: ver arriba.
+    if (!resto || /^\s/.test(resto))
+        return null;
+    const texto = limpiar(resto).slice(0, MAX_EJEMPLO);
+    return texto || null;
+}
+/** true si este segmento es un ejemplo. Para que los lectores de ficha lo aparten. */
+export function esTokenDeEjemplo(segmento) {
+    return leerEjemploDeSegmento(segmento) !== null;
+}
+/**
+ * Los ejemplos que un agente publica en la cadena, en el orden en que los
+ * escribió. `[]` es lo normal.
+ *
+ * Los repetidos se quedan en uno: dos botones iguales no son dos ideas.
+ */
+export function leerEjemplosDeMetadata(metadataURI) {
+    if (!metadataURI)
+        return [];
+    const out = [];
+    for (const segmento of metadataURI.split('·')) {
+        if (out.length >= EJEMPLOS_EDITABLES)
+            break;
+        const ejemplo = leerEjemploDeSegmento(segmento);
+        if (ejemplo && !out.includes(ejemplo))
+            out.push(ejemplo);
+    }
+    return out;
+}
+/**
+ * Qué le pasa a lo que alguien escribe, para poder decírselo.
+ *
+ * `null` es que está bien o que está vacío. Un «·» partiría la ficha en dos y
+ * el trozo de después saldría como una skill; demasiado largo se recortaría
+ * sin avisar. En los dos casos se firmaría algo distinto de lo que su dueño
+ * ve, así que se canta antes.
+ */
+export function falloDeEjemplo(texto) {
+    const t = limpiar(texto);
+    if (!t)
+        return null;
+    if (t.includes('·'))
+        return 'separador';
+    if (t.length > MAX_EJEMPLO)
+        return 'largo';
+    return null;
+}
+/**
+ * El texto → su segmento, o `null` si no se puede escribir tal cual.
+ *
+ * `null` en vez de arreglarlo: quien llama tiene que enseñar el error, no
+ * firmar una ficha que su dueño no reconoce. Vacío también es `null`, y eso
+ * es lo normal: el formulario enseña tres y casi nadie rellena las tres.
+ */
+export function componerEjemplo(texto) {
+    const t = limpiar(texto);
+    if (!t || falloDeEjemplo(t) !== null)
+        return null;
+    return `${CLAVE}${t}`;
+}
+/**
+ * Los ejemplos de la ficha que sirve el agente (`examples`), ya saneados.
+ *
+ * Esa ficha la escribe un servidor ajeno: se aceptan solo cadenas, se limpian
+ * y se recortan, y se leen como mucho los mismos que caben en la cadena.
+ */
+export function leerEjemplos(card) {
+    const lista = card?.examples;
+    if (!Array.isArray(lista))
+        return [];
+    const out = [];
+    for (const e of lista) {
+        if (out.length >= EJEMPLOS_EDITABLES)
+            break;
+        if (typeof e !== 'string')
+            continue;
+        const t = limpiar(e).slice(0, MAX_EJEMPLO);
+        if (t && !out.includes(t))
+            out.push(t);
+    }
+    return out;
+}
+/**
+ * Los de la cadena, con el texto —traducido— de la ficha cuando cuadra.
+ *
+ * La cadena guarda una sola versión, en el idioma de su dueño. La ficha que
+ * sirve el agente los repite traducidos al idioma pedido, en el mismo orden.
+ * Se usan los de la ficha solo si son LOS MISMOS en número: si no cuadran, la
+ * ficha está desfasada respecto a la cadena (el agente la relee cada pocos
+ * minutos) y se enseñan los de la cadena, que son los vigentes.
+ *
+ * Sin nada en la cadena valen los de la ficha: un ejemplo no mueve dinero, y
+ * un agente puede declararlos solo en su código.
+ */
+export function conEjemplosDeLaFicha(enCadena, deLaFicha) {
+    if (enCadena.length === 0)
+        return deLaFicha;
+    return deLaFicha.length === enCadena.length ? deLaFicha : enCadena;
+}

package/dist/index.d.ts

@@ -45,8 +45,14 @@ export type { AgentCard, FichaGetResult, FichaNivel, FichaPostAttachment, FichaP
 export { componerNivel, conTextoDeLaFicha, esTokenDeNivel, leerNivelDeSegmento, leerNivelesDeMetadata, NIVELES_EDITABLES, precioAWei, weiAPrecio, } from './niveles.js';
 export { esTokenDeTipo, leerTipo, leerTipoDeSegmento, tokenDeTipo } from './tipo.js';
 export type { TipoDeAgente } from './tipo.js';
+export { componerEjemplo, conEjemplosDeLaFicha, EJEMPLOS_EDITABLES, esTokenDeEjemplo, falloDeEjemplo, leerEjemploDeSegmento, leerEjemplos, leerEjemplosDeMetadata, MAX_EJEMPLO, } from './ejemplos.js';
 export { rutaDeAgente } from './net.js';
 export { BUZON_URL, TABLON, VENTANA_FIRMA_S, encargoSignMessage, entregaSignMessage, ofertaSignMessage, } from './tablon.js';
 export type { EncargoDelTablon } from './tablon.js';
 export { fichaEnIdioma, IDIOMAS, NOMBRE_IDIOMA, normalizarIdioma } from './idiomas.js';
 export type { Idioma } from './idiomas.js';
+export { MERCADO_PANAL, PRECIO_MAX_EDAD_S, PYTH_MONAD, PYTH_MON_USD, enDolares, esFresco, formatearDolares, leerPrecios, valorDeVenta, } from './precios.js';
+export type { FuentePrecio, MonedaConPrecio, OpcionesPrecios, Precio, Precios } from './precios.js';
+export { panalTablonAbi } from './tablon-abi.js';
+export { EstadoTablon, MARGEN_ASIGNACION_S, MAX_CATEGORIAS, MAX_OFERTAS, MAX_VENTANA_ELECCION_S, MIN_PLAZO_ENTREGA_S, ModoTablon, categoriasDeMascara, claveDeCampana, encargoDeLaCadena, idDeCampana, ofertaDeLaCadena, problemaAlPublicar, situacionDe, tablonEncargoSignMessage, tablonEntregaSignMessage, tablonResultadoSignMessage, } from './tablon-reglas.js';
+export type { EncargoConReglas, OfertaConReglas, PublicarEnElTablon, SituacionEnElTablon, } from './tablon-reglas.js';

package/dist/index.js

@@ -47,6 +47,9 @@ export { componerNivel, conTextoDeLaFicha, esTokenDeNivel, leerNivelDeSegmento,
 // Quién hay al otro lado: una persona o un programa. Va en la misma cadena que
 // los niveles, y por lo mismo lo tienen que reconocer todos los que la leen.
 export { esTokenDeTipo, leerTipo, leerTipoDeSegmento, tokenDeTipo } from './tipo.js';
+// Los encargos de ejemplo que un agente propone al contratarle. Viven en la
+// misma cadena que los niveles y el tipo, y la ficha del bot los traduce.
+export { componerEjemplo, conEjemplosDeLaFicha, EJEMPLOS_EDITABLES, esTokenDeEjemplo, falloDeEjemplo, leerEjemploDeSegmento, leerEjemplos, leerEjemplosDeMetadata, MAX_EJEMPLO, } from './ejemplos.js';
 // La ficha en el idioma de quien la lee. En idiomas.ts está por qué traduce el
 // propio agente y no un servicio de Panal.
 // Unir una ruta con la URL de un agente. Ver por qué en `net.ts`: un agente
@@ -57,3 +60,11 @@ export { rutaDeAgente } from './net.js';
 // —otro lenguaje, otro runtime— necesita producir exactamente estos bytes.
 export { BUZON_URL, TABLON, VENTANA_FIRMA_S, encargoSignMessage, entregaSignMessage, ofertaSignMessage, } from './tablon.js';
 export { fichaEnIdioma, IDIOMAS, NOMBRE_IDIOMA, normalizarIdioma } from './idiomas.js';
+// Cuánto vale en dólares lo que se paga en MON o en $PANAL. Solo fuera de la
+// cadena: los contratos no leen precios. Ver precios.ts y BOARD.md §11.
+export { MERCADO_PANAL, PRECIO_MAX_EDAD_S, PYTH_MONAD, PYTH_MON_USD, enDolares, esFresco, formatearDolares, leerPrecios, valorDeVenta, } from './precios.js';
+// El tablón con reglas: PanalTablon, delante del escrow. Los métodos están en
+// el cliente (`…BoardJob`); aquí, el ABI, los tipos y lo que se calcula sin la
+// cadena. Ver tablon-reglas.ts y contracts/BOARD.md.
+export { panalTablonAbi } from './tablon-abi.js';
+export { EstadoTablon, MARGEN_ASIGNACION_S, MAX_CATEGORIAS, MAX_OFERTAS, MAX_VENTANA_ELECCION_S, MIN_PLAZO_ENTREGA_S, ModoTablon, categoriasDeMascara, claveDeCampana, encargoDeLaCadena, idDeCampana, ofertaDeLaCadena, problemaAlPublicar, situacionDe, tablonEncargoSignMessage, tablonEntregaSignMessage, tablonResultadoSignMessage, } from './tablon-reglas.js';

package/dist/precios.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Panal — cuánto vale en dólares lo que se paga en MON o en $PANAL.
+ * ───────────────────────────────────────────────────────────────────────────
+ * POR QUÉ ESTÁ AQUÍ
+ * Nadie piensa en MON ni en $PANAL. Quien contrata quiere saber cuánto paga, y
+ * un agente si el encargo le cubre lo que le cuesta: un vídeo que cuesta $1-2
+ * de generar no se puede hacer por 100.000 $PANAL si eso son $0,60. Ver
+ * contracts/BOARD.md §11.
+ *
+ * SOLO FUERA DE LA CADENA. Los contratos no leen ningún precio y las cantidades
+ * on-chain siguen en MON o $PANAL: lo que se bloquea es lo que cobra el agente,
+ * se mueva el precio o no. Los dólares son para enseñar y para decidir.
+ *
+ * DE DÓNDE SALE CADA PRECIO
+ *
+ *   MON → USD    Pyth en Monad, EN LA CADENA (`getPriceUnsafe`), con su
+ *                `publishTime`. Si no responde o está viejo, CoinGecko.
+ *   $PANAL → MON La curva de nad.fun, EN LA CADENA (`getAmountOut` del
+ *                mercado de $PANAL). Si no responde, la API de nad.fun.
+ *   $PANAL → USD Lo anterior multiplicado.
+ *
+ * En la cadena primero: es el mismo RPC que ya usan la web, la app y los
+ * agentes, y no necesita claves. La API de nad.fun solo deja entrar a
+ * panal.lat, así que para la app y los agentes es un respaldo que puede fallar
+ * por CORS; desde Node no hay CORS.
+ *
+ * DOS PRECIOS DE $PANAL
+ *   - El de MERCADO, el que se enseña: el punto medio entre comprar y vender
+ *     una cantidad pequeña. Coincide con el que enseña nad.fun.
+ *   - El de VENTA (`valorDeVenta`): lo que daría vender ESA cantidad, con la
+ *     comisión de la curva y el impacto en el precio. Para un agente es el
+ *     honrado, porque es lo que cobraría de verdad.
+ *
+ * NUNCA UN NÚMERO VIEJO SIN DECIRLO. Cada precio lleva cuándo se publicó, y
+ * `enDolares` no devuelve nada si tiene más de cinco minutos.
+ */
+import { type Address, type Hex, type PublicClient } from 'viem';
+/** Pyth en Monad mainnet (contrato «pull»: alguien publica y queda guardado). */
+export declare const PYTH_MONAD: Address;
+/** El feed `Crypto.MON/USD` de Pyth. */
+export declare const PYTH_MON_USD: Hex;
+/**
+ * El mercado de $PANAL en la curva V2 de nad.fun. Si $PANAL se gradúa a un
+ * pool, `getAmountOut` deja de responder aquí y se usa la API, que sigue al
+ * token donde esté.
+ */
+export declare const MERCADO_PANAL: Address;
+/** $PANAL en Monad mainnet. */
+export declare const PANAL_TOKEN_MAINNET: Address;
+/** Pasado esto, un precio no se enseña (BOARD.md §14, decisión 11). */
+export declare const PRECIO_MAX_EDAD_S: number;
+export type FuentePrecio = 'pyth' | 'coingecko' | 'nadfun-curva' | 'nadfun-api';
+/** Un precio con su fecha: unix en segundos de cuando se publicó. */
+export interface Precio {
+    valor: number;
+    actualizado: number;
+    fuente: FuentePrecio;
+}
+export interface Precios {
+    /** Dólares por MON. */
+    mon: Precio | null;
+    /** MON por $PANAL, a precio de mercado. */
+    panalEnMon: Precio | null;
+    /** Dólares por $PANAL: los dos anteriores multiplicados, con la fecha del más viejo. */
+    panal: Precio | null;
+}
+export interface OpcionesPrecios {
+    /** Para las pruebas y para entornos sin `fetch` global. */
+    fetch?: typeof fetch;
+    /** Ahora, en segundos. Para las pruebas. */
+    ahora?: number;
+    /** Si no se pasa, el de mainnet. */
+    panalToken?: Address;
+    /** Cuánto esperar a cada fuente HTTP. */
+    timeoutMs?: number;
+}
+type Lector = Pick<PublicClient, 'readContract'>;
+/**
+ * Lee los precios de MON y de $PANAL.
+ *
+ * Nunca lanza: si una fuente cae se usa la otra, y si caen las dos ese precio
+ * queda en `null`. Un precio viejo SÍ se devuelve, con su fecha: quien enseña
+ * decide con `esFresco`, y `enDolares` ya lo hace.
+ */
+export declare function leerPrecios(lector: Lector, opciones?: OpcionesPrecios): Promise<Precios>;
+/** Si un precio se puede enseñar: existe y tiene menos de cinco minutos. */
+export declare function esFresco(p: Precio | null | undefined, ahora?: number, maxEdadS?: number): p is Precio;
+/** Las monedas que tienen precio aquí. Las estables (GHO, USDC, AUSD) ya son dólares. */
+export type MonedaConPrecio = 'MON' | '$PANAL';
+/**
+ * Cuántos dólares son `cantidad` unidades mínimas de `moneda` (18 decimales),
+ * con el precio de mercado. `null` si no hay precio o tiene más de 5 minutos.
+ */
+export declare function enDolares(cantidad: bigint, moneda: MonedaConPrecio, precios: Precios | null | undefined, ahora?: number): {
+    usd: number;
+    actualizado: number;
+    fuente: FuentePrecio;
+} | null;
+/**
+ * Lo que daría vender `cantidad` $PANAL ahora en la curva, en MON (wei): con
+ * la comisión y el impacto en el precio. Es lo que de verdad cobraría quien
+ * los vendiera. `null` si la curva no responde.
+ */
+export declare function valorDeVenta(lector: Lector, cantidad: bigint, panalToken?: Address): Promise<bigint | null>;
+/**
+ * «$0.075», «$0.0006», «$1.50». Por debajo de un dólar, dos cifras
+ * significativas: con decimales fijos, 100 $PANAL saldrían «$0.00».
+ */
+export declare function formatearDolares(usd: number, locale?: string): string;
+export {};

package/dist/precios.js

@@ -0,0 +1,247 @@
+/**
+ * Panal — cuánto vale en dólares lo que se paga en MON o en $PANAL.
+ * ───────────────────────────────────────────────────────────────────────────
+ * POR QUÉ ESTÁ AQUÍ
+ * Nadie piensa en MON ni en $PANAL. Quien contrata quiere saber cuánto paga, y
+ * un agente si el encargo le cubre lo que le cuesta: un vídeo que cuesta $1-2
+ * de generar no se puede hacer por 100.000 $PANAL si eso son $0,60. Ver
+ * contracts/BOARD.md §11.
+ *
+ * SOLO FUERA DE LA CADENA. Los contratos no leen ningún precio y las cantidades
+ * on-chain siguen en MON o $PANAL: lo que se bloquea es lo que cobra el agente,
+ * se mueva el precio o no. Los dólares son para enseñar y para decidir.
+ *
+ * DE DÓNDE SALE CADA PRECIO
+ *
+ *   MON → USD    Pyth en Monad, EN LA CADENA (`getPriceUnsafe`), con su
+ *                `publishTime`. Si no responde o está viejo, CoinGecko.
+ *   $PANAL → MON La curva de nad.fun, EN LA CADENA (`getAmountOut` del
+ *                mercado de $PANAL). Si no responde, la API de nad.fun.
+ *   $PANAL → USD Lo anterior multiplicado.
+ *
+ * En la cadena primero: es el mismo RPC que ya usan la web, la app y los
+ * agentes, y no necesita claves. La API de nad.fun solo deja entrar a
+ * panal.lat, así que para la app y los agentes es un respaldo que puede fallar
+ * por CORS; desde Node no hay CORS.
+ *
+ * DOS PRECIOS DE $PANAL
+ *   - El de MERCADO, el que se enseña: el punto medio entre comprar y vender
+ *     una cantidad pequeña. Coincide con el que enseña nad.fun.
+ *   - El de VENTA (`valorDeVenta`): lo que daría vender ESA cantidad, con la
+ *     comisión de la curva y el impacto en el precio. Para un agente es el
+ *     honrado, porque es lo que cobraría de verdad.
+ *
+ * NUNCA UN NÚMERO VIEJO SIN DECIRLO. Cada precio lleva cuándo se publicó, y
+ * `enDolares` no devuelve nada si tiene más de cinco minutos.
+ */
+import { formatUnits, parseEther } from 'viem';
+/** Pyth en Monad mainnet (contrato «pull»: alguien publica y queda guardado). */
+export const PYTH_MONAD = '0x2880aB155794e7179c9eE2e38200202908C17B43';
+/** El feed `Crypto.MON/USD` de Pyth. */
+export const PYTH_MON_USD = '0x31491744e2dbf6df7fcf4ac0820d18a609b49076d45066d3568424e62f686cd1';
+/**
+ * El mercado de $PANAL en la curva V2 de nad.fun. Si $PANAL se gradúa a un
+ * pool, `getAmountOut` deja de responder aquí y se usa la API, que sigue al
+ * token donde esté.
+ */
+export const MERCADO_PANAL = '0x9f3832732923252A21044F21eE6bd87F09514ae4';
+/** $PANAL en Monad mainnet. */
+export const PANAL_TOKEN_MAINNET = '0x2e2e44e7fa6178822d4397299f719e89d1a67777';
+/** Pasado esto, un precio no se enseña (BOARD.md §14, decisión 11). */
+export const PRECIO_MAX_EDAD_S = 5 * 60;
+const COINGECKO_MON = 'https://api.coingecko.com/api/v3/simple/price?ids=monad&vs_currencies=usd&include_last_updated_at=true';
+const NADFUN_MERCADO = 'https://api.nad.fun/agent/market/';
+const pythAbi = [
+    {
+        type: 'function',
+        name: 'getPriceUnsafe',
+        stateMutability: 'view',
+        inputs: [{ name: 'id', type: 'bytes32' }],
+        outputs: [
+            {
+                type: 'tuple',
+                components: [
+                    { name: 'price', type: 'int64' },
+                    { name: 'conf', type: 'uint64' },
+                    { name: 'expo', type: 'int32' },
+                    { name: 'publishTime', type: 'uint256' },
+                ],
+            },
+        ],
+    },
+];
+const curvaAbi = [
+    {
+        type: 'function',
+        name: 'getAmountOut',
+        stateMutability: 'view',
+        inputs: [
+            { name: 'token', type: 'address' },
+            { name: 'amountIn', type: 'uint256' },
+            { name: 'isBuy', type: 'bool' },
+        ],
+        outputs: [{ type: 'uint256' }],
+    },
+];
+const ahoraS = (o) => o?.ahora ?? Math.floor(Date.now() / 1000);
+async function getJson(url, o) {
+    const f = o?.fetch ?? fetch;
+    const r = await f(url, { signal: AbortSignal.timeout(o?.timeoutMs ?? 6000) });
+    if (!r.ok)
+        throw new Error(`HTTP ${r.status}`);
+    return r.json();
+}
+const numero = (v) => {
+    const n = typeof v === 'string' ? Number(v) : typeof v === 'number' ? v : NaN;
+    return Number.isFinite(n) && n > 0 ? n : null;
+};
+/** MON → USD de Pyth en la cadena. */
+async function monDePyth(lector) {
+    try {
+        const p = (await lector.readContract({
+            address: PYTH_MONAD,
+            abi: pythAbi,
+            functionName: 'getPriceUnsafe',
+            args: [PYTH_MON_USD],
+        }));
+        const valor = Number(p.price) * 10 ** p.expo;
+        return valor > 0 ? { valor, actualizado: Number(p.publishTime), fuente: 'pyth' } : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** MON → USD de CoinGecko. */
+async function monDeCoingecko(o) {
+    try {
+        const j = (await getJson(COINGECKO_MON, o));
+        const valor = numero(j.monad?.usd);
+        const actualizado = numero(j.monad?.last_updated_at);
+        return valor && actualizado ? { valor, actualizado, fuente: 'coingecko' } : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * $PANAL → MON en la curva: el punto medio entre comprar con 1 MON y vender
+ * 1.000 $PANAL. Las dos cantidades son ínfimas frente a las reservas, así que
+ * el impacto no cuenta y la media geométrica quita la comisión de la curva.
+ */
+async function panalDeCurva(lector, token, ahora) {
+    try {
+        const [comprados, monVenta] = await Promise.all([
+            lector.readContract({
+                address: MERCADO_PANAL,
+                abi: curvaAbi,
+                functionName: 'getAmountOut',
+                args: [token, parseEther('1'), true],
+            }),
+            lector.readContract({
+                address: MERCADO_PANAL,
+                abi: curvaAbi,
+                functionName: 'getAmountOut',
+                args: [token, parseEther('1000'), false],
+            }),
+        ]);
+        const compra = 1 / Number(formatUnits(comprados, 18)); // MON por $PANAL al comprar
+        const venta = Number(formatUnits(monVenta, 18)) / 1000; // MON por $PANAL al vender
+        const valor = Math.sqrt(compra * venta);
+        return Number.isFinite(valor) && valor > 0 ? { valor, actualizado: ahora, fuente: 'nadfun-curva' } : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** $PANAL → MON de la API de nad.fun. */
+async function panalDeApi(token, ahora, o) {
+    try {
+        const j = (await getJson(`${NADFUN_MERCADO}${token}`, o));
+        const valor = numero(j.market_info?.price_native ?? j.price_native);
+        return valor ? { valor, actualizado: ahora, fuente: 'nadfun-api' } : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Lee los precios de MON y de $PANAL.
+ *
+ * Nunca lanza: si una fuente cae se usa la otra, y si caen las dos ese precio
+ * queda en `null`. Un precio viejo SÍ se devuelve, con su fecha: quien enseña
+ * decide con `esFresco`, y `enDolares` ya lo hace.
+ */
+export async function leerPrecios(lector, opciones) {
+    const ahora = ahoraS(opciones);
+    const token = opciones?.panalToken ?? PANAL_TOKEN_MAINNET;
+    const [pyth, curva] = await Promise.all([monDePyth(lector), panalDeCurva(lector, token, ahora)]);
+    // CoinGecko solo si Pyth no responde o se ha quedado viejo.
+    const mon = pyth && esFresco(pyth, ahora) ? pyth : masReciente(pyth, await monDeCoingecko(opciones));
+    const panalEnMon = curva ?? (await panalDeApi(token, ahora, opciones));
+    const panal = mon && panalEnMon
+        ? {
+            valor: mon.valor * panalEnMon.valor,
+            actualizado: Math.min(mon.actualizado, panalEnMon.actualizado),
+            fuente: panalEnMon.fuente,
+        }
+        : null;
+    return { mon, panalEnMon, panal };
+}
+function masReciente(a, b) {
+    if (!a)
+        return b;
+    if (!b)
+        return a;
+    return b.actualizado > a.actualizado ? b : a;
+}
+/** Si un precio se puede enseñar: existe y tiene menos de cinco minutos. */
+export function esFresco(p, ahora, maxEdadS = PRECIO_MAX_EDAD_S) {
+    if (!p)
+        return false;
+    return (ahora ?? Math.floor(Date.now() / 1000)) - p.actualizado <= maxEdadS;
+}
+/**
+ * Cuántos dólares son `cantidad` unidades mínimas de `moneda` (18 decimales),
+ * con el precio de mercado. `null` si no hay precio o tiene más de 5 minutos.
+ */
+export function enDolares(cantidad, moneda, precios, ahora) {
+    const p = moneda === 'MON' ? precios?.mon : precios?.panal;
+    if (!esFresco(p, ahora))
+        return null;
+    return { usd: Number(formatUnits(cantidad, 18)) * p.valor, actualizado: p.actualizado, fuente: p.fuente };
+}
+/**
+ * Lo que daría vender `cantidad` $PANAL ahora en la curva, en MON (wei): con
+ * la comisión y el impacto en el precio. Es lo que de verdad cobraría quien
+ * los vendiera. `null` si la curva no responde.
+ */
+export async function valorDeVenta(lector, cantidad, panalToken = PANAL_TOKEN_MAINNET) {
+    if (cantidad <= 0n)
+        return 0n;
+    try {
+        return (await lector.readContract({
+            address: MERCADO_PANAL,
+            abi: curvaAbi,
+            functionName: 'getAmountOut',
+            args: [panalToken, cantidad, false],
+        }));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * «$0.075», «$0.0006», «$1.50». Por debajo de un dólar, dos cifras
+ * significativas: con decimales fijos, 100 $PANAL saldrían «$0.00».
+ */
+export function formatearDolares(usd, locale = 'en-US') {
+    if (!Number.isFinite(usd) || usd < 0)
+        return '';
+    if (usd > 0 && usd < 0.000001) {
+        return `< ${new Intl.NumberFormat(locale, { style: 'currency', currency: 'USD', maximumFractionDigits: 6 }).format(0.000001)}`;
+    }
+    const opciones = usd >= 1
+        ? { style: 'currency', currency: 'USD', minimumFractionDigits: 2, maximumFractionDigits: 2 }
+        : { style: 'currency', currency: 'USD', maximumSignificantDigits: 2 };
+    return new Intl.NumberFormat(locale, opciones).format(usd);
+}