Build a listing gate
with Skein.

curl "https://api.skeinlabs.site/v1/quote?chain=8453&token=0x4200000000000000000000000000000000000006"

{
  "subject": { "chainId": 8453, "token": "0x4200000000000000000000000000000000000006" },
  "policy": "dex-list@0.1.0",
  "priceUsdc": 0.25,
  "pricing": "standard; ABSTAIN is charged at upstream cost only",
  "ok": true,
  "upstreamUsdc": 0.06,
  "checks": [
    { "check": "contract_audit",  "intent": "SMART_CONTRACT_AUDIT_GENERAL",      "quoteUsdc": 0.01 },
    { "check": "holder_count",    "intent": "TOKEN_HOLDER_COUNT_GENERAL",        "quoteUsdc": 0.01 },
    { "check": "liquidity_depth", "intent": "LIQUIDITY_DEPTH_VERIFY_GENERAL",    "quoteUsdc": 0.01 },
    { "check": "sanctions",       "intent": "SANCTIONS_SCREENING_MATCH_GENERAL", "quoteUsdc": 0.01 },
    { "check": "social_bots",     "intent": "SOCIAL_BOT_DETECTION_GENERAL",      "quoteUsdc": 0.01 },
    { "check": "wash_trading",    "intent": "WASH_TRADING_DETECTION_GENERAL",    "quoteUsdc": 0.01 }
  ]
}

curl -X POST https://api.skeinlabs.site/v1/verdicts \
  -H "Authorization: Bearer $SKEIN_API_KEY" \
  -H "Idempotency-Key: $(uuidgen)" \
  -H "Content-Type: application/json" \
  -d '{
    "subject": { "chainId": 8453, "token": "0x4200000000000000000000000000000000000006" },
    "policy": "dex-list@0.1.0",
    "mode": "async"
  }'
# → 202 { "id": "vrd_…", "status": "running" }

curl https://api.skeinlabs.site/v1/verdicts/vrd_…          # the verdict, once sealed
curl -X POST https://api.skeinlabs.site/v1/verify \
  -H "Content-Type: application/json" -d '{ "id": "vrd_…" }'

mkdir listing-gate && cd listing-gate
npm init -y && npm pkg set type=module
npm install @skeinlabs/sdk
npm install -D tsx typescript @types/node

// quote.ts: run with  npx tsx quote.ts
import { Skein } from "@skeinlabs/sdk";

const skein = new Skein({ apiUrl: "https://api.skeinlabs.site" });

const q = await skein.quote({
  subject: { chainId: 8453, token: "0x4200000000000000000000000000000000000006" }, // WETH on Base
  policy: "dex-list@0.1.0",
});

if (q.ok) console.log(`${q.priceUsdc} USDC buys ${q.checks?.length} checks`);
else console.log("would be refused:", q.refusal?.code, q.refusal?.detail);

// verdict.ts: SKEIN_API_KEY=sk_part_… npx tsx verdict.ts
import { Skein, SkeinError, SpendCapError } from "@skeinlabs/sdk";

const skein = new Skein({
  apiUrl: "https://api.skeinlabs.site",
  payer: { kind: "apiKey", key: process.env.SKEIN_API_KEY! },
  maxUsdcPerCall: 0.3, // quoted first; refused before paying above this
});

try {
  const v = await skein.verdict({
    subject: { chainId: 8453, token: "0x4200000000000000000000000000000000000006" },
    policy: "dex-list@0.1.0",
  });

  console.log(v.verdict, v.riskBps, "bps");
  console.log(v.summary);
  for (const r of v.reasons) console.log("-", r.detail);
  console.log("open risks:", v.openRisks);
  console.log("cost:", v.cost.priceUsdc, "USDC, upstream", v.cost.upstreamUsdc);
  console.log("page:", "https://skeinlabs.site/v/" + v.id);
} catch (e) {
  if (e instanceof SpendCapError) console.log("too expensive:", e.priceUsdc, "USDC");
  else if (e instanceof SkeinError) console.log(e.code, e.message);
  else throw e;
}

interface VerdictObject {
  id: string;                      // "vrd_…", public: anyone can GET, verify and audit it
  verdict: "APPROVE" | "REJECT" | "ESCALATE" | "ABSTAIN";
  riskBps: number;                 // 0–10000: how risky, in basis points
  confidenceBps: number;           // 0–10000: how sure, given the evidence that arrived
  coverage: number;                // 0–1: share of the policy's checks that answered
  summary: string;                 // one line a human can read
  reasons: { code: string; check?: string; detail: string }[];
  openRisks: string[];             // what was not settled (a check that failed, a conflict)
  conflicts: string[];             // where two sources disagreed
  findings: Finding[];             // one per check: status, severity, value, source, receipt
  cost: { upstreamUsdc: number; priceUsdc: number; currency: "USDC" };
  bom: { root: string; items: number };   // Merkle root over every paid input's receipt
  policy: { id: string; version: string };
  engineVersion: string;
  verdictHash: string;             // hash over the whole decision: recompute it with verify()
  network: string;                 // "testnet" today; "simulated" means canned answers
  cached?: boolean;                // served from cache: no new purchases
  replayed?: boolean;              // same Idempotency-Key as before: not charged again
  payment: { rail: "apiKey" } | { rail: "telegraph"; minerId; amountUsdc; receiptHash; signalHash };
}

{
  "id": "vrd_mw1xqc4d3k4t22320e31",
  "verdict": "ABSTAIN",
  "summary": "Abstained: required check contract_audit is ERROR (+3 more).",
  "reasons": [
    { "code": "MISSING_REQUIRED_CHECK", "check": "contract_audit", "detail": "required check contract_audit is ERROR" },
    …
  ],
  "cost": { "upstreamUsdc": 0, "priceUsdc": 0, "pricingRule": "abstain_upstream_only", "currency": "USDC" },
  "bom": { "root": "0x0000…0000", "items": 0 },
  "verdictHash": "0x8f1ac48e5260f1c43b36942a1df39af128c5f747f7ac85564c253095437ec923",
  "network": "testnet",
  "durationMs": 2379
}

const v = await skein.verdict({
  subject,
  onEvent: (e) => {
    switch (e.type) {
      case "plan":     console.log("buying", e.data.purchases?.map((p) => p.check)); break;
      case "purchase": console.log("paid", e.data.check, e.data.amountUusdc / 1e6, "USDC", e.data.receiptHash); break;
      case "finding":  console.log(e.data.check, e.data.status, e.data.notes.join("; ")); break;
      case "decision": console.log("decided", e.data.decision.verdict); break;
    }
  },
});

// Start now, collect later: useful in a queue worker or a serverless function.
const started = await skein.submit({ subject, idempotencyKey: jobId });
if ("status" in started && started.status === "running") {
  await queue.later({ verdictId: started.id });       // returns in milliseconds
}

// …in another invocation:
const v = await skein.wait(verdictId, { timeoutMs: 60_000 });

// Or follow any verdict's events yourself, replayed from the start:
for await (const e of skein.stream(verdictId)) console.log(e.type);

const report = await skein.verify(v.id);
// {
//   ok: true,
//   checks: {
//     adaptersRerun: true,     // each raw paid answer re-parsed into the same finding
//     policyRerun: true,       // the policy file re-applied to those findings
//     policyFile: true,        // the policy text matches its published sha256
//     engineVersion: true,     // the engine that sealed it is the one that re-ran it
//     decisionMatches: true,   // same verdict, risk and confidence
//     bomRootRebuilt: true,    // the receipts' Merkle root rebuilt from the lines
//     receiptsMatch: true      // every line's receipt is the one Telegraph returned
//   },
//   verdictHash: { stored: "0x…", recomputed: "0x…" },
//   problems: []
// }
if (!report.ok) throw new Error("verdict did not verify: " + report.problems.join("; "));

const bom = await skein.bom(v.id);           // the bill of materials
for (const line of bom.lines) {
  console.log(line.check, line.minerName, line.amountUsdc, "USDC", line.receiptHash);
}

const skein = new Skein({
  apiUrl: "https://api.skeinlabs.site",
  payer: { kind: "apiKey", key },
  maxUsdcPerCall: 0.3,      // checked against a fresh quote before any payment
  retries: 2,               // network errors, 429 and retryable 5xx (POSTs only with an idempotency key)
  maxRetryWaitMs: 10_000,   // never sleep longer than this in total; a longer Retry-After throws
  requestTimeoutMs: 15_000, // per HTTP request
  timeoutMs: 120_000,       // how long verdict() waits for the seal
});

import { SkeinError, SpendCapError } from "@skeinlabs/sdk";

try {
  return await skein.verdict({ subject, idempotencyKey });
} catch (e) {
  if (e instanceof SpendCapError) return hold("price above cap", e.priceUsdc);   // nothing paid
  if (!(e instanceof SkeinError)) throw e;
  if (e.payment) ledger.add(e.payment.amountUsdc);  // paid, but no verdict: count it
  switch (e.code) {
    case "BUDGET_TOO_LOW":                          // live floors above your budget
    case "UPSTREAM_UNAVAILABLE":                    // a required check has no live miner
    case "DAILY_CAP_REACHED":                       // Skein's own cap for the day
      return retryLater(e.code);
    case "RATE_LIMITED":                            // the SDK already waited and retried
    case "TIMEOUT":
      return retryLater(e.code, { sameKey: idempotencyKey });
    default:
      throw e;                                      // INVALID_SUBJECT, UNAUTHORIZED, …
  }
}

# 1. A fresh burner wallet (Foundry's cast; or any wallet you only use for this)
cast wallet new

export KEY=0x…            # the burner's private key: never a wallet that holds real funds
export ME=0x…             # its address
export RPC=https://ethereum-sepolia-rpc.publicnode.com
export USDC=0xcc194e1a843B658526D0D5C431f670028582Ae17     # Telegraph test USDC
export DIAMOND=0x3624EB012B5E998BB57B6bE6C9Cfc9c4bc5eb99b  # Telegraph escrow

# 2. Sepolia ETH for gas: any public Sepolia faucet, sent to $ME

# 3. Mint 10 test USDC (6 decimals): anyone can mint the test token
cast send $USDC "mint(address,uint256)" $ME 10000000 --rpc-url $RPC --private-key $KEY

# 4. Deposit 5 USDC into escrow: paid asks settle from here
cast send $USDC "approve(address,uint256)" $DIAMOND 5000000 --rpc-url $RPC --private-key $KEY
cast send $DIAMOND "depositUSDC(uint256)" 5000000 --rpc-url $RPC --private-key $KEY

# 5. Check the escrow balance (micro-USDC)
cast call $DIAMOND "effectiveBalance(address)(int256)" $ME --rpc-url $RPC

npm install viem   # the Telegraph entry signs with it

// telegraph.ts: SKEIN_PAYER_KEY=0x… npx tsx telegraph.ts
import { Skein } from "@skeinlabs/sdk";
import { TelegraphClient, TESTNET, viemSigner } from "@skeinlabs/sdk/telegraph";

const client = new TelegraphClient({
  network: TESTNET,                                   // Sepolia escrow, Telegraph dev node
  signer: viemSigner(process.env.SKEIN_PAYER_KEY as `0x${string}`),
  maxUusdcPerCall: 300_000,                           // 0.30 USDC: no challenge is signed above this
});

const skein = new Skein({
  apiUrl: "https://api.skeinlabs.site",                     // only for reading the sealed verdict back
  payer: {
    kind: "telegraph",
    client,
    minerId: process.env.SKEIN_MINER_ID,             // pin Skein's miner (see /status)
  },
});

const v = await skein.verdict({ subject: { chainId: 1, token: "0x…" } });
console.log(v.verdict, v.payment);
// { rail: "telegraph", minerId: "…", amountUsdc: …, receiptHash: "0x…", signalHash: "0x…" }

claude mcp add skein --env SKEIN_API_KEY=sk_part_… -- npx -y @skeinlabs/mcp

{
  "mcpServers": {
    "skein": {
      "command": "npx",
      "args": ["-y", "@skeinlabs/mcp"],
      "env": {
        "SKEIN_API_KEY": "sk_part_…",
        "SKEIN_MAX_USDC_PER_CALL": "0.30",
        "SKEIN_SESSION_CAP_USDC": "2"
      }
    }
  }
}

You: Before we add 0x4200000000000000000000000000000000000006 on Base to the
     launchpad, check it with Skein. Tell me the cost first.

Agent → skein_quote   { chainId: "base", token: "0x4200…0006" }
      ← dex-list@0.1.0: 0.25 USDC per verdict; buys 6 checks upstream for about 0.06 USDC
Agent → skein_verdict { chainId: "base", token: "0x4200…0006" }
      ← <VERDICT> · risk <n> bps · confidence <n>% · coverage <n>%
        <summary, reasons, open risks, cost>
        Verdict hash 0x…. Verify: https://skeinlabs.site/v/vrd_…
Agent → skein_verify  { id: "vrd_…" }
      ← VERIFIED: vrd_…  ✓ adaptersRerun ✓ policyRerun ✓ decisionMatches …

const DECISION = { APPROVE: "list", REJECT: "block", ESCALATE: "review", ABSTAIN: "retry" } as const;

for (const subject of subjects) {
  // 1. Free: what it would cost, or why it would be refused, before any money moves.
  const quote = await skein.quote({ subject, policy });
  if (!quote.ok) { refuse(subject, quote.refusal); continue; }
  if (spent + quote.priceUsdc > runCapUsdc) { refuse(subject, "run cap"); continue; }

  // 2. Buy it. One idempotency key per token per day: re-running today is free.
  const v = await skein.verdict({
    subject, policy, quote,
    idempotencyKey: `listing-gate:${subject.chainId}:${subject.token.toLowerCase()}:${day}`,
  });
  spent += v.cached || v.replayed ? 0 : v.cost.priceUsdc;

  // 3. Don't take it on trust: recompute it.
  const report = await skein.verify(v.id);

  // 4. Act. A verdict that fails verification goes to a human, never to "list".
  decide(subject, report.ok ? DECISION[v.verdict] : "review", v);
}

process.exit(rows.some((r) => r.decision === "block") ? 1 : 0);   // CI fails on a block

git clone -b ccr-4e0a77db-k2xyoy https://github.com/linoxbt/skein.git && cd skein/examples/listing-gate
npm install
SKEIN_API_KEY=sk_part_… npm run gate -- \
  base:0x4200000000000000000000000000000000000006 \
  ethereum:0xdAC17F958D2ee523a2206206994597C13D831ec7

# one block per token: decision, chain, token, verdict and risk, then why and the verdict page
<DECISION> 8453   0x4200…0006  <VERDICT> <risk> bps
           <summary>
           https://skeinlabs.site/v/vrd_…
<DECISION> 1      0xdAC1…1ec7  <VERDICT> <risk> bps
           <summary>
           https://skeinlabs.site/v/vrd_…

2 tokens · spent <total> USDC (cap 2)

# .github/workflows/listing-gate.yml: check every token added to tokens.txt
on:
  pull_request:
    paths: ["tokens.txt"]
jobs:
  gate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: 22 }
      - run: npm ci
      - run: npx tsx gate.ts $(cat tokens.txt)
        env:
          SKEIN_API_KEY: ${{ secrets.SKEIN_API_KEY }}
          SKEIN_RUN_CAP_USDC: "5"
      - uses: actions/upload-artifact@v4
        if: always()
        with: { name: decisions, path: decisions.json }