pulse-protocol 0.9.3

package/dist/index.js

@@ -0,0 +1,791 @@
+#!/usr/bin/env node
+
+// src/core/client.ts
+import { EventEmitter } from "eventemitter3";
+
+// src/core/errors.ts
+var PulseError = class _PulseError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PulseError";
+    Object.setPrototypeOf(this, _PulseError.prototype);
+  }
+};
+var ScanError = class _ScanError extends PulseError {
+  detector;
+  constructor(message, detector) {
+    super(message);
+    this.name = "ScanError";
+    this.detector = detector;
+    Object.setPrototypeOf(this, _ScanError.prototype);
+  }
+};
+var SourceError = class _SourceError extends PulseError {
+  source;
+  status;
+  constructor(source, message, status) {
+    super(`${source}: ${message}`);
+    this.name = "SourceError";
+    this.source = source;
+    this.status = status;
+    Object.setPrototypeOf(this, _SourceError.prototype);
+  }
+};
+var SignatureError = class _SignatureError extends PulseError {
+  constructor(message) {
+    super(message);
+    this.name = "SignatureError";
+    Object.setPrototypeOf(this, _SignatureError.prototype);
+  }
+};
+
+// src/sources/helius.ts
+var HeliusSource = class {
+  baseUrl;
+  apiKey;
+  timeout;
+  maxRetries;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.rpcUrl ?? "https://api.helius.xyz/v0";
+    this.timeout = config.timeout;
+    this.maxRetries = config.maxRetries;
+  }
+  async getWalletHistory(wallet, opts = {}) {
+    const limit = opts.limit ?? 100;
+    const url = new URL(`${this.baseUrl}/addresses/${wallet}/transactions`);
+    url.searchParams.set("api-key", this.apiKey);
+    url.searchParams.set("limit", String(Math.min(limit, 100)));
+    if (opts.before) url.searchParams.set("before", opts.before);
+    const raw = await this.fetchWithRetry(url);
+    if (!Array.isArray(raw)) {
+      throw new SourceError("helius", "unexpected response shape");
+    }
+    return raw.map((tx) => {
+      const t = tx;
+      return {
+        signature: String(t.signature ?? ""),
+        timestamp: Number(t.timestamp ?? 0),
+        fee: Number(t.fee ?? 0),
+        programs: Array.isArray(t.accountData) ? extractPrograms(t) : [],
+        type: String(t.type ?? "UNKNOWN")
+      };
+    });
+  }
+  async fetchWithRetry(url) {
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        const res = await fetch(url, { signal: controller.signal });
+        clearTimeout(timer);
+        if (res.status === 429) {
+          const retryAfter = Number(res.headers.get("retry-after") ?? "2");
+          await sleep(retryAfter * 1e3);
+          continue;
+        }
+        if (!res.ok) {
+          throw new SourceError(
+            "helius",
+            `HTTP ${res.status}`,
+            res.status
+          );
+        }
+        return await res.json();
+      } catch (err) {
+        lastError = err;
+        if (attempt < this.maxRetries) {
+          await sleep(500 * (attempt + 1));
+        }
+      }
+    }
+    throw lastError instanceof Error ? new SourceError("helius", lastError.message) : new SourceError("helius", "unknown error");
+  }
+};
+function extractPrograms(tx) {
+  const programs = /* @__PURE__ */ new Set();
+  for (const ix of tx.instructions ?? []) {
+    if (ix.programId) programs.add(ix.programId);
+  }
+  return Array.from(programs);
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/sources/x.ts
+var XSource = class {
+  baseUrl;
+  apiKey;
+  timeout;
+  maxRetries;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl ?? "https://api.twitterapi.io";
+    this.timeout = config.timeout;
+    this.maxRetries = config.maxRetries;
+  }
+  async getRecentPosts(handle, opts = {}) {
+    const limit = opts.limit ?? 100;
+    const url = new URL(`${this.baseUrl}/twitter/user/last_tweets`);
+    url.searchParams.set("userName", handle);
+    const raw = await this.fetchWithRetry(url);
+    const tweets = Array.isArray(raw.tweets) ? raw.tweets : Array.isArray(raw.data?.tweets) ? raw.data.tweets : [];
+    const posts = [];
+    for (const t of tweets.slice(0, limit)) {
+      const obj = t;
+      const createdAt = parseDate(obj.createdAt);
+      if (!createdAt) continue;
+      posts.push({
+        id: String(obj.id ?? ""),
+        text: String(obj.text ?? ""),
+        created_at: createdAt,
+        reply_count: Number(obj.replyCount ?? 0),
+        like_count: Number(obj.likeCount ?? 0),
+        retweet_count: Number(obj.retweetCount ?? 0),
+        in_reply_to_id: obj.inReplyToId ? String(obj.inReplyToId) : void 0
+      });
+    }
+    for (let i = 0; i < posts.length; i++) {
+      const p = posts[i];
+      if (p.in_reply_to_id) {
+        const parent = posts.find((x) => x.id === p.in_reply_to_id);
+        if (parent) {
+          p.reply_delta_ms = (p.created_at - parent.created_at) * 1e3;
+        }
+      }
+    }
+    return posts;
+  }
+  async fetchWithRetry(url) {
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        const res = await fetch(url, {
+          signal: controller.signal,
+          headers: { "X-API-Key": this.apiKey }
+        });
+        clearTimeout(timer);
+        if (res.status === 429) {
+          const retryAfter = Number(res.headers.get("retry-after") ?? "2");
+          await sleep2(retryAfter * 1e3);
+          continue;
+        }
+        if (!res.ok) {
+          throw new SourceError("x", `HTTP ${res.status}`, res.status);
+        }
+        return await res.json();
+      } catch (err) {
+        lastError = err;
+        if (attempt < this.maxRetries) {
+          await sleep2(500 * (attempt + 1));
+        }
+      }
+    }
+    throw lastError instanceof Error ? new SourceError("x", lastError.message) : new SourceError("x", "unknown error");
+  }
+};
+function parseDate(v) {
+  if (typeof v === "number") return v;
+  if (typeof v !== "string") return null;
+  const parsed = Date.parse(v);
+  return isNaN(parsed) ? null : Math.floor(parsed / 1e3);
+}
+function sleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/detectors/cadence.ts
+function cadenceDetector(posts) {
+  const notes = [];
+  if (posts.length < 20) {
+    notes.push(`only ${posts.length} posts available, low confidence`);
+    return {
+      detector: "cadence",
+      score: 50,
+      samples: posts.length,
+      notes,
+      runtime_ms: 0
+    };
+  }
+  const hourBuckets = new Array(24).fill(0);
+  for (const p of posts) {
+    const hour = new Date(p.created_at * 1e3).getUTCHours();
+    hourBuckets[hour]++;
+  }
+  const total = posts.length;
+  let entropy = 0;
+  for (const count of hourBuckets) {
+    if (count > 0) {
+      const p = count / total;
+      entropy -= p * Math.log2(p);
+    }
+  }
+  const entropyScore = entropy / Math.log2(24) * 100;
+  notes.push(`hour entropy: ${entropy.toFixed(2)} bits (${entropyScore.toFixed(0)}/100)`);
+  const businessHours = hourBuckets.slice(9, 18).reduce((a, b) => a + b, 0);
+  const businessRatio = businessHours / total;
+  notes.push(`business-hours ratio: ${(businessRatio * 100).toFixed(1)}%`);
+  const sleepWindow = hourBuckets.slice(4, 8).reduce((a, b) => a + b, 0);
+  const sleepRatio = sleepWindow / total;
+  const hasDeadZone = sleepRatio < 0.05;
+  notes.push(
+    hasDeadZone ? `sleep window detected (${(sleepRatio * 100).toFixed(1)}% posts in 4-8am)` : `no sleep window (${(sleepRatio * 100).toFixed(1)}% posts in 4-8am)`
+  );
+  const sorted = [...posts].sort((a, b) => a.created_at - b.created_at);
+  const intervals = [];
+  for (let i = 1; i < sorted.length; i++) {
+    intervals.push(sorted[i].created_at - sorted[i - 1].created_at);
+  }
+  const meanInterval = intervals.reduce((a, b) => a + b, 0) / intervals.length;
+  const variance = intervals.reduce((a, b) => a + (b - meanInterval) ** 2, 0) / intervals.length;
+  const cv = Math.sqrt(variance) / meanInterval;
+  notes.push(`interval CV: ${cv.toFixed(2)} (lower = more regular = agent-like)`);
+  let score = 0;
+  score += entropyScore * 0.4;
+  score += (1 - Math.abs(businessRatio - 0.15)) * 100 * 0.25;
+  score += (hasDeadZone ? 0 : 100) * 0.2;
+  score += Math.max(0, 100 - cv * 30) * 0.15;
+  return {
+    detector: "cadence",
+    score: Math.round(Math.max(0, Math.min(100, score))),
+    samples: posts.length,
+    notes,
+    runtime_ms: 0
+  };
+}
+
+// src/detectors/onchain.ts
+function onchainDetector(txs) {
+  const notes = [];
+  if (txs.length < 10) {
+    notes.push(`only ${txs.length} transactions, low confidence`);
+    return {
+      detector: "onchain",
+      score: 50,
+      samples: txs.length,
+      notes,
+      runtime_ms: 0
+    };
+  }
+  const hourBuckets = new Array(24).fill(0);
+  for (const t of txs) {
+    const hour = new Date(t.timestamp * 1e3).getUTCHours();
+    hourBuckets[hour]++;
+  }
+  let entropy = 0;
+  for (const count of hourBuckets) {
+    if (count > 0) {
+      const p = count / txs.length;
+      entropy -= p * Math.log2(p);
+    }
+  }
+  const entropyScore = entropy / Math.log2(24) * 100;
+  notes.push(`onchain hour entropy: ${entropy.toFixed(2)} bits`);
+  const sorted = [...txs].sort((a, b) => a.timestamp - b.timestamp);
+  let bursts = 0;
+  for (let i = 0; i < sorted.length - 3; i++) {
+    const window = sorted[i + 3].timestamp - sorted[i].timestamp;
+    if (window <= 10) bursts++;
+  }
+  const burstRatio = bursts / Math.max(1, sorted.length - 3);
+  notes.push(`burst clusters: ${bursts} (${(burstRatio * 100).toFixed(1)}% of windows)`);
+  const programs = /* @__PURE__ */ new Set();
+  for (const t of txs) {
+    for (const p of t.programs ?? []) {
+      programs.add(p);
+    }
+  }
+  const diversityScore = Math.min(100, programs.size * 10);
+  notes.push(`${programs.size} unique programs touched`);
+  const fees = txs.map((t) => t.fee ?? 5e3).filter((f) => f > 0);
+  const meanFee = fees.reduce((a, b) => a + b, 0) / Math.max(1, fees.length);
+  const feeStd = Math.sqrt(
+    fees.reduce((a, b) => a + (b - meanFee) ** 2, 0) / Math.max(1, fees.length)
+  );
+  const feeCV = meanFee > 0 ? feeStd / meanFee : 0;
+  notes.push(`fee CV: ${feeCV.toFixed(2)}`);
+  let score = 0;
+  score += entropyScore * 0.35;
+  score += Math.min(100, burstRatio * 300) * 0.3;
+  score += (100 - diversityScore) * 0.2;
+  score += Math.max(0, 100 - feeCV * 50) * 0.15;
+  return {
+    detector: "onchain",
+    score: Math.round(Math.max(0, Math.min(100, score))),
+    samples: txs.length,
+    notes,
+    runtime_ms: 0
+  };
+}
+
+// src/detectors/voice.ts
+function voiceDetector(posts) {
+  const notes = [];
+  if (posts.length < 15) {
+    notes.push(`only ${posts.length} posts, low confidence`);
+    return {
+      detector: "voice",
+      score: 50,
+      samples: posts.length,
+      notes,
+      runtime_ms: 0
+    };
+  }
+  const allTokens = [];
+  for (const p of posts) {
+    const tokens = tokenize(p.text);
+    allTokens.push(...tokens);
+  }
+  const uniqueRatio = new Set(allTokens).size / allTokens.length;
+  notes.push(`lexical diversity: ${uniqueRatio.toFixed(3)}`);
+  let typoCount = 0;
+  for (const p of posts) {
+    if (/([a-z])\1{2,}/i.test(p.text)) typoCount++;
+    if (/\b[bcdfghjklmnpqrstvwxyz]{4,}\b/i.test(p.text)) typoCount++;
+  }
+  const typoRate = typoCount / posts.length;
+  notes.push(`typo rate: ${(typoRate * 100).toFixed(1)}%`);
+  const trigrams = /* @__PURE__ */ new Map();
+  for (const p of posts) {
+    const tokens = tokenize(p.text);
+    for (let i = 0; i < tokens.length - 2; i++) {
+      const key = `${tokens[i]} ${tokens[i + 1]} ${tokens[i + 2]}`;
+      trigrams.set(key, (trigrams.get(key) ?? 0) + 1);
+    }
+  }
+  const repeated = Array.from(trigrams.values()).filter((v) => v > 1).length;
+  const repetitionRate = repeated / Math.max(1, trigrams.size);
+  notes.push(`phrase repetition: ${(repetitionRate * 100).toFixed(1)}%`);
+  const emojiRegex = /[\p{Emoji_Presentation}]/u;
+  const withEmoji = posts.filter((p) => emojiRegex.test(p.text)).length;
+  const emojiRatio = withEmoji / posts.length;
+  const emojiConsistency = Math.abs(emojiRatio - 0.5) * 2;
+  notes.push(`emoji ratio: ${(emojiRatio * 100).toFixed(0)}%`);
+  let score = 0;
+  score += (1 - uniqueRatio) * 100 * 0.35;
+  score += (1 - typoRate) * 100 * 0.25;
+  score += repetitionRate * 100 * 0.2;
+  score += emojiConsistency * 100 * 0.2;
+  return {
+    detector: "voice",
+    score: Math.round(Math.max(0, Math.min(100, score))),
+    samples: posts.length,
+    notes,
+    runtime_ms: 0
+  };
+}
+function tokenize(text) {
+  return text.toLowerCase().replace(/https?:\/\/\S+/g, "").replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length > 1);
+}
+
+// src/detectors/timing.ts
+function timingDetector(posts, txs) {
+  const notes = [];
+  let anomalies = 0;
+  const quickReplies = posts.filter(
+    (p) => p.in_reply_to_id && p.reply_delta_ms !== void 0 && p.reply_delta_ms < 1e3
+  ).length;
+  if (quickReplies > 0) {
+    anomalies += Math.min(3, quickReplies);
+    notes.push(`${quickReplies} sub-second reply posts`);
+  }
+  const sortedPosts = [...posts].sort((a, b) => a.created_at - b.created_at);
+  let regular = 0;
+  for (let i = 2; i < sortedPosts.length; i++) {
+    const d1 = sortedPosts[i].created_at - sortedPosts[i - 1].created_at;
+    const d2 = sortedPosts[i - 1].created_at - sortedPosts[i - 2].created_at;
+    if (Math.abs(d1 - d2) < 5 && d1 > 0) regular++;
+  }
+  if (regular >= 5) {
+    anomalies++;
+    notes.push(`${regular} posts with cron-like regularity`);
+  }
+  let simultaneous = 0;
+  const txTimes = new Set(txs.map((t) => t.timestamp));
+  for (const p of posts) {
+    for (let offset = -1; offset <= 1; offset++) {
+      if (txTimes.has(p.created_at + offset)) {
+        simultaneous++;
+        break;
+      }
+    }
+  }
+  if (simultaneous >= 3) {
+    anomalies++;
+    notes.push(`${simultaneous} simultaneous X+onchain events (within 1s)`);
+  }
+  const deadHour = posts.filter((p) => {
+    const h = new Date(p.created_at * 1e3).getUTCHours();
+    return h >= 4 && h < 7;
+  }).length;
+  if (deadHour / posts.length > 0.1) {
+    anomalies++;
+    notes.push(`${deadHour} posts during 4-7am UTC dead zone`);
+  }
+  let burstAfterSilence = 0;
+  for (let i = 1; i < sortedPosts.length; i++) {
+    const gap = sortedPosts[i].created_at - sortedPosts[i - 1].created_at;
+    if (gap > 48 * 3600) {
+      const nextFive = sortedPosts.slice(i, i + 5);
+      if (nextFive.length === 5) {
+        const span = nextFive[4].created_at - nextFive[0].created_at;
+        if (span < 600) burstAfterSilence++;
+      }
+    }
+  }
+  if (burstAfterSilence > 0) {
+    anomalies += burstAfterSilence;
+    notes.push(`${burstAfterSilence} silence-then-burst patterns`);
+  }
+  if (anomalies === 0) {
+    notes.push("no timing anomalies detected");
+  }
+  return {
+    detector: "timing",
+    score: anomalies,
+    // raw anomaly count, aggregator normalizes
+    samples: posts.length + txs.length,
+    notes,
+    runtime_ms: 0
+  };
+}
+
+// src/detectors/correlation.ts
+function correlationDetector(posts, txs, target) {
+  const notes = [];
+  if (posts.length < 10 || txs.length < 10) {
+    notes.push(`insufficient data (posts=${posts.length}, txs=${txs.length})`);
+    return {
+      detector: "correlation",
+      score: 50,
+      samples: posts.length + txs.length,
+      notes,
+      runtime_ms: 0
+    };
+  }
+  const postsByHour = /* @__PURE__ */ new Map();
+  const txsByHour = /* @__PURE__ */ new Map();
+  const bucket = (t) => Math.floor(t / 3600);
+  for (const p of posts) {
+    const b = bucket(p.created_at);
+    postsByHour.set(b, (postsByHour.get(b) ?? 0) + 1);
+  }
+  for (const t of txs) {
+    const b = bucket(t.timestamp);
+    txsByHour.set(b, (txsByHour.get(b) ?? 0) + 1);
+  }
+  const allHours = /* @__PURE__ */ new Set([...postsByHour.keys(), ...txsByHour.keys()]);
+  const postVec = [];
+  const txVec = [];
+  for (const h of allHours) {
+    postVec.push(postsByHour.get(h) ?? 0);
+    txVec.push(txsByHour.get(h) ?? 0);
+  }
+  const pearson = pearsonCorrelation(postVec, txVec);
+  notes.push(`pearson r = ${pearson.toFixed(3)}`);
+  const postSpan = maxOf(posts.map((p) => p.created_at)) - minOf(posts.map((p) => p.created_at));
+  const txSpan = maxOf(txs.map((t) => t.timestamp)) - minOf(txs.map((t) => t.timestamp));
+  const postStart = minOf(posts.map((p) => p.created_at));
+  const txStart = minOf(txs.map((t) => t.timestamp));
+  const overlapStart = Math.max(postStart, txStart);
+  const overlapEnd = Math.min(postStart + postSpan, txStart + txSpan);
+  const overlap = Math.max(0, overlapEnd - overlapStart);
+  const overlapRatio = overlap / Math.max(postSpan, txSpan, 1);
+  notes.push(`timeline overlap: ${(overlapRatio * 100).toFixed(1)}%`);
+  const corrScore = Math.max(0, pearson) * 100;
+  const overlapScore = overlapRatio * 100;
+  const score = corrScore * 0.7 + overlapScore * 0.3;
+  notes.push(`target: @${target.handle}, ${target.wallet.slice(0, 8)}...`);
+  return {
+    detector: "correlation",
+    score: Math.round(Math.max(0, Math.min(100, score))),
+    samples: posts.length + txs.length,
+    notes,
+    runtime_ms: 0
+  };
+}
+function pearsonCorrelation(x, y) {
+  if (x.length !== y.length || x.length === 0) return 0;
+  const n = x.length;
+  const meanX = x.reduce((a, b) => a + b, 0) / n;
+  const meanY = y.reduce((a, b) => a + b, 0) / n;
+  let num = 0;
+  let denX = 0;
+  let denY = 0;
+  for (let i = 0; i < n; i++) {
+    const dx = x[i] - meanX;
+    const dy = y[i] - meanY;
+    num += dx * dy;
+    denX += dx * dx;
+    denY += dy * dy;
+  }
+  const denom = Math.sqrt(denX * denY);
+  return denom === 0 ? 0 : num / denom;
+}
+function minOf(arr) {
+  return arr.reduce((a, b) => a < b ? a : b, arr[0] ?? 0);
+}
+function maxOf(arr) {
+  return arr.reduce((a, b) => a > b ? a : b, arr[0] ?? 0);
+}
+
+// src/core/aggregator.ts
+var DEFAULT_WEIGHTS = {
+  cadence: 0.25,
+  onchain: 0.25,
+  voice: 0.2,
+  timing: 0.15,
+  correlation: 0.15
+};
+var DEFAULT_THRESHOLDS = {
+  autonomous: 80,
+  hybrid: 40
+};
+var DISAGREEMENT_DELTA = 40;
+function aggregate(target, detectors, options = {}) {
+  const weights = { ...DEFAULT_WEIGHTS, ...options.weights };
+  const thresholds = options.thresholds ?? DEFAULT_THRESHOLDS;
+  const normalized = {};
+  for (const d of detectors) {
+    if (d.detector === "timing") {
+      normalized.timing = Math.max(0, 100 - d.score * 10);
+    } else {
+      normalized[d.detector] = d.score;
+    }
+  }
+  const presentKeys = Object.keys(normalized);
+  const totalWeight = presentKeys.reduce((s, k) => s + (weights[k] ?? 0), 0);
+  let aggregate2 = 0;
+  for (const k of presentKeys) {
+    const w = (weights[k] ?? 0) / totalWeight;
+    aggregate2 += (normalized[k] ?? 0) * w;
+  }
+  const scoreValues = presentKeys.map((k) => normalized[k] ?? 0);
+  const maxScore = Math.max(...scoreValues);
+  const minScore = Math.min(...scoreValues);
+  const disagreement = maxScore - minScore;
+  const hasDisagreement = disagreement >= DISAGREEMENT_DELTA;
+  let verdict;
+  if (aggregate2 >= thresholds.autonomous && !hasDisagreement) {
+    verdict = "AUTONOMOUS";
+  } else if (aggregate2 >= thresholds.hybrid || hasDisagreement) {
+    verdict = "HYBRID";
+  } else {
+    verdict = "HUMAN";
+  }
+  const confidence = computeConfidence(aggregate2, thresholds, hasDisagreement);
+  const signals = {
+    posting_cadence: Math.round(normalized.cadence ?? 0),
+    onchain_cadence: Math.round(normalized.onchain ?? 0),
+    voice_consistency: Math.round(normalized.voice ?? 0),
+    timing_anomalies: detectors.find((d) => d.detector === "timing")?.score ?? 0,
+    correlation: Math.round(normalized.correlation ?? 0)
+  };
+  return {
+    id: `vrd_${generateId()}`,
+    target,
+    verdict,
+    confidence: Number(confidence.toFixed(3)),
+    aggregate_score: Number(aggregate2.toFixed(2)),
+    signals,
+    detectors,
+    scanned_at: Math.floor(Date.now() / 1e3),
+    version: VERSION
+  };
+}
+function computeConfidence(aggregate2, thresholds, hasDisagreement) {
+  if (hasDisagreement) {
+    return 0.55 + Math.random() * 0.2;
+  }
+  let distance;
+  if (aggregate2 >= thresholds.autonomous) {
+    distance = aggregate2 - thresholds.autonomous;
+  } else if (aggregate2 >= thresholds.hybrid) {
+    distance = Math.min(
+      aggregate2 - thresholds.hybrid,
+      thresholds.autonomous - aggregate2
+    );
+  } else {
+    distance = thresholds.hybrid - aggregate2;
+  }
+  return Math.min(0.98, 0.55 + distance / 40 * 0.43);
+}
+function generateId() {
+  const bytes = new Uint8Array(6);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/core/client.ts
+var PulseProtocol = class {
+  events;
+  helius;
+  x;
+  config;
+  constructor(config) {
+    if (!config.heliusApiKey) {
+      throw new Error("heliusApiKey is required. Get one at https://helius.xyz");
+    }
+    if (!config.xApiKey) {
+      throw new Error("xApiKey is required.");
+    }
+    this.config = {
+      heliusApiKey: config.heliusApiKey,
+      xApiKey: config.xApiKey,
+      rpcUrl: config.rpcUrl,
+      feedUrl: config.feedUrl,
+      signingKey: config.signingKey,
+      timeout: config.timeout ?? 3e4,
+      maxRetries: config.maxRetries ?? 2
+    };
+    this.helius = new HeliusSource({
+      apiKey: config.heliusApiKey,
+      rpcUrl: config.rpcUrl,
+      timeout: this.config.timeout,
+      maxRetries: this.config.maxRetries
+    });
+    this.x = new XSource({
+      apiKey: config.xApiKey,
+      timeout: this.config.timeout,
+      maxRetries: this.config.maxRetries
+    });
+    this.events = new EventEmitter();
+  }
+  /**
+   * Run a full scan on a target and return a verdict.
+   *
+   * This fetches X posts, on-chain history, cross-correlates them, runs all
+   * five detectors, and aggregates the result. A typical scan completes in
+   * 2-8 seconds depending on source latency.
+   */
+  async scan(input, options = {}) {
+    this.events.emit("scan:start", input);
+    const [posts, txs] = await Promise.all([
+      this.x.getRecentPosts(input.handle, { limit: 200 }),
+      this.helius.getWalletHistory(input.wallet, { limit: 500 })
+    ]);
+    if (posts.length === 0 && txs.length === 0) {
+      throw new ScanError(
+        `No data found for @${input.handle} or wallet ${input.wallet.slice(0, 8)}...`
+      );
+    }
+    const requested = options.only ?? ["cadence", "onchain", "voice", "timing", "correlation"];
+    const results = [];
+    for (const name of requested) {
+      const started = Date.now();
+      try {
+        let result;
+        switch (name) {
+          case "cadence":
+            result = cadenceDetector(posts);
+            break;
+          case "onchain":
+            result = onchainDetector(txs);
+            break;
+          case "voice":
+            result = voiceDetector(posts);
+            break;
+          case "timing":
+            result = timingDetector(posts, txs);
+            break;
+          case "correlation":
+            result = correlationDetector(posts, txs, input);
+            break;
+        }
+        result.runtime_ms = Date.now() - started;
+        results.push(result);
+        this.events.emit("detector:done", result);
+      } catch (err) {
+        throw new ScanError(
+          `Detector ${name} failed: ${err.message}`,
+          name
+        );
+      }
+    }
+    const verdict = aggregate(input, results, options);
+    this.events.emit("scan:done", verdict);
+    return verdict;
+  }
+  /**
+   * Scan a batch of targets concurrently. Respects the configured rate limits
+   * on underlying sources. Use for watchlists.
+   */
+  async scanMany(inputs, options = {}) {
+    const results = [];
+    for (const input of inputs) {
+      try {
+        results.push(await this.scan(input, options));
+      } catch (err) {
+        this.events.emit("scan:error", { input, error: err });
+      }
+    }
+    return results;
+  }
+};
+
+// src/core/signing.ts
+import * as ed from "@noble/ed25519";
+import { sha256 } from "@noble/hashes/sha256";
+function canonicalize(verdict) {
+  const sorted = JSON.stringify(verdict, Object.keys(verdict).sort());
+  return new TextEncoder().encode(sorted);
+}
+function commitmentHash(verdict) {
+  const payload = `${verdict.target.wallet}|${verdict.target.handle}|${verdict.aggregate_score}|${verdict.scanned_at}`;
+  const digest = sha256(new TextEncoder().encode(payload));
+  return Buffer.from(digest).toString("hex");
+}
+async function signVerdict(verdict, privateKeyHex, feedUrl) {
+  const priv = Buffer.from(privateKeyHex, "hex");
+  if (priv.length !== 32) {
+    throw new SignatureError(
+      `ed25519 private key must be 32 bytes, got ${priv.length}`
+    );
+  }
+  const message = canonicalize(verdict);
+  const signature = await ed.signAsync(message, priv);
+  return {
+    ...verdict,
+    signature: Buffer.from(signature).toString("hex"),
+    commitment: commitmentHash(verdict),
+    posted_at: Math.floor(Date.now() / 1e3),
+    feed_url: feedUrl
+  };
+}
+async function verifyVerdict(publicVerdict, publicKeyHex) {
+  const pub = Buffer.from(publicKeyHex, "hex");
+  if (pub.length !== 32) {
+    throw new SignatureError(
+      `ed25519 public key must be 32 bytes, got ${pub.length}`
+    );
+  }
+  const { signature, commitment, posted_at, feed_url, ...verdictOnly } = publicVerdict;
+  const expectedCommitment = commitmentHash(verdictOnly);
+  if (expectedCommitment !== commitment) {
+    throw new SignatureError(
+      `commitment mismatch: ${expectedCommitment} vs ${commitment}`
+    );
+  }
+  const message = canonicalize(verdictOnly);
+  const sig = Buffer.from(signature, "hex");
+  return ed.verifyAsync(sig, message, pub);
+}
+
+// src/index.ts
+var VERSION = "0.9.3";
+export {
+  PulseError,
+  PulseProtocol,
+  ScanError,
+  SignatureError,
+  SourceError,
+  VERSION,
+  aggregate,
+  signVerdict,
+  verifyVerdict
+};
+//# sourceMappingURL=index.js.map