@panal/sdk 0.18.2 → 0.19.0

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. */