aeX402 — Cross-Chain DeFi MCP: LINQ, AMM, Bridge, AI

{
  "type": "object",
  "required": [
    "fromChain",
    "toChain",
    "fromToken",
    "toToken",
    "fromAmount",
    "fromAddress"
  ],
  "properties": {
    "toChain": {
      "type": "string",
      "description": "Destination chain id or key, e.g. 4663 (Robinhood Chain)"
    },
    "toToken": {
      "type": "string",
      "description": "Destination token symbol or 0x address, e.g. USDG or ETH"
    },
    "fromChain": {
      "type": "string",
      "description": "Source chain id or key, e.g. 42161 or ARB"
    },
    "fromToken": {
      "type": "string",
      "description": "Source token symbol or 0x address, e.g. USDC"
    },
    "toAddress": {
      "type": "string",
      "description": "Recipient on the destination chain (defaults to fromAddress)"
    },
    "fromAmount": {
      "type": "string",
      "description": "Amount in the source token's smallest unit (e.g. 1000000 = 1 USDC at 6 decimals)"
    },
    "fromAddress": {
      "type": "string",
      "description": "Sender 0x address on the source chain"
    }
  }
}

{
  "type": "object",
  "required": [
    "type"
  ],
  "properties": {
    "dir": {
      "type": "string",
      "description": "rankBy only: asc | desc (default desc — highest rankBy value first)"
    },
    "coin": {
      "type": "string",
      "description": "Coin symbol for l2Book/candleSnapshot (e.g. BTC, ETH)"
    },
    "type": {
      "type": "string",
      "description": "Info request type, e.g. meta, l2Book, allMids, clearinghouseState, metaAndAssetCtxs"
    },
    "user": {
      "type": "string",
      "description": "0x address for user-scoped queries (clearinghouseState, openOrders, userFills)"
    },
    "limit": {
      "type": "number",
      "description": "rankBy only: how many ranked rows to return (default 20, max 100)"
    },
    "rankBy": {
      "type": "string",
      "description": "type:metaAndAssetCtxs ONLY. One of funding | fundingAbs | openInterest | volume. Joins each coin's name to its funding/OI/volume, drops delisted coins, sorts, and returns {ranked, rankBy, dir, totalCoins} instead of the raw two-array response. Use fundingAbs for \"biggest funding outlier either direction\" (ranks by |funding|); use funding for \"most positive/most negative\" specifically (with dir)."
    },
    "endTime": {
      "type": "number",
      "description": "candleSnapshot only: end time epoch ms (default: now)"
    },
    "interval": {
      "type": "string",
      "description": "candleSnapshot only: candle interval, e.g. 1m,5m,15m,1h,4h,1d"
    },
    "startTime": {
      "type": "number",
      "description": "candleSnapshot only: start time epoch ms (default: endTime minus 500 intervals)"
    }
  }
}

{
  "type": "object",
  "required": [
    "name",
    "ticker"
  ],
  "properties": {
    "pad": {
      "type": "string",
      "description": "OPTIONAL aeX402 launchpad slug the coin is launched on. Its vpId then starts with that pad's tag, so the pad lists it. Applies on BOTH the custodial (default) and build:true paths"
    },
    "name": {
      "type": "string",
      "description": "Token name, 1..32 bytes (e.g. \"Fork Meme\")"
    },
    "build": {
      "type": "boolean",
      "description": "If true, return an UNSIGNED tx to submit yourself (non-custodial) instead of the backend launching for you. Default false."
    },
    "image": {
      "type": "string",
      "description": "Image URL (https:// or ipfs:// only) — off-chain metadata"
    },
    "links": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Up to 3 links (https:// or ipfs:// only) — off-chain metadata"
    },
    "ticker": {
      "type": "string",
      "description": "Ticker / symbol, 1..16 bytes (e.g. \"FMEME\")"
    },
    "creator": {
      "type": "string",
      "description": "OPTIONAL 0x EVM address recorded as the coin owner (and seeds the vpId). REQUIRED only when build:true (then it is the self-signing on-chain creator)."
    },
    "description": {
      "type": "string",
      "description": "Short description (<=256 chars) — off-chain metadata"
    }
  }
}

{
  "type": "object",
  "required": [
    "calls"
  ],
  "properties": {
    "linq": {
      "type": "string",
      "description": "LINQ-like query string compiled into pipeline steps. Supports fluent dot chaining and query clauses. .where()/.map()/.select() bodies AND .orderBy()/.orderByDesc()/.distinctBy()/.groupBy() keys are all real expressions — ternaries, &&/||, comparisons, arithmetic, member/index access, object/array literals, and a small method whitelist (.includes/.startsWith/.endsWith/.toLowerCase/.toUpperCase/.trim/.slice/.indexOf/.split/.join, Math.min/max/round/floor/ceil/abs, String()/Number()/Boolean()) all work, e.g. results.map(r => r.ok ? ({chain: r.id, height: r.output}) : ({chain: r.id, height: -1})), or ranking by a COMPUTED score: results.where(r => r.ok).orderByDesc(r => r.output.volume24h * r.output.priceChangePct).take(10) — the ranking key is not limited to a bare field. Fluent example: results.selectMany(r => r.output.programs[]).where(p => p.type in (\"token\",\"canonical-token\")).groupBy(p => p._chain, assets=count(), activity=sum(activity)).orderByDesc(assets).take(5). Clause example: from results[] | expand output.programs[] | where type in (\"token\",\"canonical-token\") | group by _chain as chain select assets=count(), activity=sum(activity) | order by assets desc | take 5."
    },
    "calls": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "tool"
        ],
        "properties": {
          "id": {
            "type": "string",
            "description": "Stable label for this subcall; defaults to tool:index."
          },
          "args": {
            "type": "object",
            "description": "Arguments for the subcall.",
            "additionalProperties": true
          },
          "pick": {
            "type": "string",
            "description": "Optional dot path to return from this subcall, e.g. count or programs[].activity."
          },
          "tool": {
            "type": "string",
            "description": "Read-only tool name, e.g. evm_rpc, solana_rpc, discover_programs, search_tokens, hl_info."
          }
        }
      },
      "maxItems": 32,
      "minItems": 1,
      "description": "Read-only MCP tool calls to run. Each call has {id?, tool, args?, pick?}. pick is a dot path into that call output; [] flattens arrays."
    },
    "reduce": {
      "type": "object",
      "description": "Named reductions to compute from subcall outputs. Example: {\"total\":{\"op\":\"sum\",\"path\":\"results[].picked\"},\"top\":{\"op\":\"top\",\"path\":\"results[]\",\"sortBy\":\"picked\",\"limit\":5}}.",
      "additionalProperties": {
        "type": "object",
        "required": [
          "op"
        ],
        "properties": {
          "by": {
            "type": "string",
            "description": "For group* reducers: dot path inside each selected item used as the group key."
          },
          "op": {
            "enum": [
              "count",
              "sum",
              "avg",
              "min",
              "max",
              "top",
              "groupCount",
              "groupSum",
              "groupAvg",
              "concat",
              "first"
            ],
            "type": "string"
          },
          "path": {
            "type": "string",
            "description": "Dot path into the batch result, e.g. results[].picked or results[].output.programs[].activity."
          },
          "limit": {
            "type": "number",
            "description": "Max rows returned by top/concat/group reducers (default 10, max 100)."
          },
          "value": {
            "type": "string",
            "description": "For groupSum/groupAvg: numeric path inside each selected item. Defaults to the item itself."
          },
          "sortBy": {
            "type": "string",
            "description": "For top: numeric/string path inside each selected item used for ordering."
          }
        }
      }
    },
    "pipeline": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "op"
        ],
        "properties": {
          "by": {
            "type": "string",
            "description": "groupBy/distinct key path."
          },
          "op": {
            "type": "string",
            "description": "from | expand | where | select | project | groupBy | orderBy | sort | take | limit | skip | distinct | count | sum | avg | min | max | first | top"
          },
          "dir": {
            "type": "string",
            "description": "asc or desc for orderBy/top."
          },
          "path": {
            "type": "string",
            "description": "Dot path. [] flattens arrays. \"$\" or \".\" means the current item."
          },
          "count": {
            "type": "number",
            "description": "take/limit/top count."
          },
          "limit": {
            "type": "number",
            "description": "Alias for count."
          },
          "fields": {
            "type": "object",
            "description": "Projection map: outputField -> input path. Use {\"literal\":value} for literal strings.",
            "additionalProperties": true
          },
          "aggregates": {
            "type": "object",
            "description": "groupBy aggregates: name -> {op,path?}; ops: count, sum, avg, min, max, first, top.",
            "additionalProperties": true
          }
        },
        "additionalProperties": true
      },
      "maxItems": 64,
      "description": "LINQ-style chained transforms over the raw batch result. Each step feeds the next. Ops: from, expand, where, select/project, groupBy, orderBy/sort, take/limit, skip, distinct, count, sum, avg, min, max, first, top. Example: [{\"op\":\"from\",\"path\":\"results[]\"},{\"op\":\"expand\",\"path\":\"output.programs[]\"},{\"op\":\"where\",\"path\":\"type\",\"in\":[\"token\",\"canonical-token\"]},{\"op\":\"groupBy\",\"by\":\"_chain\",\"as\":\"chain\",\"aggregates\":{\"tokens\":{\"op\":\"count\"},\"activity\":{\"op\":\"sum\",\"path\":\"activity\"}}},{\"op\":\"orderBy\",\"path\":\"tokens\",\"dir\":\"desc\"},{\"op\":\"take\",\"count\":5}]."
    },
    "concurrency": {
      "type": "number",
      "default": 8,
      "description": "Parallelism for subcalls (default 8, max 12)."
    },
    "ignoreFailures": {
      "type": "boolean",
      "default": false,
      "description": "When reduce/pipeline/linq is used, a failed subcall is normally still reported in `failures` alongside the aggregate result, since a `.where(ok)`-style query would otherwise make it invisible. Set true to suppress that and get back only {reductions?, result?} — use when you already expect some chains/calls to fail and only want whatever succeeded. Defaults to false (failures still shown) because silently dropping an error is a real information loss, not just an efficiency choice — this one is opt-in on purpose."
    }
  }
}