@celorodrigues/x402-conformance 2.2.0 → 2.2.1

package/README.md

@@ -1,6 +1,6 @@
 # @celorodrigues/x402-conformance
 
-[![x402-conformance](https://api.automaton-sovereign.workers.dev/v2/badge/default.svg)](https://api.automaton-sovereign.workers.dev/leaderboard)
+[![x402-conformance](https://automaton-api.bfzovw.easypanel.host/v2/badge/default.svg)](https://automaton-api.bfzovw.easypanel.host/leaderboard)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
 > **Autonomous Linter and Conformance Suite for Official x402 Micropayments & EIP-3009**
@@ -47,9 +47,34 @@ The same package runs as an MCP stdio server:
 - Claude Desktop: Settings → Developer → Edit Config (`claude_desktop_config.json`), then restart.
 - Cursor: `.cursor/mcp.json` in the project, or `~/.cursor/mcp.json`.
 
-Tools: `x402_conformance_check` (free, runs locally), `simulate_base_transaction` (free, EVM dry-run via Base RPC with revert reason decoding), `security_scan` (Base token honeypot / mint-trap / contract risk), `oracle_base`, `sentiment_analysis`, `attest`, `merkle_prove`, plus free `verify_attestation`, `read_ledger`, `merkle_verify`, `pricing`, `health`. Paid tools cost 0.001 - 0.05 USDC on Base (3 free calls/day/IP).
-
-Optional env: `VALUE_API_BASE` (default `https://api.automaton-sovereign.workers.dev`), `VALUE_API_PAYMENT` (payment tx hash attached to paid calls).
+### Available MCP Tools (15 Tools)
+
+#### 🆓 Free Diagnostics & Local Execution (No payment required)
+| Tool | Description |
+|---|---|
+| `simulate_base_transaction` | EVM transaction dry-run with exact gas estimation and revert reason decoding on Base L2. |
+| `x402_conformance_check` | Full 12-point conformance audit of any HTTP 402 API endpoint against the official spec. |
+| `health` | Real-time service diagnostics, node health, and payment recipient address. |
+| `pricing` | Live pricing directory across all hosted x402 services and settlement rails. |
+| `read_ledger` | Query the immutable, signed ledger of attested operations. |
+| `verify_attestation` | Verify cryptographic signatures and proofs offline or online. |
+| `attestation_pubkey` | Retrieve the agent's public key for independent trustless verification. |
+| `merkle_verify` | Validate cryptographic Merkle tree inclusion proofs. |
+
+#### ⚡ Hosted Intelligence & Consensus (x402 Micro-payments on Base — 3 Free Trials/Day/IP)
+| Tool | Price | Description |
+|---|---|---|
+| `oracle_base` | 0.001 USDC | Multi-RPC consensus oracle on Base (block, gas, clock, balance). |
+| `security_scan` | 0.002 USDC | EVM bytecode scanner, honeypot detection, fee-traps & contract risk analysis. |
+| `sentiment_analysis` | 0.001 USDC | Fast agentic financial sentiment scoring for market data. |
+| `attest` | 0.05 USDC | Generate on-chain attestations signed by Agent #95791. |
+| `merkle_prove` | 0.05 USDC | Cryptographic Merkle batch proof generation. |
+| `hash_sha256` | 0.0001 USDC | Fast deterministic SHA-256 computation. |
+| `uuid` | 0.0001 USDC | Cryptographically secure UUID generation. |
+
+Optional environment variables:
+- `VALUE_API_BASE`: Default `https://automaton-api.bfzovw.easypanel.host` (or edge mirror `https://api.automaton-sovereign.workers.dev`).
+- `VALUE_API_PAYMENT`: Optional Base USDC transaction hash or EIP-3009 authorization payload.
 
 ---
 
@@ -77,13 +102,13 @@ Optional env: `VALUE_API_BASE` (default `https://api.automaton-sovereign.workers
 Services that achieve a **CONFORMANT** verdict (Grade A or A+) can request an on-chain signed attestation and permanent verification badge:
 
 ```bash
-curl -X POST https://api.automaton-sovereign.workers.dev/v2/conformance/certify \
+curl -X POST https://automaton-api.bfzovw.easypanel.host/v2/conformance/certify \
   -H "Content-Type: application/json" \
   -H "X-PAYMENT: <txHash-or-EIP3009>" \
   -d '{"url":"https://your-service.com/v1/paid"}'
 ```
 
-* Certified services appear on the public [x402 Leaderboard](https://api.automaton-sovereign.workers.dev/leaderboard).
+* Certified services appear on the public [x402 Leaderboard](https://automaton-api.bfzovw.easypanel.host/leaderboard).
 * Fee: 0.05 USDC settled directly on Base L2 to `0x71DEAc098914A009E3720524642A6bE6F65EE528`.
 
 ---

package/mcp-server.js

@@ -24,7 +24,7 @@ const PKG = require('./package.json');
 const linter = require('./index.js');
 const simulator = require('./tx-simulator.js');
 
-const BASE = (process.env.VALUE_API_BASE || 'https://api.automaton-sovereign.workers.dev').replace(/\/+$/, '');
+const BASE = (process.env.VALUE_API_BASE || 'https://automaton-api.bfzovw.easypanel.host').replace(/\/+$/, '');
 const PAYMENT = process.env.VALUE_API_PAYMENT || '';
 
 function httpJson(method, urlStr, headers, body) {
@@ -52,9 +52,9 @@ const TOOLS = [
     inputSchema: { type: 'object', properties: { url: { type: 'string', description: 'Full URL of the x402-protected endpoint to check.' } }, required: ['url'] } },
   { name: 'simulate_base_transaction', description: 'FREE, runs locally against Base Mainnet RPC. Dry-run a transaction before sending it: eth_call + eth_estimateGas at the latest block. Predicts whether it will revert and decodes the reason (Error(string), Panic(uint256) codes, custom-error selector, or node rejection such as insufficient funds). Returns { ok, willRevert, revertReason, estimatedGas, returnData }.',
     inputSchema: { type: 'object', properties: { to: { type: 'string', description: 'Target contract or recipient address on Base (0x...).' }, data: { type: 'string', description: 'Calldata as 0x-hex (default 0x for a plain ETH transfer).' }, value: { type: 'string', description: 'ETH value in wei, decimal or 0x-hex (default 0).' }, from: { type: 'string', description: 'Optional sender address; needed for balance/allowance-dependent calls.' } }, required: ['to'] } },
-  { name: 'security_scan', description: 'PAID 0.001 USDC/call, or free trial (3/day/IP). Base token safety analysis: honeypot detection, mint traps, selfdestruct/delegatecall, proxy and tax risks from contract bytecode, with a risk score and signed verdict. On 402, pay the accepts[] terms then retry with the payment tx hash.',
+  { name: 'security_scan', description: 'PAID 0.002 USDC/call, or free trial (3/day/IP). Base token safety analysis: honeypot detection, mint traps, selfdestruct/delegatecall, proxy and tax risks from contract bytecode, with a risk score and signed verdict. On 402, pay the accepts[] terms then retry with the payment tx hash.',
     inputSchema: { type: 'object', properties: { address: { type: 'string', description: 'Token or contract address on Base (0x...).' }, payment: { type: 'string', description: 'Optional X-PAYMENT base tx hash of the USDC payment.' } }, required: ['address'] } },
-  { name: 'attest', description: 'Create a SIGNED, hash-chained, append-only attestation (verifiable proof-of-existence) for a payload. PAID: 0.001 USDC/call, or free trial (3/day/IP). On 402, pay the accepts[] terms then retry with the payment tx hash.',
+  { name: 'attest', description: 'Create a SIGNED, hash-chained, append-only attestation (verifiable proof-of-existence) for a payload. PAID: 0.05 USDC/call, or free trial (3/day/IP). On 402, pay the accepts[] terms then retry with the payment tx hash.',
     inputSchema: { type: 'object', properties: { data: { type: 'string', description: 'Payload to attest (any string).' }, payment: { type: 'string', description: 'Optional X-PAYMENT base tx hash of the USDC payment.' } }, required: ['data'] } },
   { name: 'verify_attestation', description: 'FREE. Verify a ledger entry by index or by data hash: recomputes hash, checks ECDSA signature and chain link.',
     inputSchema: { type: 'object', properties: { index: { type: 'integer' }, dataHash: { type: 'string' } } } },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celorodrigues/x402-conformance",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "Zero-dependency CLI, MCP server and testing suite for x402 AI agent micropayment protocol & EIP-3009 compliance",
   "main": "index.js",
   "bin": {
@@ -38,7 +38,7 @@
     "type": "git",
     "url": "git+https://github.com/baianomarceloeduardo-jpg/automaton-x402.git"
   },
-  "homepage": "https://api.automaton-sovereign.workers.dev/leaderboard",
+  "homepage": "https://automaton-api.bfzovw.easypanel.host/leaderboard",
   "bugs": {
     "url": "https://github.com/baianomarceloeduardo-jpg/automaton-x402/issues"
   },

package/smithery.yaml

@@ -7,20 +7,20 @@ startCommand:
     properties:
       valueApiBase:
         type: string
-        default: https://api.automaton-sovereign.workers.dev
+        default: https://automaton-api.bfzovw.easypanel.host
         description: Base URL of the Automaton-Sovereign Value API used by the paid/free API tools.
       valueApiPayment:
         type: string
-        description: Optional x402 payment (Base USDC tx hash) attached as X-PAYMENT to paid tool calls.
+        description: Optional x402 payment (Base USDC tx hash or EIP-3009 authorization) attached to paid tool calls.
   commandFunction:
     |-
     (config) => ({
       command: 'npx',
-      args: ['-y', '@celorodrigues/x402-conformance', '--mcp'],
+      args: ['-y', '@celorodrigues/x402-conformance@2.2.0', '--mcp'],
       env: Object.assign(
-        { VALUE_API_BASE: config.valueApiBase || 'https://api.automaton-sovereign.workers.dev' },
+        { VALUE_API_BASE: config.valueApiBase || 'https://automaton-api.bfzovw.easypanel.host' },
         config.valueApiPayment ? { VALUE_API_PAYMENT: config.valueApiPayment } : {}
       )
     })
   exampleConfig:
-    valueApiBase: https://api.automaton-sovereign.workers.dev
+    valueApiBase: https://automaton-api.bfzovw.easypanel.host

package/tx-simulator.js

@@ -14,7 +14,10 @@ const https = require('https');
 const http = require('http');
 const { URL } = require('url');
 
-const DEFAULT_RPC = process.env.BASE_RPC_URL || 'https://mainnet.base.org';
+const DEFAULT_RPC = process.env.SIM_RPC_URL || process.env.BASE_RPC_URL || 'https://mainnet.base.org';
+const MAX_DATA_BYTES = 65536;                  // well above any real tx; bounds upstream work
+const MAX_DATA_HEX = 2 + MAX_DATA_BYTES * 2;
+const MAX_RPC_RESPONSE = 2 * 1024 * 1024;      // cap memory per upstream response
 const BASE_CHAIN_ID = '0x2105'; // 8453
 
 const PANIC_CODES = {
@@ -37,7 +40,8 @@ function rpcCall(rpcUrl, method, params) {
     const payload = JSON.stringify({ jsonrpc: '2.0', id: 1, method, params });
     const req = lib.request({ hostname: u.hostname, port: u.port || (u.protocol === 'http:' ? 80 : 443), path: u.pathname + u.search, method: 'POST',
       headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload), 'User-Agent': 'automaton-simulator/1.0' } }, (res) => {
-      let d = ''; res.on('data', (c) => d += c);
+      let d = '';
+      res.on('data', (c) => { d += c; if (d.length > MAX_RPC_RESPONSE) req.destroy(new Error('rpc_response_too_large')); });
       res.on('end', () => {
         let j; try { j = JSON.parse(d); } catch (e) { return reject(new Error('bad_rpc_response (HTTP ' + res.statusCode + ')')); }
         resolve(j); // caller inspects j.result / j.error (a revert arrives as j.error)
@@ -94,17 +98,64 @@ function revertDataOf(err) {
   return null;
 }
 
+// JSON-RPC error -> 'revert' (execution reverted), 'rejected' (node refuses the tx itself:
+// funds, gas, nonce) or 'transient' (rate limit, capacity, internal: says nothing about the tx).
+function classify(err) {
+  if (!err) return null;
+  if (revertDataOf(err)) return 'revert';
+  const msg = String(err.message || '');
+  if (err.code === 3 || /revert/i.test(msg)) return 'revert';
+  if (/insufficient funds|OutOfFunds|gas required exceeds|intrinsic gas|gas too low|exceeds block gas limit|nonce|invalid opcode|out of gas|stack (over|under)flow|InvalidFEOpcode|OpcodeNotFound/i.test(msg)) return 'rejected';
+  return 'transient';
+}
+
+// Returns an error string for unusable input, or null. Pure and cheap: callers run it before
+// charging a payment or spending an RPC call.
+function validate(input) {
+  input = input || {};
+  if (!isAddr(input.to)) return 'to must be a 0x-prefixed 20-byte address';
+  if (input.from !== undefined && input.from !== null && input.from !== '' && !isAddr(input.from)) return 'from must be a 0x-prefixed 20-byte address';
+  const data = input.data === undefined || input.data === null || input.data === '' ? '0x' : input.data;
+  if (typeof data !== 'string') return 'data must be a 0x-hex string';
+  if (data.length > MAX_DATA_HEX) return 'calldata too large (max ' + MAX_DATA_BYTES + ' bytes)';
+  if (!/^0x([0-9a-fA-F]{2})*$/.test(data)) return 'data must be 0x-prefixed even-length hex';
+  try { toQuantity(input.value); } catch (e) { return e.message; }
+  return null;
+}
+
+// Process-wide limiter: the free MCP tool must not turn this host into an open Base RPC proxy
+// (each simulation costs 4 upstream calls, and the same public RPC verifies our payments).
+const RATE_PER_MIN = parseInt(process.env.SIM_RATE_PER_MIN || '120', 10);
+const MAX_CONCURRENT = parseInt(process.env.SIM_MAX_CONCURRENT || '8', 10);
+let tokens = RATE_PER_MIN, refillAt = Date.now(), inFlight = 0;
+function acquire() {
+  const now = Date.now();
+  tokens = Math.min(RATE_PER_MIN, tokens + ((now - refillAt) / 60000) * RATE_PER_MIN);
+  refillAt = now;
+  if (inFlight >= MAX_CONCURRENT) return 'rate_limited: too many concurrent simulations, retry shortly';
+  if (tokens < 1) return 'rate_limited: simulation quota exceeded (' + RATE_PER_MIN + '/min), retry shortly';
+  tokens -= 1; inFlight++;
+  return null;
+}
+
 async function simulate(input, opts) {
   input = input || {};
   opts = opts || {};
-  const rpcUrl = opts.rpcUrl || DEFAULT_RPC;
   const out = { ok: false, network: 'base', chainId: 8453, willRevert: null, revertReason: null, estimatedGas: null, returnData: null };
+  const invalid = validate(input);
+  if (invalid) { out.error = invalid; return out; }
+  // Paid HTTP calls (already metered by x402) skip the free-tier limiter but not the concurrency cap.
+  if (!opts.bypassLimit) {
+    const limited = acquire();
+    if (limited) { out.error = limited; out.rateLimited = true; return out; }
+  } else inFlight++;
+  try { return await run(input, opts, out); } finally { inFlight--; }
+}
 
-  if (!isAddr(input.to)) { out.error = 'to must be a 0x-prefixed 20-byte address'; return out; }
-  if (input.from !== undefined && input.from !== null && input.from !== '' && !isAddr(input.from)) { out.error = 'from must be a 0x-prefixed 20-byte address'; return out; }
-  const data = input.data === undefined || input.data === null || input.data === '' ? '0x' : String(input.data);
-  if (!/^0x([0-9a-fA-F]{2})*$/.test(data)) { out.error = 'data must be 0x-prefixed even-length hex'; return out; }
-  let value; try { value = toQuantity(input.value); } catch (e) { out.error = e.message; return out; }
+async function run(input, opts, out) {
+  const rpcUrl = opts.rpcUrl || DEFAULT_RPC;
+  const data = input.data === undefined || input.data === null || input.data === '' ? '0x' : input.data;
+  const value = toQuantity(input.value);
 
   const tx = { to: input.to, data, value };
   if (input.from) tx.from = input.from;
@@ -120,9 +171,18 @@ async function simulate(input, opts) {
   out.tx = tx;
 
   let call, gas;
-  try {
-    [call, gas] = await Promise.all([rpcCall(rpcUrl, 'eth_call', [tx, block]), rpcCall(rpcUrl, 'eth_estimateGas', [tx, block])]);
-  } catch (e) { out.error = 'rpc_unreachable: ' + e.message; return out; }
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      [call, gas] = await Promise.all([rpcCall(rpcUrl, 'eth_call', [tx, block]), rpcCall(rpcUrl, 'eth_estimateGas', [tx, block])]);
+    } catch (e) { out.error = 'rpc_unreachable: ' + e.message; return out; }
+    // Rate limits / capacity errors are not reverts: retry once, then report ok:false.
+    if (classify(call.error) !== 'transient' && classify(gas.error) !== 'transient') break;
+    if (attempt === 0) await new Promise((r) => setTimeout(r, 400));
+  }
+  if (classify(call.error) === 'transient') {
+    out.error = 'rpc_error: ' + String(call.error.message || call.error.code || 'unknown').slice(0, 200);
+    return out;
+  }
 
   out.ok = true;
   if (call.error) {
@@ -149,7 +209,8 @@ async function simulate(input, opts) {
   else if (gas.error) {
     out.estimateGasError = String(gas.error.message || 'estimateGas failed');
     // eth_call can pass while estimateGas fails (e.g. gas-dependent logic): still a revert on-chain.
-    if (out.willRevert === false) {
+    // A transient RPC error on estimateGas alone says nothing about the tx, so it does not flip it.
+    if (out.willRevert === false && classify(gas.error) !== 'transient') {
       out.willRevert = true;
       const rd = revertDataOf(gas.error);
       const dec = rd ? decodeRevert(rd) : null;
@@ -162,4 +223,4 @@ async function simulate(input, opts) {
   return out;
 }
 
-module.exports = { simulate, decodeRevert, toQuantity, PANIC_CODES };
+module.exports = { simulate, validate, decodeRevert, toQuantity, PANIC_CODES };