brainblast 0.6.3 → 0.7.0

package/dist/{chunk-A56IF3UX.js → chunk-CRYFCQYM.js}

@@ -1,3 +1,10 @@
+import {
+  CANONICAL_MINTS
+} from "./chunk-2XJORJPQ.js";
+import {
+  toSnakeCase
+} from "./chunk-O5Z4ZJHC.js";
+
 // src/finder.ts
 import { Project, SyntaxKind } from "ts-morph";
 
@@ -789,6 +796,123 @@ var forbiddenCallReplacement = (c, p) => {
   };
 };
 
+// src/checkers/solanaMintIdentity.ts
+import { Node, SyntaxKind as SyntaxKind11 } from "ts-morph";
+var BASE58_RE = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+function tokenize(name) {
+  return name.replace(/([a-z])([A-Z])/g, "$1_$2").split(/[_\s]+/).map((t) => t.toUpperCase()).filter(Boolean);
+}
+function symbolFromName(name) {
+  return tokenize(name).find((t) => t in CANONICAL_MINTS);
+}
+function addressFromInitializer(init) {
+  if (Node.isStringLiteral(init)) {
+    return init.getLiteralValue();
+  }
+  if (Node.isNewExpression(init)) {
+    const args = init.getArguments();
+    if (args.length > 0 && Node.isStringLiteral(args[0])) {
+      return args[0].getLiteralValue?.() ?? args[0].getText().replace(/['"]/g, "");
+    }
+  }
+  return void 0;
+}
+var solanaMintIdentity = (c, _params) => {
+  const sf = c.fn.getSourceFile?.();
+  if (!sf) return { result: "cant_tell", detail: "Could not access source file" };
+  let foundWrong = false;
+  let foundRight = false;
+  for (const vd of sf.getDescendantsOfKind(SyntaxKind11.VariableDeclaration)) {
+    const sym = symbolFromName(vd.getName());
+    if (!sym) continue;
+    const init = vd.getInitializer();
+    if (!init) continue;
+    const addr = addressFromInitializer(init);
+    if (!addr || !BASE58_RE.test(addr)) continue;
+    if (addr === CANONICAL_MINTS[sym].mint) {
+      foundRight = true;
+    } else {
+      foundWrong = true;
+    }
+  }
+  for (const pa of sf.getDescendantsOfKind(SyntaxKind11.PropertyAssignment)) {
+    const nameNode = pa.getNameNode();
+    const name = Node.isIdentifier(nameNode) ? nameNode.getText() : nameNode.getText().replace(/['"]/g, "");
+    const sym = symbolFromName(name);
+    if (!sym) continue;
+    const init = pa.getInitializer();
+    if (!init) continue;
+    const addr = addressFromInitializer(init);
+    if (!addr || !BASE58_RE.test(addr)) continue;
+    if (addr === CANONICAL_MINTS[sym].mint) {
+      foundRight = true;
+    } else {
+      foundWrong = true;
+    }
+  }
+  if (foundWrong) return { result: "fail", detail: "Mint constant has wrong address for its symbol" };
+  if (foundRight) return { result: "pass", detail: "All symbol-named mint constants have canonical addresses" };
+  return { result: "cant_tell", detail: "No symbol-named mint constants found" };
+};
+
+// src/checkers/anchorIdlAccount.ts
+function fieldIsSigner(f) {
+  if (/\bSigner\s*</.test(f.typeName)) return true;
+  if (/\bsigner\b/.test(f.attrText)) return true;
+  return false;
+}
+function fieldIsMut(f) {
+  if (/\bmut\b/.test(f.attrText)) return true;
+  if (/\binit\b/.test(f.attrText)) return true;
+  if (f.hasInitIfNeeded) return true;
+  return false;
+}
+function anchorIdlAccount(c, params) {
+  const handlerName = toSnakeCase(c.fnName);
+  const spec = params?.instructions?.find((i) => i.name === handlerName);
+  if (!spec) {
+    return {
+      result: "cant_tell",
+      detail: `Handler '${c.fnName}' is not declared in the ${params?.idlName ?? "IDL"}; constraint rule does not apply.`
+    };
+  }
+  if (spec.signers.length === 0 && spec.mutable.length === 0) {
+    return {
+      result: "cant_tell",
+      detail: `Instruction '${spec.name}' declares no signer or mutable accounts in the IDL; nothing to verify.`
+    };
+  }
+  const byName = /* @__PURE__ */ new Map();
+  for (const f of c.accountFields) byName.set(toSnakeCase(f.name), f);
+  const violations = [];
+  for (const acct of spec.signers) {
+    const f = byName.get(acct);
+    if (!f) {
+      violations.push(`'${acct}' (IDL signer) is not present in the Accounts struct`);
+    } else if (!fieldIsSigner(f)) {
+      violations.push(`'${acct}' must be a Signer (IDL marks it isSigner) but the Rust field has no signer constraint`);
+    }
+  }
+  for (const acct of spec.mutable) {
+    const f = byName.get(acct);
+    if (!f) {
+      violations.push(`'${acct}' (IDL mutable) is not present in the Accounts struct`);
+    } else if (!fieldIsMut(f)) {
+      violations.push(`'${acct}' must be mutable (IDL marks it isMut) but the Rust field has no mut/init constraint`);
+    }
+  }
+  if (violations.length > 0) {
+    return {
+      result: "fail",
+      detail: `Handler '${c.fnName}' diverges from the ${params.idlName} IDL: ` + violations.join("; ") + ". A missing signer/mut constraint is a silent authorization hole."
+    };
+  }
+  return {
+    result: "pass",
+    detail: `Handler '${c.fnName}' declares all ${spec.signers.length} signer and ${spec.mutable.length} mutable account(s) the ${params.idlName} IDL requires.`
+  };
+}
+
 // src/checkers/index.ts
 var registry = {
   "positional-arg-identity": positionalArgIdentity,
@@ -801,7 +925,9 @@ var registry = {
   "env-secrets-committed": envSecretsCommitted,
   "taint-to-sink": taintToSink,
   "literal-multiplier-wrong-constant": literalMultiplierWrongConstant,
-  "forbidden-call-replacement": forbiddenCallReplacement
+  "forbidden-call-replacement": forbiddenCallReplacement,
+  "solana-mint-identity-mismatch": solanaMintIdentity,
+  "anchor-account-matches-idl": anchorIdlAccount
 };
 function runChecker(kind, c, params) {
   const fn = registry[kind];
@@ -1017,7 +1143,7 @@ function findRustCandidates(targetDir, rule) {
 }
 
 // src/fixers/positionalArgIdentity.ts
-import { SyntaxKind as SyntaxKind11 } from "ts-morph";
+import { SyntaxKind as SyntaxKind12 } from "ts-morph";
 
 // src/fixers/diffUtil.ts
 function buildDiff(node, replacement) {
@@ -1042,9 +1168,9 @@ function buildDiff(node, replacement) {
 // src/fixers/positionalArgIdentity.ts
 var fixPositionalArgIdentity = (c, p, outcome) => {
   if (outcome.result !== "fail") return void 0;
-  const calls = c.fn.getDescendantsOfKind(SyntaxKind11.CallExpression).filter((call) => {
+  const calls = c.fn.getDescendantsOfKind(SyntaxKind12.CallExpression).filter((call) => {
     const exp = call.getExpression();
-    return exp.getKind() === SyntaxKind11.PropertyAccessExpression && exp.asKind(SyntaxKind11.PropertyAccessExpression).getName() === p.call;
+    return exp.getKind() === SyntaxKind12.PropertyAccessExpression && exp.asKind(SyntaxKind12.PropertyAccessExpression).getName() === p.call;
   });
   if (calls.length === 0) {
     const wantParam2 = c.params[p.paramIndex] ?? "<rawBodyParam>";
@@ -1059,7 +1185,7 @@ Do not call JSON.parse() on the body before this verification step.`
   }
   const arg = calls[0].getArguments()[p.argIndex];
   const wantParam = c.params[p.paramIndex];
-  if (arg && wantParam && arg.getKind() === SyntaxKind11.CallExpression) {
+  if (arg && wantParam && arg.getKind() === SyntaxKind12.CallExpression) {
     return {
       summary: `Pass the raw body parameter '${wantParam}' to ${p.call} instead of a parsed value`,
       diff: buildDiff(arg, wantParam)
@@ -1069,12 +1195,12 @@ Do not call JSON.parse() on the body before this verification step.`
 };
 
 // src/fixers/requiredCallWithOptions.ts
-import { SyntaxKind as SyntaxKind12 } from "ts-morph";
+import { SyntaxKind as SyntaxKind13 } from "ts-morph";
 function callName6(call) {
   const exp = call.getExpression();
-  if (exp.getKind() === SyntaxKind12.Identifier) return exp.getText();
-  if (exp.getKind() === SyntaxKind12.PropertyAccessExpression) {
-    return exp.asKind(SyntaxKind12.PropertyAccessExpression).getName();
+  if (exp.getKind() === SyntaxKind13.Identifier) return exp.getText();
+  if (exp.getKind() === SyntaxKind13.PropertyAccessExpression) {
+    return exp.asKind(SyntaxKind13.PropertyAccessExpression).getName();
   }
   return "";
 }
@@ -1092,15 +1218,15 @@ function placeholderFor(propName) {
 }
 var fixRequiredCallWithOptions = (c, p, outcome) => {
   if (outcome.result !== "fail") return void 0;
-  const calls = c.fn.getDescendantsOfKind(SyntaxKind12.CallExpression);
+  const calls = c.fn.getDescendantsOfKind(SyntaxKind13.CallExpression);
   const verify = calls.filter((x) => p.verifyCalls.includes(callName6(x)));
   if (verify.length > 0) {
     const call = verify[0];
     const args = call.getArguments();
     const lastArg = args[args.length - 1];
-    const obj = lastArg?.asKind(SyntaxKind12.ObjectLiteralExpression);
+    const obj = lastArg?.asKind(SyntaxKind13.ObjectLiteralExpression);
     const presentNames = obj ? obj.getProperties().map((pr) => {
-      const pa = pr.asKind(SyntaxKind12.PropertyAssignment) ?? pr.asKind(SyntaxKind12.ShorthandPropertyAssignment);
+      const pa = pr.asKind(SyntaxKind13.PropertyAssignment) ?? pr.asKind(SyntaxKind13.ShorthandPropertyAssignment);
       return pa?.getName() ?? "";
     }) : [];
     const missingGroups = p.requiredProps.filter(
@@ -1134,22 +1260,22 @@ JWKS must come from Privy's published JWKS endpoint for your app.`
 };
 
 // src/fixers/literalMultiplierWrongConstant.ts
-import { SyntaxKind as SyntaxKind13 } from "ts-morph";
+import { SyntaxKind as SyntaxKind14 } from "ts-morph";
 function callName7(call) {
   const exp = call.getExpression();
-  if (exp.getKind() === SyntaxKind13.Identifier) return exp.getText();
-  if (exp.getKind() === SyntaxKind13.PropertyAccessExpression) {
-    return exp.asKind(SyntaxKind13.PropertyAccessExpression).getName();
+  if (exp.getKind() === SyntaxKind14.Identifier) return exp.getText();
+  if (exp.getKind() === SyntaxKind14.PropertyAccessExpression) {
+    return exp.asKind(SyntaxKind14.PropertyAccessExpression).getName();
   }
   return "";
 }
 function findIdentifier(node, name) {
-  if (node.getKind() === SyntaxKind13.Identifier && node.getText() === name) return node;
-  return node.getDescendantsOfKind(SyntaxKind13.Identifier).find((id) => id.getText() === name);
+  if (node.getKind() === SyntaxKind14.Identifier && node.getText() === name) return node;
+  return node.getDescendantsOfKind(SyntaxKind14.Identifier).find((id) => id.getText() === name);
 }
 var fixLiteralMultiplierWrongConstant = (c, p, outcome) => {
   if (outcome.result !== "fail") return void 0;
-  const calls = c.fn.getDescendantsOfKind(SyntaxKind13.CallExpression).filter((call) => callName7(call) === p.call);
+  const calls = c.fn.getDescendantsOfKind(SyntaxKind14.CallExpression).filter((call) => callName7(call) === p.call);
   if (calls.length === 0) return void 0;
   const arg = calls[0].getArguments()[p.argIndex];
   if (!arg) return void 0;

package/dist/chunk-DQ4KAYKQ.js

@@ -0,0 +1,111 @@
+import {
+  DEFAULT_RPC,
+  probeUpgradeAuthority
+} from "./chunk-XSVQSK53.js";
+
+// src/watchChain.ts
+async function getSignaturesForAddress(programId, until, opts) {
+  const url = opts.rpcUrl ?? DEFAULT_RPC;
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const params = [programId, { limit: opts.limit ?? 25 }];
+  if (until) params[1].until = until;
+  const ac = new AbortController();
+  const t = setTimeout(() => ac.abort(), opts.timeoutMs ?? 1e4);
+  try {
+    const res = await fetchImpl(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "getSignaturesForAddress", params }),
+      signal: ac.signal
+    });
+    if (!res.ok) throw new Error(`getSignaturesForAddress: HTTP ${res.status}`);
+    const body = await res.json();
+    if (body.error) throw new Error(`getSignaturesForAddress: ${body.error.message}`);
+    return body.result ?? [];
+  } finally {
+    clearTimeout(t);
+  }
+}
+async function pollChainOnce(programId, state, opts = {}) {
+  const events = [];
+  const ts = () => (/* @__PURE__ */ new Date()).toISOString();
+  let sigs;
+  try {
+    sigs = await getSignaturesForAddress(programId, state.lastSignature, opts);
+  } catch (e) {
+    events.push({ type: "poll_error", programId, message: e?.message ?? String(e), ts: ts() });
+    return { events, state };
+  }
+  const probe = opts.probeAuthority ?? ((id, o) => probeUpgradeAuthority(id, o).then((ua) => ({ address: ua.address })));
+  let currentAuthority = state.baselineAuthority;
+  try {
+    const ua = await probe(programId, opts);
+    currentAuthority = ua.address;
+  } catch (e) {
+    events.push({ type: "poll_error", programId, message: `authority probe: ${e?.message ?? String(e)}`, ts: ts() });
+  }
+  if (!state.initialized) {
+    const head = sigs[0]?.signature ?? null;
+    events.push({ type: "watch_started", programId, headSignature: head, baselineAuthority: currentAuthority, ts: ts() });
+    return {
+      events,
+      state: { lastSignature: head, baselineAuthority: currentAuthority, initialized: true }
+    };
+  }
+  if (sigs.length > 0) {
+    events.push({
+      type: "new_activity",
+      programId,
+      newCount: sigs.length,
+      signatures: sigs.slice(0, 10).map((s) => s.signature),
+      ts: ts()
+    });
+  }
+  if (currentAuthority !== state.baselineAuthority) {
+    events.push({
+      type: "authority_changed",
+      programId,
+      from: state.baselineAuthority,
+      to: currentAuthority,
+      ts: ts()
+    });
+  }
+  return {
+    events,
+    state: {
+      lastSignature: sigs[0]?.signature ?? state.lastSignature,
+      baselineAuthority: currentAuthority,
+      initialized: true
+    }
+  };
+}
+function initialChainWatchState() {
+  return { lastSignature: null, baselineAuthority: null, initialized: false };
+}
+function startChainWatch(programId, opts = {}) {
+  const emit = opts.emit ?? ((e) => process.stdout.write(JSON.stringify(e) + "\n"));
+  const intervalMs = opts.intervalMs ?? 3e4;
+  let state = initialChainWatchState();
+  let stopped = false;
+  let timer;
+  const tick = async () => {
+    if (stopped) return;
+    const { events, state: next } = await pollChainOnce(programId, state, opts);
+    state = next;
+    for (const e of events) emit(e);
+    if (!stopped) timer = setTimeout(tick, intervalMs);
+  };
+  void tick();
+  return {
+    stop: () => {
+      stopped = true;
+      if (timer) clearTimeout(timer);
+    }
+  };
+}
+
+export {
+  pollChainOnce,
+  initialChainWatchState,
+  startChainWatch
+};

package/dist/chunk-FQA5BYWW.js

@@ -0,0 +1,89 @@
+// src/ricomaps.ts
+function deployerFlagsFrom(sec) {
+  if (!sec) return [];
+  const flags = [];
+  if (sec.hasMintAuthority) flags.push("mint-authority-live");
+  if (sec.hasFreezeAuthority) flags.push("freeze-authority-live");
+  if (sec.isMutable) flags.push("metadata-mutable");
+  if (sec.riskFactors) flags.push(...sec.riskFactors);
+  return flags;
+}
+function renderRicoText(r) {
+  const lines = [
+    `Rico Maps analysis \u2014 ${r.mint}`,
+    `  Risk score:    ${r.riskScore}/100`,
+    `  Holders:       ${r.totalHolders}`,
+    `  Cabal:         ${r.cabalCount}`,
+    `  Snipers:       ${r.snipersDetected ? `yes (${(r.sniperPct * 100).toFixed(1)}%)` : "none"}`,
+    `  Bundle clusters: ${r.bundleClustersDetected ? "detected" : "none"}`
+  ];
+  if (r.deployerFlags.length) {
+    lines.push(`  Deployer flags: ${r.deployerFlags.join(", ")}`);
+  }
+  if (r.tier) lines.push(`  Tier:          ${r.tier}`);
+  return lines.join("\n");
+}
+async function analyzeToken(mint, opts = {}) {
+  const url = `${opts.baseUrl ?? "https://ricomaps.fun"}/api/v1/analyze`;
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ mint, apiKey: opts.apiKey ?? "" }),
+      signal: AbortSignal.timeout(15e3)
+    });
+  } catch (err) {
+    return { ok: false, kind: "network", error: String(err) };
+  }
+  if (res.status === 401 || res.status === 403) {
+    return { ok: false, kind: "auth", status: res.status, error: "Invalid or missing API key" };
+  }
+  if (res.status === 429) {
+    const retryAfter = res.headers.get("Retry-After");
+    return {
+      ok: false,
+      kind: "rate-limit",
+      status: 429,
+      error: "Rate limit exceeded",
+      retryAfterMs: retryAfter ? parseInt(retryAfter, 10) * 1e3 : void 0
+    };
+  }
+  if (res.status === 400) {
+    const text = await res.text().catch(() => "bad request");
+    return { ok: false, kind: "bad-request", status: 400, error: text };
+  }
+  if (!res.ok) {
+    return { ok: false, kind: "server", status: res.status, error: `Server error ${res.status}` };
+  }
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    return { ok: false, kind: "server", error: "Invalid JSON response" };
+  }
+  const s = body.summary;
+  const sniperPct = s.totalHolders > 0 && s.sniperCount != null ? s.sniperCount / s.totalHolders : 0;
+  const result = {
+    mint,
+    riskScore: s.riskScore,
+    totalHolders: s.totalHolders,
+    cabalCount: s.cabalCount,
+    snipersDetected: s.snipersDetected,
+    sniperPct,
+    bundleClustersDetected: s.bundleClustersDetected,
+    symbol: body.tokenMetadata?.symbol,
+    name: body.tokenMetadata?.name,
+    tokenSecurity: body.tokenSecurity,
+    deployerFlags: deployerFlagsFrom(body.tokenSecurity),
+    tier: body.tier,
+    processingMs: body.processingMs
+  };
+  return { ok: true, result };
+}
+
+export {
+  deployerFlagsFrom,
+  renderRicoText,
+  analyzeToken
+};