Use as an agent

mkdir -p ~/.claude/skills/oculr
curl -s https://mpp.oculr.xyz/SKILL.md -o ~/.claude/skills/oculr/SKILL.md

claude -p "Use the oculr skill to analyse 0xYOUR_TX_HASH"

Read https://tempo.xyz/SKILL.md and set up tempo

# Create a new account (key written to the OS keychain - no plaintext on disk)
mppx account create

const spec = await fetch('https://mpp.oculr.xyz/tool-spec.json').then(r => r.json())

{
  "version": 1,
  "baseUrl": "https://mpp.oculr.xyz",
  "auth": "mpp-x402",
  "anthropic": [ /* 3 tools - Anthropic Messages format */ ],
  "openai":    [ /* 3 tools - OpenAI Chat Completions format */ ],
  "endpoints": {
    "explain_transaction": { "method": "POST", "path": "/explain" },
    "start_explain_job":   { "method": "POST", "path": "/explain/async" },
    "get_job_result":      { "method": "GET",  "path": "/result/{jobId}" }
  },
  "skillUrl":   "https://mpp.oculr.xyz/SKILL.md",
  "openapiUrl": "https://mpp.oculr.xyz/openapi.json"
}

import Anthropic from '@anthropic-ai/sdk'
 
const spec = await fetch('https://mpp.oculr.xyz/tool-spec.json').then(r => r.json())
 
const client = new Anthropic()
const response = await client.messages.create({
  model: 'claude-opus-5',
  tools: spec.anthropic,
  messages: [{ role: 'user', content: 'Analyse tx 0x4e4b8ed4…' }],
})

import OpenAI from 'openai'
 
const spec = await fetch('https://mpp.oculr.xyz/tool-spec.json').then(r => r.json())
 
const client = new OpenAI()
const response = await client.chat.completions.create({
  model: 'gpt-4o',
  tools: spec.openai,
  messages: [{ role: 'user', content: 'Analyse tx 0x4e4b8ed4…' }],
})

import { Mppx, tempo } from 'mppx/client'
import { privateKeyToAccount } from 'viem/accounts'
 
// `maxDeposit` is required - it caps the channel total this session funds. It is
// not the opening deposit: the channel opens at min(suggestedDeposit, maxDeposit),
// so '32' still escrows the $16 oculr suggests and refunds the rest on close.
await Mppx.create({
  methods: [tempo({
    account: privateKeyToAccount(process.env.WALLET_PRIVATE_KEY as `0x${string}`),
    maxDeposit: '32',
  })],
})
 
// The explicit `Promise<any>` is required: the function recurses, and under
// `strict` TypeScript cannot infer a return type for a self-referencing function.
async function dispatchToolCall(name: string, args: Record<string, unknown>): Promise<any> {
  // Sync explain_transaction is a metered SSE stream - a plain JSON POST to
  // /explain returns 402 use_metered_sse. In a plain-fetch executor, serve it
  // through the async pair instead: same ExplanationResult, no stream to consume.
  if (name === 'explain_transaction') {
    const { jobId } = await dispatchToolCall('start_explain_job', args)
    while (true) {
      await new Promise(r => setTimeout(r, 5000))
      const job = await dispatchToolCall('get_job_result', { jobId })
      if (job.status === 'complete') return job.result
      if (job.status === 'error')    throw new Error(job.error)
    }
  }
 
  const route = spec.endpoints[name]
  if (!route) throw new Error(`Unknown tool: ${name}`)
 
  // Substitute path params, e.g. /result/{jobId}
  const path = route.path.replace(/\{(\w+)\}/g, (_: string, k: string) => String(args[k]))
  const url = `${spec.baseUrl}${path}`
 
  const init: RequestInit = { method: route.method }
  if (route.method === 'POST') {
    init.headers = { 'Content-Type': 'application/json' }
    init.body = JSON.stringify(args)
  }
 
  const res = await fetch(url, init)
  if (!res.ok) throw new Error(`oculr ${name} ${res.status}: ${(await res.text()) || 'no body'}`)
  return res.json()
}

async function explainAsync(txHash: string, context?: string) {
  const { jobId } = await dispatchToolCall('start_explain_job', { txHash, context })
 
  while (true) {
    await new Promise(r => setTimeout(r, 5000))
    const job = await dispatchToolCall('get_job_result', { jobId })
    if (job.status === 'complete') return job.result
    if (job.status === 'error')    throw new Error(job.error)
  }
}

export WALLET_PRIVATE_KEY=0xYOUR_PRIVATE_KEY

npm install mppx viem

import { Mppx, tempo } from 'mppx/client'
import { privateKeyToAccount } from 'viem/accounts'
 
const account = privateKeyToAccount(process.env.WALLET_PRIVATE_KEY! as `0x${string}`)
 
// `maxDeposit` is your hard per-session spend cap. It is NOT the amount escrowed:
// the channel opens at min(suggestedDeposit, maxDeposit) and oculr suggests $16,
// so a cap of '32' still escrows $16, and unused deposit is refunded on close.
// Use '32' - above the suggestion, never equal to it, or the channel opens on its
// own ceiling and can never be topped up. The $16 deposit covers any single
// analysis; a $5 cap can be exhausted by one exploit investigation on its own.
await Mppx.create({ methods: [tempo({ account, maxDeposit: '32' })] })

async function analyseTransaction(txHash: string, context?: string) {
  const startRes = await fetch('https://mpp.oculr.xyz/explain/async', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ txHash, context }),
  })
  if (!startRes.ok) throw new Error(`oculr start: ${startRes.status}`)
  const { jobId } = await startRes.json()
 
  while (true) {
    await new Promise(r => setTimeout(r, 5000))
    const pollRes = await fetch(`https://mpp.oculr.xyz/result/${jobId}`)
    if (!pollRes.ok) throw new Error(`oculr poll: ${pollRes.status}`)
    const job = await pollRes.json()
    if (job.status === 'complete') return job.result
    if (job.status === 'error')    throw new Error(`oculr: ${job.error}`)
  }
}

const { summary, txType, confidence, risks } = result
 
// Always check the partial signal first.
if (summary.startsWith('**Partial result')) {
  return escalate(result)
}
 
// Confidence-gated handling.
if (confidence === 'high') {
  return summary
} else if (confidence === 'medium' && risks.length === 0) {
  return summary
} else {
  return escalate(result)
}
 
// `txType` is a closed enum - dispatch to specialised follow-up.
switch (txType) {
  case 'swap':        return classifySwapPnL(result)
  case 'exploit':     return triageExploit(result)
  case 'mev':         return logMevPattern(result)
  case 'liquidation': return creditRiskUpdate(result)
  // …
}

mppx https://mpp.oculr.xyz/explain/async \
  -J '{"txHash":"0x4e4b8ed4de38be29e3a7a15e2b14b5d8262e3c5b3f1e9d6a7c8b9e0f1a2d3c4e"}'
# → {"jobId":"…"} - poll with mppx: each poll collects the cost accrued so far,
# and the first poll after the job finishes charges the true-up.
mppx https://mpp.oculr.xyz/result/JOB_ID | jq '{status, result: {summary, txType, confidence}}'