Build your own

Before I buy $5K of SOL, use CoinGraph:

1. Call check_token with token "solana", size_usd 5000 and this policy:
   min_depth_usd 500000, max_funding_pct 0.05, allow_mint_authority false.
2. Call get_token_snapshot for "solana" with sections "derivatives,onchain".
3. Answer GO only if the verdict is proceed, no policy rule is fail or unknown,
   and derivatives.crowding.regime is not "crowded". Otherwise answer HOLD.
4. Give the reasons with their sources, then call get_proof with the check's id
   and quote its sha256.

npx tsx check-before-acting.ts chainlink

export COINGRAPH_KEY=cg_live_your_key_here
npx tsx check-before-acting.ts solana 5000

// Check a token with CoinGraph before your agent acts on it. Needs Node 18 or later, and no packages.
//
//   npx tsx check-before-acting.ts chainlink            free check, no key needed
//   npx tsx check-before-acting.ts solana 5000          sized to your order, needs COINGRAPH_KEY, costs 5 credits
//
// Exit code: 0 proceed, 1 caution or avoid, 2 the check could not be completed.
// CoinGraph never executes, custodies or advises. Your agent decides what to do with the answer.

const API = process.env.COINGRAPH_API ?? "https://coingraph.ai/api/v1";
const KEY = process.env.COINGRAPH_KEY;

type Reason = { dimension: string; text: string; source: string };
type Check = {
  id: string;
  as_of: string;
  data: {
    token: { id: string; symbol: string };
    verdict: "proceed" | "caution" | "avoid";
    confidence: number;
    reasons: Reason[];
    size_check: { order_usd: number; estimated_impact_pct: number | string } | null;
  };
};

async function checkToken(token: string, sizeUsd?: number): Promise<{ check: Check; charged: string | null; left: string | null }> {
  if (sizeUsd !== undefined && !KEY) throw new Error("A sized check needs a key. Create one at https://coingraph.ai/account/keys, then set COINGRAPH_KEY.");
  const res = await fetch(sizeUsd === undefined ? `${API}/evaluate/${encodeURIComponent(token)}` : `${API}/evaluate`, {
    method: sizeUsd === undefined ? "GET" : "POST",
    headers: { "content-type": "application/json", ...(KEY ? { authorization: `Bearer ${KEY}` } : {}) },
    body: sizeUsd === undefined ? undefined : JSON.stringify({ token, size_usd: sizeUsd }),
    signal: AbortSignal.timeout(30_000),
  });
  const body = await res.json();
  if (!res.ok) throw new Error(`${res.status} ${body.error?.code ?? "error"}: ${body.error?.message ?? "request failed"}`);
  return { check: body, charged: res.headers.get("x-credits-charged"), left: res.headers.get("x-credits-remaining") };
}

async function main() {
  const [token = "chainlink", size] = process.argv.slice(2);
  const sizeUsd = size === undefined ? undefined : Number(size);
  if (sizeUsd !== undefined && !(sizeUsd > 0)) throw new Error("The order size must be a positive number of US dollars.");

  const { check, charged, left } = await checkToken(token, sizeUsd);
  const { verdict, confidence, reasons, size_check } = check.data;

  console.log(`${check.data.token.symbol}: ${verdict} (confidence ${confidence}), as of ${check.as_of}`);
  for (const r of reasons) console.log(`  ${r.dimension}: ${r.text} [${r.source}]`);
  if (size_check) console.log(`  order: $${size_check.order_usd}, estimated impact ${size_check.estimated_impact_pct}%`);
  console.log(`Proof: https://coingraph.ai/proof/${check.id}`);
  if (charged) console.log(`Credits: ${charged} charged, ${left} left`);

  // Your agent's decision goes here. Keep the proof id with whatever it does next.
  process.exitCode = verdict === "proceed" ? 0 : 1;
}

main().catch((e: Error) => {
  // Fail closed: if the check can't be completed, the agent shouldn't act as though it passed.
  console.error(`Check not completed: ${e.message}`);
  process.exitCode = 2;
});