hood-alerts 0.1.0

package/dist/service/index.cjs

@@ -0,0 +1,3774 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/service/index.ts
+var service_exports = {};
+__export(service_exports, {
+  AlertStore: () => AlertStore,
+  LEVELS: () => LEVELS,
+  VERSION: () => VERSION,
+  createDispatcher: () => createDispatcher,
+  createHttpServer: () => createHttpServer,
+  createLogger: () => createLogger,
+  createService: () => createService,
+  createSilentLogger: () => createSilentLogger,
+  decode: () => decode,
+  decodeEvent: () => decodeEvent,
+  encode: () => encode,
+  encodeEvent: () => encodeEvent,
+  loadConfig: () => loadConfig,
+  renderMetrics: () => renderMetrics
+});
+module.exports = __toCommonJS(service_exports);
+
+// src/service/config.ts
+var import_zod = require("zod");
+var bool = (defaultValue) => import_zod.z.string().optional().transform((value) => {
+  if (value === void 0 || value.trim() === "") return defaultValue;
+  return /^(1|true|yes|on)$/i.test(value.trim());
+});
+var int = (defaultValue, min, max) => import_zod.z.string().optional().transform((value) => value === void 0 || value.trim() === "" ? defaultValue : Number(value)).refine((value) => Number.isFinite(value) && value >= min && value <= max, {
+  message: `must be a number between ${min} and ${max}`
+});
+var bigintValue = (defaultValue) => import_zod.z.string().optional().transform((value) => value === void 0 || value.trim() === "" ? defaultValue : BigInt(value.trim()));
+var csv = import_zod.z.string().optional().transform(
+  (value) => (value ?? "").split(",").map((entry) => entry.trim()).filter(Boolean)
+);
+var addressValue = import_zod.z.string().regex(/^0x[0-9a-fA-F]{40}$/, "must be a 0x-prefixed address").optional();
+var envSchema = import_zod.z.object({
+  NETWORK: import_zod.z.enum(["mainnet", "testnet"]).optional().default("mainnet"),
+  ROBINHOOD_RPC_URL: import_zod.z.string().url().optional(),
+  DB_PATH: import_zod.z.string().optional().default("./data/hood-alerts.sqlite"),
+  PORT: int(8080, 1, 65535),
+  LOG_LEVEL: import_zod.z.enum(["debug", "info", "warn", "error"]).optional().default("info"),
+  DRY_RUN: bool(false),
+  TELEGRAM_BOT_TOKEN: import_zod.z.string().optional(),
+  DISCORD_BOT_TOKEN: import_zod.z.string().optional(),
+  DISCORD_APPLICATION_ID: import_zod.z.string().optional(),
+  DISCORD_PUBLIC_KEY: import_zod.z.string().optional(),
+  DISCORD_INTERACTIONS_PATH: import_zod.z.string().optional().default("/discord/interactions"),
+  POLL_INTERVAL_MS: int(3e3, 250, 6e5),
+  FLUSH_INTERVAL_MS: int(1e3, 100, 6e5),
+  CONFIRMATIONS: bigintValue(2n),
+  CHUNK_SIZE: bigintValue(2000n),
+  INITIAL_LOOKBACK_BLOCKS: bigintValue(5000n),
+  WHALE_MIN_USD: int(1e3, 0, 1e9),
+  WHALE_POOL_LIMIT: int(400, 1, 5e3),
+  FLUSH_BATCH_SIZE: int(50, 1, 1e3),
+  MAX_DELIVERY_ATTEMPTS: int(6, 1, 50),
+  RETRY_BACKOFF_MS: int(3e4, 100, 36e5),
+  OUTBOX_RETENTION_HOURS: int(72, 1, 8760),
+  ENTITLEMENTS: import_zod.z.enum(["static", "usdg", "both"]).optional().default("static"),
+  PREMIUM_SUBSCRIBERS: csv,
+  ALL_PREMIUM: bool(false),
+  USDG_RECEIVER: addressValue,
+  PREMIUM_PRICE_USDG: int(25, 1, 1e6),
+  PREMIUM_PERIOD_DAYS: int(30, 1, 3650),
+  PAYMENTS_FROM_BLOCK: bigintValue(0n),
+  UPGRADE_INSTRUCTIONS: import_zod.z.string().optional()
+});
+function loadConfig(env = process.env) {
+  const parsed = envSchema.safeParse(env);
+  if (!parsed.success) {
+    const detail = parsed.error.issues.map((issue) => `${issue.path.join(".") || "env"}: ${issue.message}`).join("\n  ");
+    throw new Error(`hood-alerts: invalid configuration
+  ${detail}`);
+  }
+  const value = parsed.data;
+  if (value.ENTITLEMENTS !== "static" && !value.USDG_RECEIVER) {
+    throw new Error(
+      "hood-alerts: ENTITLEMENTS=usdg (or both) needs USDG_RECEIVER, the address subscribers pay."
+    );
+  }
+  if (value.DISCORD_APPLICATION_ID && !value.DISCORD_PUBLIC_KEY) {
+    throw new Error(
+      "hood-alerts: DISCORD_APPLICATION_ID is set but DISCORD_PUBLIC_KEY is not. Interactions cannot be verified without it."
+    );
+  }
+  return {
+    network: value.NETWORK,
+    rpcUrl: value.ROBINHOOD_RPC_URL,
+    dbPath: value.DB_PATH,
+    port: value.PORT,
+    logLevel: value.LOG_LEVEL,
+    dryRun: value.DRY_RUN,
+    telegramBotToken: value.TELEGRAM_BOT_TOKEN,
+    discordBotToken: value.DISCORD_BOT_TOKEN,
+    discordApplicationId: value.DISCORD_APPLICATION_ID,
+    discordPublicKey: value.DISCORD_PUBLIC_KEY,
+    discordInteractionsPath: value.DISCORD_INTERACTIONS_PATH,
+    pollIntervalMs: value.POLL_INTERVAL_MS,
+    flushIntervalMs: value.FLUSH_INTERVAL_MS,
+    confirmations: value.CONFIRMATIONS,
+    chunkSize: value.CHUNK_SIZE,
+    initialLookbackBlocks: value.INITIAL_LOOKBACK_BLOCKS,
+    whaleMinUsd: value.WHALE_MIN_USD,
+    whalePoolLimit: value.WHALE_POOL_LIMIT,
+    flushBatchSize: value.FLUSH_BATCH_SIZE,
+    maxDeliveryAttempts: value.MAX_DELIVERY_ATTEMPTS,
+    retryBackoffMs: value.RETRY_BACKOFF_MS,
+    outboxRetentionHours: value.OUTBOX_RETENTION_HOURS,
+    entitlements: value.ENTITLEMENTS,
+    premiumSubscribers: value.PREMIUM_SUBSCRIBERS,
+    allPremium: value.ALL_PREMIUM,
+    usdgReceiver: value.USDG_RECEIVER,
+    premiumPriceUsdg: value.PREMIUM_PRICE_USDG,
+    premiumPeriodDays: value.PREMIUM_PERIOD_DAYS,
+    paymentsFromBlock: value.PAYMENTS_FROM_BLOCK,
+    upgradeInstructions: value.UPGRADE_INSTRUCTIONS
+  };
+}
+
+// src/service/store.ts
+var import_node_module = require("module");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_viem = require("viem");
+
+// src/rules/schema.ts
+var import_zod2 = require("zod");
+
+// src/events/types.ts
+var LAUNCHPAD_EVENT_KINDS = {
+  noxa: ["launch", "whale_trade"],
+  odyssey: ["launch", "curve_trade", "graduation", "whale_trade"]
+};
+
+// src/rules/schema.ts
+var addressPattern = /^0x[0-9a-fA-F]{40}$/;
+var addressSchema = import_zod2.z.string().regex(addressPattern, "must be a 0x-prefixed 20-byte address").transform((value) => value.toLowerCase());
+var eventKindSchema = import_zod2.z.enum(["launch", "curve_trade", "graduation", "whale_trade"]);
+var launchpadSchema = import_zod2.z.enum(["noxa", "odyssey"]);
+var sideSchema = import_zod2.z.enum(["buy", "sell", "any"]);
+var reputationFilterSchema = import_zod2.z.object({
+  /** Require the deployer to have launched at least this many tokens before. */
+  minPriorLaunches: import_zod2.z.number().int().min(0).max(1e4).optional(),
+  /** Reject serial deployers above this prior-launch count. */
+  maxPriorLaunches: import_zod2.z.number().int().min(0).max(1e4).optional(),
+  /**
+   * Reject a deployer with more than this many prior launches whose pool
+   * liquidity has since been drained below the rug threshold.
+   */
+  maxRuggedLaunches: import_zod2.z.number().int().min(0).max(1e4).optional(),
+  /**
+   * Require this launch's own LP position to be held by the launchpad's
+   * locker contract. Only meaningful for `launch` events that carry a pool
+   * (NOXA); events without a pool never satisfy it.
+   */
+  requireLpLocked: import_zod2.z.boolean().optional()
+}).strict().refine(
+  (value) => value.minPriorLaunches === void 0 || value.maxPriorLaunches === void 0 || value.minPriorLaunches <= value.maxPriorLaunches,
+  { message: "minPriorLaunches must not exceed maxPriorLaunches" }
+);
+var rateLimitSchema = import_zod2.z.object({
+  /** Hard cap on alerts this rule may deliver per rolling hour. */
+  maxPerHour: import_zod2.z.number().int().min(1).max(1e4).optional(),
+  /** Minimum gap between two alerts from this rule, in seconds. */
+  minIntervalSeconds: import_zod2.z.number().int().min(1).max(86400).optional()
+}).strict();
+var ruleSchema = import_zod2.z.object({
+  /** Stable id, unique within a subscription. Used in bot commands. */
+  id: import_zod2.z.string().min(1).max(32).regex(/^[a-z0-9][a-z0-9_-]*$/, "must be lowercase letters, digits, hyphen or underscore"),
+  /** Human label shown in `/rules`. */
+  name: import_zod2.z.string().min(1).max(64).optional(),
+  enabled: import_zod2.z.boolean().default(true),
+  /** Event kinds this rule reacts to. Defaults to all four. */
+  kinds: import_zod2.z.array(eventKindSchema).min(1).max(4).default(["launch", "curve_trade", "graduation", "whale_trade"]),
+  /** Launchpads this rule reacts to. Defaults to both. */
+  launchpads: import_zod2.z.array(launchpadSchema).min(1).max(2).default(["noxa", "odyssey"]),
+  /** Minimum USD value of the event. Events with an unknown value never pass. */
+  minUsd: import_zod2.z.number().min(0).max(1e12).optional(),
+  /** Maximum USD value of the event. */
+  maxUsd: import_zod2.z.number().min(0).max(1e12).optional(),
+  /** Minimum USD liquidity of the token's deepest known pool. */
+  minLiquidityUsd: import_zod2.z.number().min(0).max(1e12).optional(),
+  /** Maximum USD liquidity of the token's deepest known pool. */
+  maxLiquidityUsd: import_zod2.z.number().min(0).max(1e12).optional(),
+  /** Watchlist. When non-empty, only these tokens match. */
+  tokens: import_zod2.z.array(addressSchema).max(500).default([]),
+  /** Deployer watchlist. When non-empty, only these actors match. */
+  deployers: import_zod2.z.array(addressSchema).max(500).default([]),
+  /** Deployers to always reject, applied after every other filter. */
+  excludeDeployers: import_zod2.z.array(addressSchema).max(500).default([]),
+  /** Trade direction. Ignored by `launch` and `graduation` events. */
+  side: sideSchema.default("any"),
+  reputation: reputationFilterSchema.optional(),
+  rateLimit: rateLimitSchema.optional()
+}).strict().refine((rule) => rule.minUsd === void 0 || rule.maxUsd === void 0 || rule.minUsd <= rule.maxUsd, {
+  message: "minUsd must not exceed maxUsd",
+  path: ["minUsd"]
+}).refine(
+  (rule) => rule.minLiquidityUsd === void 0 || rule.maxLiquidityUsd === void 0 || rule.minLiquidityUsd <= rule.maxLiquidityUsd,
+  { message: "minLiquidityUsd must not exceed maxLiquidityUsd", path: ["minLiquidityUsd"] }
+).refine((rule) => rule.kinds.some((kind) => rule.launchpads.some((pad) => canEmit(pad, kind))), {
+  message: "this combination can never fire: NOXA is an instant launcher with no bonding curve, so it emits no curve_trade and no graduation",
+  path: ["kinds"]
+});
+var platformSchema = import_zod2.z.enum(["telegram", "discord"]);
+var subscriptionSchema = import_zod2.z.object({
+  id: import_zod2.z.string().min(1).max(64),
+  /**
+   * The account that owns this subscription, and the unit entitlements are
+   * checked against. For Telegram this is the user id, for Discord the guild
+   * id (a server pays once for its channels) or user id for a DM.
+   */
+  subscriberId: import_zod2.z.string().min(1).max(128),
+  platform: platformSchema,
+  /**
+   * Where alerts go: a Telegram chat id, a Discord channel id, or a Discord
+   * webhook URL. Validated per platform by the notifier, not here, because
+   * the same subscription record serves all three shapes.
+   */
+  target: import_zod2.z.string().min(1).max(512),
+  enabled: import_zod2.z.boolean().default(true),
+  rules: import_zod2.z.array(ruleSchema).max(100).default([]),
+  createdAtMs: import_zod2.z.number().int().nonnegative()
+}).strict().refine((sub) => new Set(sub.rules.map((rule) => rule.id)).size === sub.rules.length, {
+  message: "rule ids must be unique within a subscription",
+  path: ["rules"]
+});
+function canEmit(launchpad, kind) {
+  return LAUNCHPAD_EVENT_KINDS[launchpad].includes(kind);
+}
+function ruleComplexity(rule) {
+  let score = 0;
+  if (rule.minUsd !== void 0) score += 1;
+  if (rule.maxUsd !== void 0) score += 1;
+  if (rule.minLiquidityUsd !== void 0) score += 1;
+  if (rule.maxLiquidityUsd !== void 0) score += 1;
+  if (rule.tokens.length > 0) score += 1;
+  if (rule.deployers.length > 0) score += 1;
+  if (rule.excludeDeployers.length > 0) score += 1;
+  if (rule.side !== "any") score += 1;
+  if (rule.reputation) score += Object.values(rule.reputation).filter((v) => v !== void 0).length;
+  if (rule.rateLimit) score += 1;
+  return score;
+}
+function usesOnChainLookups(rule) {
+  return rule.minLiquidityUsd !== void 0 || rule.maxLiquidityUsd !== void 0 || rule.reputation !== void 0 && Object.values(rule.reputation).some((value) => value !== void 0);
+}
+function parseRule(input) {
+  return ruleSchema.parse(input);
+}
+function safeParseRule(input) {
+  return ruleSchema.safeParse(input);
+}
+function parseSubscription(input) {
+  return subscriptionSchema.parse(input);
+}
+function formatValidationError(error) {
+  return error.issues.map((issue) => {
+    const path = issue.path.join(".");
+    return path ? `${path}: ${issue.message}` : issue.message;
+  }).join("; ");
+}
+function defaultRules() {
+  return [
+    parseRule({ id: "launches", name: "New launches", kinds: ["launch"] }),
+    parseRule({
+      id: "graduations",
+      name: "Odyssey graduations",
+      kinds: ["graduation"],
+      launchpads: ["odyssey"]
+    }),
+    parseRule({ id: "whales", name: "Whale trades over $5k", kinds: ["whale_trade"], minUsd: 5e3 })
+  ];
+}
+
+// src/service/codec.ts
+var BIGINT_TAG = "$bigint";
+function encode(value) {
+  return JSON.stringify(
+    value,
+    (_key, raw) => typeof raw === "bigint" ? { [BIGINT_TAG]: raw.toString() } : raw
+  );
+}
+function decode(text) {
+  return JSON.parse(text, (_key, raw) => {
+    if (typeof raw === "object" && raw !== null && Object.keys(raw).length === 1 && typeof raw[BIGINT_TAG] === "string") {
+      return BigInt(raw[BIGINT_TAG]);
+    }
+    return raw;
+  });
+}
+function encodeEvent(event) {
+  return encode(event);
+}
+function decodeEvent(text) {
+  return decode(text);
+}
+
+// src/service/store.ts
+var import_meta = {};
+var requireFromHere = (0, import_node_module.createRequire)(
+  import_meta.url ?? `${process.cwd()}/`
+);
+var { DatabaseSync } = requireFromHere("node:sqlite");
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS subscriptions (
+  id            TEXT PRIMARY KEY,
+  subscriber_id TEXT NOT NULL,
+  platform      TEXT NOT NULL,
+  target        TEXT NOT NULL,
+  enabled       INTEGER NOT NULL DEFAULT 1,
+  rules         TEXT NOT NULL,
+  created_at    INTEGER NOT NULL,
+  updated_at    INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_subscriptions_subscriber ON subscriptions(subscriber_id);
+
+CREATE TABLE IF NOT EXISTS cursors (
+  source_id  TEXT PRIMARY KEY,
+  next_block TEXT NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS outbox (
+  id              TEXT PRIMARY KEY,
+  subscription_id TEXT NOT NULL,
+  subscriber_id   TEXT NOT NULL,
+  rule_id         TEXT NOT NULL,
+  event_id        TEXT NOT NULL,
+  event_json      TEXT NOT NULL,
+  platform        TEXT NOT NULL,
+  target          TEXT NOT NULL,
+  status          TEXT NOT NULL,
+  not_before      INTEGER NOT NULL,
+  attempts        INTEGER NOT NULL DEFAULT 0,
+  last_error      TEXT,
+  created_at      INTEGER NOT NULL,
+  updated_at      INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_outbox_due ON outbox(status, not_before);
+CREATE INDEX IF NOT EXISTS idx_outbox_event ON outbox(event_id);
+
+CREATE TABLE IF NOT EXISTS deliveries (
+  key           TEXT NOT NULL,
+  subscriber_id TEXT NOT NULL,
+  at            INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_deliveries_key ON deliveries(key, at);
+CREATE INDEX IF NOT EXISTS idx_deliveries_subscriber ON deliveries(subscriber_id, at);
+
+CREATE TABLE IF NOT EXISTS pools (
+  pool          TEXT PRIMARY KEY,
+  token         TEXT NOT NULL,
+  quote_token   TEXT NOT NULL,
+  launchpad     TEXT NOT NULL,
+  created_block TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_pools_token ON pools(token);
+CREATE INDEX IF NOT EXISTS idx_pools_created ON pools(created_block);
+
+CREATE TABLE IF NOT EXISTS wallet_links (
+  subscriber_id TEXT PRIMARY KEY,
+  address       TEXT NOT NULL,
+  linked_at     INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS link_nonces (
+  subscriber_id TEXT PRIMARY KEY,
+  nonce         TEXT NOT NULL,
+  issued_at     INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+`;
+var AlertStore = class _AlertStore {
+  db;
+  clock;
+  constructor(path, clock = () => Date.now()) {
+    if (path !== ":memory:") (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(path), { recursive: true });
+    this.db = new DatabaseSync(path);
+    this.clock = clock;
+    this.db.exec("PRAGMA journal_mode = WAL;");
+    this.db.exec("PRAGMA foreign_keys = ON;");
+    this.db.exec(SCHEMA);
+  }
+  /** Deterministic outbox key. The whole dedupe guarantee rests on this. */
+  static deliveryKey(eventId2, subscriptionId, ruleId) {
+    return `${eventId2}|${subscriptionId}|${ruleId}`;
+  }
+  // ---- cursors -----------------------------------------------------------
+  /** The next unprocessed block for a source, or `null` when never persisted. */
+  getCursor(sourceId) {
+    const row = this.db.prepare("SELECT next_block FROM cursors WHERE source_id = ?").get(sourceId);
+    return row ? BigInt(row.next_block) : null;
+  }
+  /** Persist the next unprocessed block. Call only after the range is enqueued. */
+  setCursor(sourceId, nextBlock) {
+    this.db.prepare(
+      `INSERT INTO cursors (source_id, next_block, updated_at) VALUES (?, ?, ?)
+         ON CONFLICT(source_id) DO UPDATE SET next_block = excluded.next_block, updated_at = excluded.updated_at`
+    ).run(sourceId, nextBlock.toString(), this.clock());
+  }
+  /** Every persisted cursor, for `/metrics` and for operator inspection. */
+  listCursors() {
+    const rows = this.db.prepare("SELECT source_id, next_block FROM cursors ORDER BY source_id").all();
+    return rows.map((row) => ({ sourceId: row.source_id, nextBlock: BigInt(row.next_block) }));
+  }
+  // ---- subscriptions -----------------------------------------------------
+  /** Insert or replace a subscription. */
+  saveSubscription(subscription) {
+    const now = this.clock();
+    this.db.prepare(
+      `INSERT INTO subscriptions (id, subscriber_id, platform, target, enabled, rules, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           subscriber_id = excluded.subscriber_id,
+           platform = excluded.platform,
+           target = excluded.target,
+           enabled = excluded.enabled,
+           rules = excluded.rules,
+           updated_at = excluded.updated_at`
+    ).run(
+      subscription.id,
+      subscription.subscriberId,
+      subscription.platform,
+      subscription.target,
+      subscription.enabled ? 1 : 0,
+      encode(subscription.rules),
+      subscription.createdAtMs,
+      now
+    );
+  }
+  hydrate(row) {
+    return parseSubscription({
+      id: row.id,
+      subscriberId: row.subscriber_id,
+      platform: row.platform,
+      target: row.target,
+      enabled: row.enabled === 1,
+      rules: decode(row.rules),
+      createdAtMs: row.created_at
+    });
+  }
+  /** One subscription by id. */
+  getSubscription(id) {
+    const row = this.db.prepare("SELECT * FROM subscriptions WHERE id = ?").get(id);
+    return row ? this.hydrate(row) : null;
+  }
+  /** Every subscription owned by a subscriber. */
+  listSubscriptionsFor(subscriberId) {
+    const rows = this.db.prepare("SELECT * FROM subscriptions WHERE subscriber_id = ? ORDER BY created_at").all(subscriberId);
+    return rows.map((row) => this.hydrate(row));
+  }
+  /** Every enabled subscription, for the dispatch fan-out. */
+  listEnabledSubscriptions() {
+    const rows = this.db.prepare("SELECT * FROM subscriptions WHERE enabled = 1 ORDER BY created_at").all();
+    return rows.map((row) => this.hydrate(row));
+  }
+  /** Remove a subscription. Returns `true` when a row was deleted. */
+  deleteSubscription(id) {
+    const result = this.db.prepare("DELETE FROM subscriptions WHERE id = ?").run(id);
+    return Number(result.changes) > 0;
+  }
+  /** Every token on any enabled subscription's watchlist, deduped. */
+  watchlistTokens() {
+    const seen = /* @__PURE__ */ new Set();
+    for (const subscription of this.listEnabledSubscriptions()) {
+      for (const rule of subscription.rules) {
+        for (const token of rule.tokens) seen.add(token.toLowerCase());
+      }
+    }
+    return [...seen].map((token) => (0, import_viem.getAddress)(token));
+  }
+  // ---- outbox ------------------------------------------------------------
+  /**
+   * Queue a delivery.
+   *
+   * @returns `true` when this call created the row, `false` when it already
+   * existed (a replayed block range, a duplicate log). The boolean is the
+   * dedupe signal the dispatcher counts.
+   */
+  enqueue(row) {
+    const now = this.clock();
+    try {
+      this.db.prepare(
+        `INSERT INTO outbox (id, subscription_id, subscriber_id, rule_id, event_id, event_json,
+                               platform, target, status, not_before, attempts, last_error, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?, 0, NULL, ?, ?)`
+      ).run(
+        row.id,
+        row.subscriptionId,
+        row.subscriberId,
+        row.ruleId,
+        row.eventId,
+        row.eventJson,
+        row.platform,
+        row.target,
+        row.notBeforeMs,
+        now,
+        now
+      );
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (/UNIQUE|PRIMARY KEY/i.test(message)) return false;
+      throw error;
+    }
+  }
+  static toOutboxRow(raw) {
+    return {
+      id: raw.id,
+      subscriptionId: raw.subscription_id,
+      subscriberId: raw.subscriber_id,
+      ruleId: raw.rule_id,
+      eventId: raw.event_id,
+      eventJson: raw.event_json,
+      platform: raw.platform,
+      target: raw.target,
+      status: raw.status,
+      notBeforeMs: raw.not_before,
+      attempts: raw.attempts,
+      lastError: raw.last_error,
+      createdAtMs: raw.created_at,
+      updatedAtMs: raw.updated_at
+    };
+  }
+  /**
+   * Claim due deliveries, moving them to `sending` in one transaction so a
+   * second flush pass cannot pick up the same rows.
+   */
+  claimDue(nowMs, limit) {
+    const rows = this.db.prepare(
+      `SELECT * FROM outbox
+         WHERE status IN ('pending', 'failed') AND not_before <= ?
+         ORDER BY not_before, created_at
+         LIMIT ?`
+    ).all(nowMs, limit);
+    if (rows.length === 0) return [];
+    const update = this.db.prepare(`UPDATE outbox SET status = 'sending', updated_at = ? WHERE id = ?`);
+    this.db.exec("BEGIN");
+    try {
+      for (const row of rows) update.run(nowMs, row.id);
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+    return rows.map((row) => _AlertStore.toOutboxRow(row));
+  }
+  /** Mark a delivery sent. */
+  markSent(id) {
+    this.db.prepare(`UPDATE outbox SET status = 'sent', last_error = NULL, updated_at = ? WHERE id = ?`).run(this.clock(), id);
+  }
+  /** Record a retryable failure and schedule the next attempt. */
+  markFailed(id, attempts, error, nextAttemptAtMs) {
+    this.db.prepare(
+      `UPDATE outbox SET status = 'failed', attempts = ?, last_error = ?, not_before = ?, updated_at = ? WHERE id = ?`
+    ).run(attempts, error, nextAttemptAtMs, this.clock(), id);
+  }
+  /** Give up on a delivery (permanent rejection, or attempts exhausted). */
+  markDead(id, attempts, error) {
+    this.db.prepare(`UPDATE outbox SET status = 'dead', attempts = ?, last_error = ?, updated_at = ? WHERE id = ?`).run(attempts, error, this.clock(), id);
+  }
+  /**
+   * Return rows abandoned mid-flight by a crash to the queue.
+   *
+   * @returns how many rows were recovered.
+   */
+  recoverInFlight() {
+    const result = this.db.prepare(`UPDATE outbox SET status = 'pending', updated_at = ? WHERE status = 'sending'`).run(this.clock());
+    return Number(result.changes);
+  }
+  /** Delete delivered rows older than `beforeMs`, keeping the file bounded. */
+  pruneOutbox(beforeMs) {
+    const result = this.db.prepare(`DELETE FROM outbox WHERE status = 'sent' AND updated_at < ?`).run(beforeMs);
+    return Number(result.changes);
+  }
+  /** Delete delivery history older than `beforeMs`. */
+  pruneDeliveries(beforeMs) {
+    const result = this.db.prepare("DELETE FROM deliveries WHERE at < ?").run(beforeMs);
+    return Number(result.changes);
+  }
+  // ---- rate limiting and throughput --------------------------------------
+  /** A {@link RateLimitStore} backed by the `deliveries` table. */
+  rateLimitStore() {
+    return {
+      countSince: async (key, sinceMs) => {
+        const row = this.db.prepare("SELECT COUNT(*) AS n FROM deliveries WHERE key = ? AND at >= ?").get(key, sinceMs);
+        return Number(row.n);
+      },
+      lastAt: async (key) => {
+        const row = this.db.prepare("SELECT MAX(at) AS last FROM deliveries WHERE key = ?").get(key);
+        return row.last ?? null;
+      },
+      record: async (key, subscriberId, atMs) => {
+        this.recordDelivery(key, subscriberId, atMs);
+      },
+      countForSubscriberSince: async (subscriberId, sinceMs) => {
+        return this.countDeliveriesForSubscriber(subscriberId, sinceMs);
+      }
+    };
+  }
+  /** Record a delivery for both rate limiting and throughput accounting. */
+  recordDelivery(key, subscriberId, atMs) {
+    this.db.prepare("INSERT INTO deliveries (key, subscriber_id, at) VALUES (?, ?, ?)").run(key, subscriberId, atMs);
+  }
+  /** How many alerts a subscriber received since `sinceMs`. */
+  countDeliveriesForSubscriber(subscriberId, sinceMs) {
+    const row = this.db.prepare("SELECT COUNT(*) AS n FROM deliveries WHERE subscriber_id = ? AND at >= ?").get(subscriberId, sinceMs);
+    return Number(row.n);
+  }
+  // ---- pool registry -----------------------------------------------------
+  /** A {@link PoolRegistry} backed by the `pools` table. */
+  poolRegistry() {
+    return {
+      record: async (entry) => {
+        this.db.prepare(
+          `INSERT INTO pools (pool, token, quote_token, launchpad, created_block) VALUES (?, ?, ?, ?, ?)
+             ON CONFLICT(pool) DO UPDATE SET
+               token = excluded.token, quote_token = excluded.quote_token,
+               launchpad = excluded.launchpad, created_block = excluded.created_block`
+        ).run(
+          (0, import_viem.getAddress)(entry.pool),
+          (0, import_viem.getAddress)(entry.token),
+          (0, import_viem.getAddress)(entry.quoteToken),
+          entry.launchpad,
+          entry.createdBlock.toString()
+        );
+      },
+      active: async (limit, pinned = []) => {
+        const picked = /* @__PURE__ */ new Map();
+        if (pinned.length > 0) {
+          const placeholders = pinned.map(() => "?").join(",");
+          const rows2 = this.db.prepare(`SELECT * FROM pools WHERE lower(token) IN (${placeholders})`).all(...pinned.map((token) => token.toLowerCase()));
+          for (const row of rows2) {
+            const entry = _AlertStore.toPoolEntry(row);
+            picked.set(entry.pool.toLowerCase(), entry);
+          }
+        }
+        const rows = this.db.prepare(
+          // created_block is stored as text to keep bigint precision, so it
+          // is ordered numerically by length first, then lexically.
+          "SELECT * FROM pools ORDER BY length(created_block) DESC, created_block DESC LIMIT ?"
+        ).all(limit);
+        for (const row of rows) {
+          if (picked.size >= limit + pinned.length) break;
+          const entry = _AlertStore.toPoolEntry(row);
+          if (!picked.has(entry.pool.toLowerCase())) picked.set(entry.pool.toLowerCase(), entry);
+        }
+        return [...picked.values()];
+      },
+      originOf: async (token) => {
+        const row = this.db.prepare("SELECT launchpad FROM pools WHERE lower(token) = ? LIMIT 1").get(token.toLowerCase());
+        return row ? row.launchpad : null;
+      },
+      poolsFor: async (token) => {
+        const rows = this.db.prepare("SELECT * FROM pools WHERE lower(token) = ?").all(token.toLowerCase());
+        return rows.map((row) => _AlertStore.toPoolEntry(row));
+      },
+      size: async () => {
+        const row = this.db.prepare("SELECT COUNT(*) AS n FROM pools").get();
+        return Number(row.n);
+      }
+    };
+  }
+  static toPoolEntry(row) {
+    return {
+      pool: (0, import_viem.getAddress)(row["pool"]),
+      token: (0, import_viem.getAddress)(row["token"]),
+      quoteToken: (0, import_viem.getAddress)(row["quote_token"]),
+      launchpad: row["launchpad"],
+      createdBlock: BigInt(row["created_block"])
+    };
+  }
+  // ---- wallet links ------------------------------------------------------
+  /** Store a signature-verified wallet link. */
+  linkWallet(subscriberId, address) {
+    this.db.prepare(
+      `INSERT INTO wallet_links (subscriber_id, address, linked_at) VALUES (?, ?, ?)
+         ON CONFLICT(subscriber_id) DO UPDATE SET address = excluded.address, linked_at = excluded.linked_at`
+    ).run(subscriberId, (0, import_viem.getAddress)(address), this.clock());
+  }
+  /** A {@link WalletLinkStore} view of the links table. */
+  walletLinks() {
+    return {
+      walletOf: async (subscriberId) => {
+        const row = this.db.prepare("SELECT address FROM wallet_links WHERE subscriber_id = ?").get(subscriberId);
+        return row ? (0, import_viem.getAddress)(row.address) : null;
+      }
+    };
+  }
+  /** Issue (or reissue) the nonce a subscriber must sign to link a wallet. */
+  issueLinkNonce(subscriberId, nonce) {
+    this.db.prepare(
+      `INSERT INTO link_nonces (subscriber_id, nonce, issued_at) VALUES (?, ?, ?)
+         ON CONFLICT(subscriber_id) DO UPDATE SET nonce = excluded.nonce, issued_at = excluded.issued_at`
+    ).run(subscriberId, nonce, this.clock());
+    return nonce;
+  }
+  /** The outstanding link nonce for a subscriber, or `null`. */
+  getLinkNonce(subscriberId) {
+    const row = this.db.prepare("SELECT nonce FROM link_nonces WHERE subscriber_id = ?").get(subscriberId);
+    return row?.nonce ?? null;
+  }
+  /** Consume a link nonce so a signature cannot be replayed. */
+  clearLinkNonce(subscriberId) {
+    this.db.prepare("DELETE FROM link_nonces WHERE subscriber_id = ?").run(subscriberId);
+  }
+  // ---- meta and metrics --------------------------------------------------
+  /** Read a free-form service setting. */
+  getMeta(key) {
+    const row = this.db.prepare("SELECT value FROM meta WHERE key = ?").get(key);
+    return row?.value ?? null;
+  }
+  /** Write a free-form service setting. */
+  setMeta(key, value) {
+    this.db.prepare(
+      `INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+    ).run(key, value);
+  }
+  /** Aggregate counters for `/metrics`. */
+  metrics() {
+    const outbox = { pending: 0, sending: 0, sent: 0, failed: 0, dead: 0 };
+    const statusRows = this.db.prepare("SELECT status, COUNT(*) AS n FROM outbox GROUP BY status").all();
+    for (const row of statusRows) outbox[row.status] = Number(row.n);
+    const subs = this.db.prepare("SELECT COUNT(*) AS total, SUM(enabled) AS enabled FROM subscriptions").get();
+    const pools = this.db.prepare("SELECT COUNT(*) AS n FROM pools").get();
+    const deliveries = this.db.prepare("SELECT COUNT(*) AS n FROM deliveries WHERE at >= ?").get(this.clock() - 36e5);
+    return {
+      subscriptions: Number(subs.total),
+      enabledSubscriptions: Number(subs.enabled ?? 0),
+      outbox,
+      pools: Number(pools.n),
+      deliveriesLastHour: Number(deliveries.n),
+      cursors: this.listCursors()
+    };
+  }
+  /** Close the database. Safe to call twice. */
+  close() {
+    try {
+      this.db.close();
+    } catch {
+    }
+  }
+};
+
+// src/rules/reputation.ts
+var import_viem3 = require("viem");
+var import_hoodchain2 = require("hoodchain");
+
+// src/events/logs.ts
+var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function isResultTooLarge(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /exceeds limit|too many results|response size exceeded|query returned more than/i.test(message);
+}
+function isRetryableRpcError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /too many requests|rate limit|timed out|timeout|429|503|502|ECONNRESET|socket hang up|fetch failed/i.test(
+    message
+  );
+}
+async function fetchLogRange(fetcher, from, to, options = {}) {
+  const minSpan = options.minSpan ?? 1n;
+  const retries = options.retries ?? 5;
+  const backoffMs = options.backoffMs ?? 500;
+  const sleep2 = options.sleep ?? defaultSleep;
+  const run = async (lo, hi) => {
+    let attempt = 0;
+    for (; ; ) {
+      try {
+        return [...await fetcher(lo, hi)];
+      } catch (error) {
+        if (isResultTooLarge(error)) {
+          const span = hi - lo;
+          if (span < minSpan || span === 0n) throw error;
+          const mid = lo + span / 2n;
+          const left = await run(lo, mid);
+          const right = await run(mid + 1n, hi);
+          return [...left, ...right];
+        }
+        if (isRetryableRpcError(error) && attempt < retries) {
+          await sleep2(backoffMs * 2 ** attempt);
+          attempt += 1;
+          continue;
+        }
+        throw error;
+      }
+    }
+  };
+  if (to < from) return [];
+  return run(from, to);
+}
+function batchAddresses(addresses, size = 200) {
+  const batches = [];
+  for (let i = 0; i < addresses.length; i += size) {
+    batches.push(addresses.slice(i, i + size));
+  }
+  return batches;
+}
+
+// src/events/pricing.ts
+var import_viem2 = require("viem");
+var import_hoodchain = require("hoodchain");
+function quoteTokens(client) {
+  return client.network === "testnet" ? { weth: import_hoodchain.TESTNET_ADDRESSES.weth, usdg: import_hoodchain.TESTNET_ADDRESSES.usdg } : { weth: import_hoodchain.MAINNET_ADDRESSES.weth, usdg: import_hoodchain.MAINNET_ADDRESSES.usdg };
+}
+function createPriceOracle(client, options = {}) {
+  const ttlMs = options.ttlMs ?? 3e4;
+  const probeWei = options.probeWei ?? 10n ** 18n;
+  const now = options.now ?? Date.now;
+  const { weth, usdg } = quoteTokens(client);
+  let cached = null;
+  let cachedAt = 0;
+  let inflight = null;
+  async function refresh() {
+    try {
+      const quote = await (0, import_hoodchain.quoteSwap)(client, { tokenIn: weth, tokenOut: usdg, amountIn: probeWei });
+      const usdgOut = Number((0, import_viem2.formatUnits)(quote.amountOut, import_hoodchain.USDG_DECIMALS));
+      const ethIn = Number((0, import_viem2.formatUnits)(probeWei, 18));
+      const rate = ethIn > 0 ? usdgOut / ethIn : 0;
+      cached = rate > 0 ? rate : null;
+    } catch {
+      cached = null;
+    }
+    cachedAt = now();
+    return cached;
+  }
+  async function ethUsd() {
+    if (cachedAt !== 0 && now() - cachedAt < ttlMs) return cached;
+    inflight ??= refresh().finally(() => {
+      inflight = null;
+    });
+    return inflight;
+  }
+  return {
+    ethUsd,
+    async weiToUsd(wei) {
+      const rate = await ethUsd();
+      if (rate === null) return null;
+      return Number((0, import_viem2.formatUnits)(wei < 0n ? -wei : wei, 18)) * rate;
+    },
+    usdgToUsd(atomic) {
+      return Number((0, import_viem2.formatUnits)(atomic < 0n ? -atomic : atomic, import_hoodchain.USDG_DECIMALS));
+    }
+  };
+}
+
+// src/rules/reputation.ts
+var positionManagerAbi = [
+  {
+    type: "function",
+    name: "ownerOf",
+    stateMutability: "view",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ type: "address" }]
+  }
+];
+var ODYSSEY_FACTORIES = [
+  import_hoodchain2.ODYSSEY_ADDRESSES.bondingCurveFactory,
+  import_hoodchain2.ODYSSEY_ADDRESSES.reflectionFactory,
+  import_hoodchain2.ODYSSEY_ADDRESSES.instantFactory
+];
+function createRpcReputationProvider(client, oracle, options = {}) {
+  const ttlMs = options.ttlMs ?? 6e5;
+  const maxHistory = options.maxHistory ?? 200;
+  const maxInspect = options.maxInspect ?? 25;
+  const rugThresholdUsd = options.rugThresholdUsd ?? 50;
+  const now = options.now ?? Date.now;
+  const cache = /* @__PURE__ */ new Map();
+  const inflight = /* @__PURE__ */ new Map();
+  const lockCache = /* @__PURE__ */ new Map();
+  const { weth, usdg } = quoteTokens(client);
+  async function reserveUsd(pool, quoteToken) {
+    const quote = quoteToken.toLowerCase();
+    if (quote !== weth.toLowerCase() && quote !== usdg.toLowerCase()) return null;
+    const balance = await client.public.readContract({
+      address: quoteToken,
+      abi: import_hoodchain2.erc20Abi,
+      functionName: "balanceOf",
+      args: [pool]
+    });
+    if (quote === usdg.toLowerCase()) return Number((0, import_viem3.formatUnits)(balance, import_hoodchain2.USDG_DECIMALS));
+    return oracle.weiToUsd(balance);
+  }
+  async function isLpLocked(positionId) {
+    const key = positionId.toString();
+    const hit = lockCache.get(key);
+    if (hit !== void 0) return hit;
+    try {
+      const owner = await client.public.readContract({
+        address: import_hoodchain2.MAINNET_ADDRESSES.nonfungiblePositionManager,
+        abi: positionManagerAbi,
+        functionName: "ownerOf",
+        args: [positionId]
+      });
+      const locked = owner.toLowerCase() === import_hoodchain2.NOXA_ADDRESSES.locker.toLowerCase();
+      lockCache.set(key, locked);
+      return locked;
+    } catch {
+      return false;
+    }
+  }
+  async function load(deployer) {
+    const head = await client.public.getBlockNumber();
+    const [noxaLogs, odysseyLogs] = await Promise.all([
+      fetchLogRange(
+        (from, to) => client.public.getLogs({
+          address: import_hoodchain2.NOXA_ADDRESSES.launchFactory,
+          event: import_hoodchain2.noxaTokenLaunchedEvent,
+          args: { deployer },
+          fromBlock: from,
+          toBlock: to
+        }),
+        import_hoodchain2.NOXA_ADDRESSES.deployBlock,
+        head,
+        options.logOptions ?? {}
+      ),
+      fetchLogRange(
+        (from, to) => client.public.getLogs({
+          address: ODYSSEY_FACTORIES,
+          event: import_hoodchain2.odysseyTokenCreatedEvent,
+          args: { creator: deployer },
+          fromBlock: from,
+          toBlock: to
+        }),
+        import_hoodchain2.NOXA_ADDRESSES.deployBlock,
+        head,
+        options.logOptions ?? {}
+      )
+    ]);
+    const launches = [];
+    for (const log of noxaLogs) {
+      const token = log.args.token;
+      if (!token) continue;
+      const pool = log.args.pool ?? null;
+      const pairToken = log.args.pairToken ?? null;
+      launches.push({
+        launchpad: "noxa",
+        token: (0, import_viem3.getAddress)(token),
+        pool: pool ? (0, import_viem3.getAddress)(pool) : null,
+        quoteToken: pairToken ? (0, import_viem3.getAddress)(pairToken) : null,
+        positionId: log.args.positionId ?? null,
+        blockNumber: log.blockNumber
+      });
+    }
+    for (const log of odysseyLogs) {
+      const token = log.args.token;
+      if (!token) continue;
+      launches.push({
+        launchpad: "odyssey",
+        token: (0, import_viem3.getAddress)(token),
+        pool: null,
+        quoteToken: null,
+        positionId: null,
+        blockNumber: log.blockNumber
+      });
+    }
+    launches.sort((a, b) => a.blockNumber < b.blockNumber ? -1 : a.blockNumber > b.blockNumber ? 1 : 0);
+    const kept = launches.slice(-maxHistory);
+    const inspectable = kept.slice(-maxInspect);
+    let lockedLaunches = 0;
+    let ruggedLaunches = 0;
+    for (const launch of inspectable) {
+      if (launch.positionId !== null && await isLpLocked(launch.positionId)) lockedLaunches += 1;
+      if (launch.pool && launch.quoteToken) {
+        try {
+          const usd = await reserveUsd(launch.pool, launch.quoteToken);
+          if (usd !== null && usd < rugThresholdUsd) ruggedLaunches += 1;
+        } catch {
+        }
+      }
+    }
+    return {
+      deployer: (0, import_viem3.getAddress)(deployer),
+      launches: kept,
+      lockedLaunches,
+      ruggedLaunches,
+      inspected: inspectable.length,
+      computedAtMs: now()
+    };
+  }
+  return {
+    async get(deployer) {
+      const key = deployer.toLowerCase();
+      const hit = cache.get(key);
+      if (hit && now() - hit.computedAtMs < ttlMs) return hit;
+      const pending = inflight.get(key);
+      if (pending) return pending;
+      const promise = load(deployer).then((record) => {
+        cache.set(key, record);
+        return record;
+      }).finally(() => {
+        inflight.delete(key);
+      });
+      inflight.set(key, promise);
+      return promise;
+    },
+    isLpLocked
+  };
+}
+function priorLaunchesBefore(record, blockNumber) {
+  return record.launches.filter((launch) => launch.blockNumber < blockNumber).length;
+}
+
+// src/rules/engine.ts
+var matchOk = (rule) => ({ matched: true, reason: `rule ${rule.id} matched` });
+var miss = (reason) => ({ matched: false, reason });
+function eventSide(event) {
+  if (event.kind === "curve_trade" || event.kind === "whale_trade") return event.side;
+  return null;
+}
+function eventPositionId(event) {
+  if (event.kind === "launch") return event.positionId;
+  if (event.kind === "graduation") return event.positionId;
+  return null;
+}
+async function evaluateRule(rule, event, context = {}) {
+  if (!rule.enabled) return miss(`rule ${rule.id} is disabled`);
+  if (!rule.kinds.includes(event.kind)) {
+    return miss(`kind ${event.kind} not in [${rule.kinds.join(", ")}]`);
+  }
+  if (!rule.launchpads.includes(event.launchpad)) {
+    return miss(`launchpad ${event.launchpad} not in [${rule.launchpads.join(", ")}]`);
+  }
+  const actor = event.actor.toLowerCase();
+  if (rule.excludeDeployers.includes(actor)) {
+    return miss(`actor ${event.actor} is on the exclude list`);
+  }
+  if (rule.tokens.length > 0 && !rule.tokens.includes(event.token.toLowerCase())) {
+    return miss(`token ${event.token} is not on the watchlist`);
+  }
+  if (rule.deployers.length > 0 && !rule.deployers.includes(actor)) {
+    return miss(`actor ${event.actor} is not on the deployer watchlist`);
+  }
+  if (rule.side !== "any") {
+    const side = eventSide(event);
+    if (side === null) return miss(`side filter does not apply to ${event.kind} events`);
+    if (side !== rule.side) return miss(`side ${side} is not ${rule.side}`);
+  }
+  if (rule.minUsd !== void 0) {
+    if (event.usdValue === null) return miss("event has no USD value to compare against minUsd");
+    if (event.usdValue < rule.minUsd) {
+      return miss(`usdValue ${event.usdValue.toFixed(2)} below minUsd ${rule.minUsd}`);
+    }
+  }
+  if (rule.maxUsd !== void 0) {
+    if (event.usdValue === null) return miss("event has no USD value to compare against maxUsd");
+    if (event.usdValue > rule.maxUsd) {
+      return miss(`usdValue ${event.usdValue.toFixed(2)} above maxUsd ${rule.maxUsd}`);
+    }
+  }
+  if (rule.minLiquidityUsd !== void 0 || rule.maxLiquidityUsd !== void 0) {
+    if (!context.liquidityUsd) {
+      return miss("rule filters on liquidity but no liquidity reader was provided");
+    }
+    const liquidity = await context.liquidityUsd(event);
+    if (liquidity === null) return miss("token liquidity is unknown");
+    if (rule.minLiquidityUsd !== void 0 && liquidity < rule.minLiquidityUsd) {
+      return miss(`liquidity ${liquidity.toFixed(2)} below minLiquidityUsd ${rule.minLiquidityUsd}`);
+    }
+    if (rule.maxLiquidityUsd !== void 0 && liquidity > rule.maxLiquidityUsd) {
+      return miss(`liquidity ${liquidity.toFixed(2)} above maxLiquidityUsd ${rule.maxLiquidityUsd}`);
+    }
+  }
+  const reputationFilter = rule.reputation;
+  if (reputationFilter) {
+    const needsRecord = reputationFilter.minPriorLaunches !== void 0 || reputationFilter.maxPriorLaunches !== void 0 || reputationFilter.maxRuggedLaunches !== void 0;
+    if (needsRecord) {
+      if (!context.reputation) {
+        return miss("rule filters on reputation but no reputation provider was configured");
+      }
+      const record = await context.reputation(event.actor);
+      const prior = priorLaunchesBefore(record, event.blockNumber);
+      if (reputationFilter.minPriorLaunches !== void 0 && prior < reputationFilter.minPriorLaunches) {
+        return miss(`deployer had ${prior} prior launches, needs ${reputationFilter.minPriorLaunches}`);
+      }
+      if (reputationFilter.maxPriorLaunches !== void 0 && prior > reputationFilter.maxPriorLaunches) {
+        return miss(`deployer had ${prior} prior launches, max is ${reputationFilter.maxPriorLaunches}`);
+      }
+      if (reputationFilter.maxRuggedLaunches !== void 0 && record.ruggedLaunches > reputationFilter.maxRuggedLaunches) {
+        return miss(
+          `deployer has ${record.ruggedLaunches} drained pools, max is ${reputationFilter.maxRuggedLaunches}`
+        );
+      }
+    }
+    if (reputationFilter.requireLpLocked === true) {
+      const positionId = eventPositionId(event);
+      if (positionId === null) return miss("event carries no LP position to check for a lock");
+      if (!context.isLpLocked) {
+        return miss("rule requires an LP lock check but no reputation provider was configured");
+      }
+      if (!await context.isLpLocked(positionId)) {
+        return miss(`LP position ${positionId} is not held by the launchpad locker`);
+      }
+    }
+  }
+  return matchOk(rule);
+}
+async function matchRules(rules, event, context = {}) {
+  const results = await Promise.all(
+    rules.map(async (rule) => {
+      try {
+        return { rule, result: await evaluateRule(rule, event, context) };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { rule, result: miss(`evaluation failed: ${message}`) };
+      }
+    })
+  );
+  return results.filter((entry) => entry.result.matched);
+}
+
+// src/rules/ratelimit.ts
+var ALLOWED = { allowed: true, reason: null, retryAtMs: null };
+async function checkRateLimit(store, key, config, nowMs) {
+  if (!config) return ALLOWED;
+  if (config.minIntervalSeconds !== void 0) {
+    const last = await store.lastAt(key);
+    if (last !== null) {
+      const nextAllowed = last + config.minIntervalSeconds * 1e3;
+      if (nowMs < nextAllowed) {
+        return {
+          allowed: false,
+          reason: `minIntervalSeconds=${config.minIntervalSeconds} not elapsed`,
+          retryAtMs: nextAllowed
+        };
+      }
+    }
+  }
+  if (config.maxPerHour !== void 0) {
+    const windowStart = nowMs - 36e5;
+    const used = await store.countSince(key, windowStart);
+    if (used >= config.maxPerHour) {
+      return {
+        allowed: false,
+        reason: `maxPerHour=${config.maxPerHour} reached (${used} in the last hour)`,
+        retryAtMs: windowStart + 36e5
+      };
+    }
+  }
+  return ALLOWED;
+}
+function rateLimitKey(subscriptionId, ruleId) {
+  return `${subscriptionId}:${ruleId}`;
+}
+
+// src/notifiers/format.ts
+var import_viem4 = require("viem");
+
+// src/notifiers/escape.ts
+var MARKDOWN_V2_RESERVED = "_*[]()~`>#+-=|{}.!";
+function escapeMarkdownV2(text) {
+  let out = "";
+  for (const char of text) {
+    if (MARKDOWN_V2_RESERVED.includes(char)) out += "\\";
+    out += char;
+  }
+  return out;
+}
+function escapeMarkdownV2Url(url) {
+  return url.replace(/[\\)]/g, (char) => `\\${char}`);
+}
+function markdownV2Link(label, url) {
+  return `[${escapeMarkdownV2(label)}](${escapeMarkdownV2Url(url)})`;
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeHtmlAttribute(value) {
+  return escapeHtml(value).replace(/"/g, "&quot;");
+}
+function htmlLink(label, url) {
+  return `<a href="${escapeHtmlAttribute(url)}">${escapeHtml(label)}</a>`;
+}
+var DISCORD_RESERVED = /[\\*_~`|>[\]()]/g;
+function escapeDiscordMarkdown(text) {
+  return text.replace(DISCORD_RESERVED, (char) => `\\${char}`);
+}
+function truncate(text, max) {
+  if (max <= 0) return "";
+  const chars = [...text];
+  if (chars.length <= max) return text;
+  if (max === 1) return "\u2026";
+  return `${chars.slice(0, max - 1).join("")}\u2026`;
+}
+function displayLabel(symbol, address) {
+  const trimmed = symbol?.trim();
+  if (trimmed) return truncate(trimmed, 40);
+  return shortAddress(address);
+}
+function shortAddress(address) {
+  if (address.length <= 12) return address;
+  return `${address.slice(0, 6)}\u2026${address.slice(-4)}`;
+}
+
+// src/notifiers/format.ts
+var EMBED_COLORS = {
+  launch: 2278750,
+  curve_trade: 3718648,
+  graduation: 11032055,
+  whale_trade: 16096779
+};
+var KIND_EMOJI = {
+  launch: "\u{1F680}",
+  curve_trade: "\u{1F4C8}",
+  graduation: "\u{1F393}",
+  whale_trade: "\u{1F40B}"
+};
+var LAUNCHPAD_NAMES = { noxa: "NOXA", odyssey: "The Odyssey" };
+var usdFormatter = new Intl.NumberFormat("en-US", {
+  style: "currency",
+  currency: "USD",
+  maximumFractionDigits: 2
+});
+function formatUsd(value) {
+  if (value === null || !Number.isFinite(value)) return "unknown";
+  const abs = Math.abs(value);
+  if (abs >= 1e6) return `$${(value / 1e6).toFixed(2)}M`;
+  if (abs >= 1e4) return `$${(value / 1e3).toFixed(1)}K`;
+  return usdFormatter.format(value);
+}
+function formatAmount(value) {
+  const abs = Math.abs(value);
+  if (abs === 0) return "0";
+  if (abs >= 1e9) return `${(value / 1e9).toFixed(2)}B`;
+  if (abs >= 1e6) return `${(value / 1e6).toFixed(2)}M`;
+  if (abs >= 1e3) return `${(value / 1e3).toFixed(2)}K`;
+  if (abs >= 1) return value.toFixed(4).replace(/\.?0+$/, "");
+  return value.toPrecision(4);
+}
+function formatEth(wei) {
+  return `${formatAmount(Number((0, import_viem4.formatUnits)(wei < 0n ? -wei : wei, 18)))} ETH`;
+}
+function headline(event) {
+  const label = displayLabel(event.symbol, event.token);
+  const pad = LAUNCHPAD_NAMES[event.launchpad];
+  switch (event.kind) {
+    case "launch":
+      return `${KIND_EMOJI.launch} New launch: ${label} on ${pad}`;
+    case "curve_trade":
+      return `${KIND_EMOJI.curve_trade} Curve ${event.side}: ${label} for ${formatUsd(event.usdValue)}`;
+    case "graduation":
+      return `${KIND_EMOJI.graduation} Graduated: ${label} filled its curve`;
+    case "whale_trade":
+      return `${KIND_EMOJI.whale_trade} Whale ${event.side}: ${formatUsd(event.usdValue)} of ${label}`;
+  }
+}
+function detailRows(event) {
+  const rows = [];
+  rows.push({ label: "Launchpad", value: LAUNCHPAD_NAMES[event.launchpad], inline: true });
+  if (event.name) rows.push({ label: "Name", value: truncate(event.name, 64), inline: true });
+  rows.push({ label: "Token", value: shortAddress(event.token), inline: true });
+  switch (event.kind) {
+    case "launch": {
+      rows.push({
+        label: "Listing",
+        value: event.instantListing ? "Instant (live Uniswap v3 pool, no curve)" : "Bonding curve (graduates when filled)",
+        inline: true
+      });
+      rows.push({ label: "Deployer", value: shortAddress(event.actor), inline: true });
+      if (event.initialBuyAmount > 0n) {
+        rows.push({ label: "Initial buy", value: formatUsd(event.usdValue), inline: true });
+      }
+      break;
+    }
+    case "curve_trade": {
+      rows.push({ label: "Side", value: event.side === "buy" ? "Buy" : "Sell", inline: true });
+      rows.push({ label: "Size", value: formatEth(event.quoteAmountWei), inline: true });
+      rows.push({ label: "Value", value: formatUsd(event.usdValue), inline: true });
+      rows.push({
+        label: "Tokens",
+        value: formatAmount(Number((0, import_viem4.formatUnits)(event.tokenAmount, 18))),
+        inline: true
+      });
+      rows.push({ label: "Trader", value: shortAddress(event.actor), inline: true });
+      break;
+    }
+    case "graduation": {
+      rows.push({ label: "Pool", value: shortAddress(event.pool), inline: true });
+      rows.push({ label: "Seeded", value: formatUsd(event.usdValue), inline: true });
+      rows.push({ label: "LP position", value: `#${event.positionId}`, inline: true });
+      break;
+    }
+    case "whale_trade": {
+      rows.push({ label: "Side", value: event.side === "buy" ? "Buy" : "Sell", inline: true });
+      rows.push({ label: "Value", value: formatUsd(event.usdValue), inline: true });
+      rows.push({
+        label: "Size",
+        value: `${formatAmount(event.tokenAmount)} for ${formatAmount(event.quoteAmount)} ${event.quoteSymbol}`,
+        inline: true
+      });
+      rows.push({ label: "Price", value: `${formatAmount(event.price)} ${event.quoteSymbol}`, inline: true });
+      rows.push({ label: "Fee tier", value: `${event.feeTier / 1e4}%`, inline: true });
+      rows.push({ label: "Trader", value: shortAddress(event.actor), inline: true });
+      break;
+    }
+  }
+  return rows;
+}
+function renderAlert(event, options = {}) {
+  const parseMode = options.parseMode ?? "HTML";
+  const title = headline(event);
+  const rows = detailRows(event);
+  const label = displayLabel(event.symbol, event.token);
+  const linkPairs = [
+    { label: "Transaction", url: event.explorer.tx },
+    { label: "Token", url: event.explorer.token }
+  ];
+  if (event.explorer.pool) linkPairs.push({ label: "Pool", url: event.explorer.pool });
+  linkPairs.push({ label: "Actor", url: event.explorer.actor });
+  const text = parseMode === "HTML" ? [
+    `<b>${escapeHtml(title)}</b>`,
+    "",
+    ...rows.map((row) => `${escapeHtml(row.label)}: <b>${escapeHtml(row.value)}</b>`),
+    `Contract: <code>${escapeHtml(event.token)}</code>`,
+    "",
+    linkPairs.map((link) => htmlLink(link.label, link.url)).join(" \xB7 "),
+    ...options.footer ? ["", `<i>${escapeHtml(options.footer)}</i>`] : []
+  ].join("\n") : [
+    `*${escapeMarkdownV2(title)}*`,
+    "",
+    ...rows.map((row) => `${escapeMarkdownV2(row.label)}: *${escapeMarkdownV2(row.value)}*`),
+    `Contract: \`${event.token}\``,
+    "",
+    linkPairs.map((link) => markdownV2Link(link.label, link.url)).join(" \xB7 "),
+    ...options.footer ? ["", `_${escapeMarkdownV2(options.footer)}_`] : []
+  ].join("\n");
+  const fields = rows.map((row) => ({
+    name: truncate(row.label, 256),
+    value: truncate(escapeDiscordMarkdown(row.value), 1024),
+    inline: row.inline ?? false
+  }));
+  fields.push({
+    name: "Links",
+    value: linkPairs.map((link) => `[${link.label}](${link.url})`).join(" \xB7 "),
+    inline: false
+  });
+  const embed = {
+    title: truncate(escapeDiscordMarkdown(title), 256),
+    url: event.explorer.tx,
+    description: `\`${event.token}\``,
+    color: EMBED_COLORS[event.kind],
+    fields,
+    ...options.footer ? { footer: { text: truncate(options.footer, 2048) } } : {},
+    ...event.timestampMs !== null ? { timestamp: new Date(event.timestampMs).toISOString() } : {}
+  };
+  const plain = `${title} | ${label} ${event.token} | block ${event.blockNumber} | ${event.explorer.tx}`;
+  return { text, parseMode, embed, plain };
+}
+
+// src/service/dispatcher.ts
+function createDispatcher(options) {
+  const {
+    store,
+    sources,
+    gate,
+    rateLimits,
+    notifierFor,
+    getBlockNumber,
+    logger
+  } = options;
+  const confirmations = options.confirmations ?? 2n;
+  const chunkSize = options.chunkSize ?? 2000n;
+  const initialLookback = options.initialLookbackBlocks ?? 5000n;
+  const flushBatchSize = options.flushBatchSize ?? 50;
+  const maxAttempts = options.maxDeliveryAttempts ?? 6;
+  const retryBackoffMs = options.retryBackoffMs ?? 3e4;
+  const now = options.now ?? Date.now;
+  const evaluation = options.evaluation ?? {};
+  async function fanOut(event, subscriptions) {
+    let enqueued = 0;
+    let deduped = 0;
+    let suppressed = 0;
+    for (const subscription of subscriptions) {
+      const matches = await matchRules(subscription.rules, event, evaluation);
+      if (matches.length === 0) continue;
+      const { policy } = await gate.resolve(subscription.subscriberId);
+      for (const { rule } of matches) {
+        if (!policy.allowedKinds.includes(event.kind)) {
+          suppressed += 1;
+          continue;
+        }
+        const key = rateLimitKey(subscription.id, rule.id);
+        const limit = await checkRateLimit(rateLimits, key, rule.rateLimit, now());
+        if (!limit.allowed) {
+          suppressed += 1;
+          logger.debug("rate limited", { subscription: subscription.id, rule: rule.id, reason: limit.reason });
+          continue;
+        }
+        const usedThisHour = await rateLimits.countForSubscriberSince(
+          subscription.subscriberId,
+          now() - 36e5
+        );
+        const throughput = await gate.checkThroughput(subscription.subscriberId, usedThisHour);
+        if (!throughput.allowed) {
+          suppressed += 1;
+          logger.debug("throughput capped", {
+            subscriber: subscription.subscriberId,
+            reason: throughput.reason
+          });
+          continue;
+        }
+        const id = AlertStore.deliveryKey(event.id, subscription.id, rule.id);
+        const created = store.enqueue({
+          id,
+          subscriptionId: subscription.id,
+          subscriberId: subscription.subscriberId,
+          ruleId: rule.id,
+          eventId: event.id,
+          eventJson: encodeEvent(event),
+          platform: subscription.platform,
+          target: subscription.target,
+          notBeforeMs: now() + policy.deliveryDelayMs
+        });
+        if (!created) {
+          deduped += 1;
+          continue;
+        }
+        enqueued += 1;
+        await rateLimits.record(key, subscription.subscriberId, now());
+      }
+    }
+    return { enqueued, deduped, suppressed };
+  }
+  return {
+    recover() {
+      const recovered = store.recoverInFlight();
+      if (recovered > 0) logger.warn("recovered in-flight deliveries after restart", { recovered });
+      return recovered;
+    },
+    async pollOnce() {
+      const stats = {
+        ranges: [],
+        eventsDecoded: 0,
+        enqueued: 0,
+        deduped: 0,
+        suppressed: 0,
+        errors: []
+      };
+      const head = await getBlockNumber();
+      const safeHead = head > confirmations ? head - confirmations : 0n;
+      const subscriptions = store.listEnabledSubscriptions();
+      for (const source of sources) {
+        const persisted = store.getCursor(source.id);
+        const fallback = safeHead > initialLookback ? safeHead - initialLookback : source.startBlock;
+        const from = persisted ?? (fallback > source.startBlock ? fallback : source.startBlock);
+        if (from > safeHead) continue;
+        const to = from + chunkSize - 1n > safeHead ? safeHead : from + chunkSize - 1n;
+        try {
+          const events = await source.poll(from, to);
+          stats.eventsDecoded += events.length;
+          for (const event of events) {
+            const result = await fanOut(event, subscriptions);
+            stats.enqueued += result.enqueued;
+            stats.deduped += result.deduped;
+            stats.suppressed += result.suppressed;
+          }
+          store.setCursor(source.id, to + 1n);
+          stats.ranges.push({ sourceId: source.id, from, to });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          stats.errors.push({ sourceId: source.id, error: message });
+          logger.error("source poll failed, cursor not advanced", {
+            source: source.id,
+            from,
+            to,
+            error: message
+          });
+        }
+      }
+      return stats;
+    },
+    async flushOnce() {
+      const stats = { claimed: 0, sent: 0, retried: 0, dead: 0 };
+      const rows = store.claimDue(now(), flushBatchSize);
+      stats.claimed = rows.length;
+      for (const row of rows) {
+        const outcome = await deliver2(row);
+        if (outcome === "sent") stats.sent += 1;
+        else if (outcome === "retry") stats.retried += 1;
+        else stats.dead += 1;
+      }
+      return stats;
+    }
+  };
+  async function deliver2(row) {
+    const subscription = store.getSubscription(row.subscriptionId);
+    if (!subscription) {
+      store.markDead(row.id, row.attempts + 1, "subscription no longer exists");
+      return "dead";
+    }
+    const notifier = notifierFor(subscription);
+    if (!notifier) {
+      store.markDead(row.id, row.attempts + 1, `no notifier configured for platform ${row.platform}`);
+      return "dead";
+    }
+    let event;
+    try {
+      event = decodeEvent(row.eventJson);
+    } catch (error) {
+      store.markDead(row.id, row.attempts + 1, `corrupt event payload: ${String(error)}`);
+      return "dead";
+    }
+    const alert = renderAlert(event, {
+      ...options.render,
+      footer: options.render?.footer ?? `rule: ${row.ruleId}`
+    });
+    const result = await notifier.send(row.target, alert);
+    const attempts = row.attempts + 1;
+    if (result.ok) {
+      store.markSent(row.id);
+      logger.info("alert delivered", {
+        id: row.id,
+        platform: notifier.platform,
+        kind: event.kind,
+        token: event.token,
+        attempts: result.attempts
+      });
+      return "sent";
+    }
+    if (!result.retryable || attempts >= maxAttempts) {
+      store.markDead(row.id, attempts, result.error ?? "delivery failed");
+      logger.error("alert dead-lettered", {
+        id: row.id,
+        platform: notifier.platform,
+        attempts,
+        retryable: result.retryable,
+        error: result.error
+      });
+      return "dead";
+    }
+    const nextAttemptAt = now() + retryBackoffMs * 2 ** (attempts - 1);
+    store.markFailed(row.id, attempts, result.error ?? "delivery failed", nextAttemptAt);
+    logger.warn("alert delivery failed, will retry", {
+      id: row.id,
+      attempts,
+      nextAttemptAt,
+      error: result.error
+    });
+    return "retry";
+  }
+}
+
+// src/service/http.ts
+var import_node_http = require("http");
+function json(res, status, body) {
+  const payload = JSON.stringify(
+    body,
+    (_key, value) => typeof value === "bigint" ? value.toString() : value
+  );
+  res.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+  res.end(payload);
+}
+async function readBody(req, limitBytes) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+    size += buffer.length;
+    if (size > limitBytes) return null;
+    chunks.push(buffer);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function renderMetrics(store, health, nowMs) {
+  const metrics = store.metrics();
+  const lines = [
+    "# HELP hood_alerts_subscriptions Subscriptions by state.",
+    "# TYPE hood_alerts_subscriptions gauge",
+    `hood_alerts_subscriptions{state="total"} ${metrics.subscriptions}`,
+    `hood_alerts_subscriptions{state="enabled"} ${metrics.enabledSubscriptions}`,
+    "# HELP hood_alerts_outbox Deliveries by outbox status.",
+    "# TYPE hood_alerts_outbox gauge"
+  ];
+  for (const [status, count] of Object.entries(metrics.outbox)) {
+    lines.push(`hood_alerts_outbox{status="${status}"} ${count}`);
+  }
+  lines.push(
+    "# HELP hood_alerts_deliveries_last_hour Alerts delivered in the last rolling hour.",
+    "# TYPE hood_alerts_deliveries_last_hour gauge",
+    `hood_alerts_deliveries_last_hour ${metrics.deliveriesLastHour}`,
+    "# HELP hood_alerts_pools Memecoin pools tracked for whale trades.",
+    "# TYPE hood_alerts_pools gauge",
+    `hood_alerts_pools ${metrics.pools}`,
+    "# HELP hood_alerts_cursor_block Next unprocessed block per source.",
+    "# TYPE hood_alerts_cursor_block gauge"
+  );
+  for (const cursor of metrics.cursors) {
+    lines.push(`hood_alerts_cursor_block{source="${cursor.sourceId}"} ${cursor.nextBlock}`);
+  }
+  lines.push(
+    "# HELP hood_alerts_head_block Chain head block last observed.",
+    "# TYPE hood_alerts_head_block gauge",
+    `hood_alerts_head_block ${health.headBlock ?? 0}`,
+    "# HELP hood_alerts_lag_blocks How far each source trails the chain head.",
+    "# TYPE hood_alerts_lag_blocks gauge"
+  );
+  if (health.headBlock !== null) {
+    for (const cursor of metrics.cursors) {
+      const lag = health.headBlock > cursor.nextBlock ? health.headBlock - cursor.nextBlock : 0n;
+      lines.push(`hood_alerts_lag_blocks{source="${cursor.sourceId}"} ${lag}`);
+    }
+  }
+  lines.push(
+    "# HELP hood_alerts_last_poll_age_seconds Seconds since the last successful poll.",
+    "# TYPE hood_alerts_last_poll_age_seconds gauge",
+    `hood_alerts_last_poll_age_seconds ${health.lastPollAtMs === null ? -1 : Math.round((nowMs - health.lastPollAtMs) / 1e3)}`,
+    "# HELP hood_alerts_uptime_seconds Process uptime.",
+    "# TYPE hood_alerts_uptime_seconds counter",
+    `hood_alerts_uptime_seconds ${Math.round((nowMs - health.startedAtMs) / 1e3)}`,
+    ""
+  );
+  return lines.join("\n");
+}
+function createHttpServer(options) {
+  const now = options.now ?? Date.now;
+  const stalenessMs = options.readinessStalenessMs ?? 12e4;
+  return (0, import_node_http.createServer)((req, res) => {
+    void (async () => {
+      const url = new URL(req.url ?? "/", "http://localhost");
+      const path = url.pathname;
+      try {
+        if (req.method === "GET" && (path === "/health" || path === "/healthz")) {
+          const health = options.health();
+          json(res, 200, {
+            ok: true,
+            version: health.version,
+            uptimeSeconds: Math.round((now() - health.startedAtMs) / 1e3),
+            headBlock: health.headBlock,
+            lastPollAtMs: health.lastPollAtMs,
+            lastError: health.lastError,
+            platforms: health.platforms
+          });
+          return;
+        }
+        if (req.method === "GET" && path === "/ready") {
+          const health = options.health();
+          const fresh = health.lastPollAtMs !== null && now() - health.lastPollAtMs <= stalenessMs;
+          json(res, fresh ? 200 : 503, {
+            ready: fresh,
+            lastPollAtMs: health.lastPollAtMs,
+            lastError: health.lastError
+          });
+          return;
+        }
+        if (req.method === "GET" && path === "/metrics") {
+          const body = renderMetrics(options.store, options.health(), now());
+          res.writeHead(200, { "content-type": "text/plain; version=0.0.4; charset=utf-8" });
+          res.end(body);
+          return;
+        }
+        if (options.discord && req.method === "POST" && path === options.discord.path) {
+          const rawBody = await readBody(req, 256 * 1024);
+          if (rawBody === null) {
+            json(res, 413, { error: "request body too large" });
+            return;
+          }
+          const answer = await options.discord.handle({
+            signature: req.headers["x-signature-ed25519"] ?? null,
+            timestamp: req.headers["x-signature-timestamp"] ?? null,
+            rawBody
+          });
+          json(res, answer.status, answer.body);
+          return;
+        }
+        json(res, 404, { error: `no route for ${req.method ?? "GET"} ${path}` });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        options.logger.error("http handler failed", { path, error: message });
+        if (!res.headersSent) json(res, 500, { error: "internal error" });
+        else res.end();
+      }
+    })();
+  });
+}
+
+// src/service/logger.ts
+var LEVELS = ["debug", "info", "warn", "error"];
+function safeStringify(value) {
+  return JSON.stringify(value, (_key, raw) => {
+    if (typeof raw === "bigint") return raw.toString();
+    if (raw instanceof Error) return { name: raw.name, message: raw.message, stack: raw.stack };
+    return raw;
+  });
+}
+function createLogger(options = {}) {
+  const minimum = LEVELS.indexOf(options.level ?? "info");
+  const write = options.write ?? ((line) => console.log(line));
+  const now = options.now ?? Date.now;
+  const base = options.base ?? {};
+  const emit = (level, message, fields) => {
+    if (LEVELS.indexOf(level) < minimum) return;
+    write(
+      safeStringify({
+        time: new Date(now()).toISOString(),
+        level,
+        message,
+        ...base,
+        ...fields ?? {}
+      })
+    );
+  };
+  return {
+    debug: (message, fields) => emit("debug", message, fields),
+    info: (message, fields) => emit("info", message, fields),
+    warn: (message, fields) => emit("warn", message, fields),
+    error: (message, fields) => emit("error", message, fields),
+    child(fields) {
+      return createLogger({ ...options, base: { ...base, ...fields } });
+    }
+  };
+}
+function createSilentLogger() {
+  const silent = {
+    debug: () => void 0,
+    info: () => void 0,
+    warn: () => void 0,
+    error: () => void 0,
+    child: () => silent
+  };
+  return silent;
+}
+
+// src/service/runner.ts
+var import_hoodchain7 = require("hoodchain");
+
+// src/events/sources.ts
+var import_viem5 = require("viem");
+var import_hoodchain3 = require("hoodchain");
+var import_hoodkit = require("hoodkit");
+
+// src/events/explorer.ts
+var MAINNET_EXPLORER = "https://robinhoodchain.blockscout.com";
+var TESTNET_EXPLORER = "https://explorer.testnet.chain.robinhood.com";
+function explorerBase(network) {
+  return network === "testnet" ? TESTNET_EXPLORER : MAINNET_EXPLORER;
+}
+function txUrl(base, hash) {
+  return `${base}/tx/${hash}`;
+}
+function addressUrl(base, address) {
+  return `${base}/address/${address}`;
+}
+function tokenUrl(base, token) {
+  return `${base}/token/${token}`;
+}
+
+// src/events/blocktime.ts
+function createBlockTimeReader(client, maxEntries = 2e3) {
+  const cache = /* @__PURE__ */ new Map();
+  function remember(block, ts) {
+    if (cache.size >= maxEntries) {
+      const oldest = cache.keys().next();
+      if (!oldest.done) cache.delete(oldest.value);
+    }
+    cache.set(block.toString(), ts);
+  }
+  async function get(blockNumber) {
+    const hit = cache.get(blockNumber.toString());
+    if (hit !== void 0) return hit;
+    try {
+      const block = await client.public.getBlock({ blockNumber, includeTransactions: false });
+      const ms = Number(block.timestamp) * 1e3;
+      remember(blockNumber, ms);
+      return ms;
+    } catch {
+      return null;
+    }
+  }
+  return {
+    get,
+    async getMany(blocks, maxLookups) {
+      const unique = [...new Set(blocks.map((b) => b.toString()))].map((b) => BigInt(b));
+      const out = /* @__PURE__ */ new Map();
+      let budget = maxLookups;
+      for (const block of unique) {
+        const cached = cache.get(block.toString());
+        if (cached !== void 0) {
+          out.set(block, cached);
+          continue;
+        }
+        if (budget <= 0) {
+          out.set(block, null);
+          continue;
+        }
+        budget -= 1;
+        out.set(block, await get(block));
+      }
+      return out;
+    }
+  };
+}
+
+// src/events/sources.ts
+var ODYSSEY_FACTORIES2 = [
+  import_hoodchain3.ODYSSEY_ADDRESSES.bondingCurveFactory,
+  import_hoodchain3.ODYSSEY_ADDRESSES.reflectionFactory,
+  import_hoodchain3.ODYSSEY_ADDRESSES.instantFactory
+];
+function eventId(kind, transactionHash, logIndex) {
+  return `${kind}:${transactionHash.toLowerCase()}:${logIndex}`;
+}
+function links(base, token, actor, hash, pool) {
+  return {
+    tx: txUrl(base, hash),
+    token: tokenUrl(base, token),
+    actor: addressUrl(base, actor),
+    ...pool ? { pool: addressUrl(base, pool) } : {}
+  };
+}
+async function valueQuote(ctx, quoteToken, raw) {
+  const { weth, usdg } = quoteTokens(ctx.client);
+  const token = quoteToken.toLowerCase();
+  if (token === usdg.toLowerCase()) return ctx.oracle.usdgToUsd(raw);
+  if (token === weth.toLowerCase()) return ctx.oracle.weiToUsd(raw);
+  return null;
+}
+function assertMainnet(client) {
+  if (client.network !== "mainnet") {
+    throw new Error(
+      'hood-alerts: the NOXA and Odyssey launchpads are deployed on Robinhood Chain mainnet (chain 4663) only. Create the client with { chain: "mainnet" } (the default) to watch them.'
+    );
+  }
+}
+function createEventSources(ctx) {
+  assertMainnet(ctx.client);
+  return [
+    createNoxaLaunchSource(ctx),
+    createOdysseyLaunchSource(ctx),
+    createOdysseyCurveTradeSource(ctx),
+    createOdysseyGraduationSource(ctx),
+    createWhaleTradeSource(ctx)
+  ];
+}
+function blockTimes(ctx) {
+  ctx.blockTimes ??= createBlockTimeReader(ctx.client);
+  return ctx.blockTimes;
+}
+async function stampTimes(ctx, events) {
+  if (events.length === 0) return events;
+  const reader = blockTimes(ctx);
+  const times = await reader.getMany(
+    events.map((e) => e.blockNumber),
+    ctx.maxBlockTimeLookupsPerPoll ?? 25
+  );
+  for (const event of events) event.timestampMs = times.get(event.blockNumber) ?? null;
+  return events;
+}
+function createNoxaLaunchSource(ctx) {
+  const base = explorerBase(ctx.client.network);
+  return {
+    id: "noxa:launch",
+    label: "NOXA launches",
+    startBlock: import_hoodchain3.NOXA_ADDRESSES.deployBlock,
+    async poll(from, to) {
+      const logs = await fetchLogRange(
+        (lo, hi) => ctx.client.public.getLogs({
+          address: import_hoodchain3.NOXA_ADDRESSES.launchFactory,
+          event: import_hoodchain3.noxaTokenLaunchedEvent,
+          fromBlock: lo,
+          toBlock: hi
+        }),
+        from,
+        to,
+        ctx.logOptions ?? {}
+      );
+      const events = [];
+      for (const log of logs) {
+        const token = log.args.token;
+        const deployer = log.args.deployer;
+        if (!token || !deployer) continue;
+        const pool = log.args.pool ?? null;
+        const pairToken = log.args.pairToken ?? null;
+        const initialBuyAmount = log.args.initialBuyAmount ?? 0n;
+        if (pool && pairToken) {
+          await ctx.registry.record({
+            pool: (0, import_viem5.getAddress)(pool),
+            token: (0, import_viem5.getAddress)(token),
+            quoteToken: (0, import_viem5.getAddress)(pairToken),
+            launchpad: "noxa",
+            createdBlock: log.blockNumber
+          });
+        }
+        const meta = await ctx.tokens.get(token);
+        const usdValue = pairToken && initialBuyAmount > 0n ? await valueQuote(ctx, pairToken, initialBuyAmount) : null;
+        events.push({
+          id: eventId("launch", log.transactionHash, log.logIndex),
+          kind: "launch",
+          launchpad: "noxa",
+          token: (0, import_viem5.getAddress)(token),
+          symbol: meta.symbol,
+          name: meta.name,
+          actor: (0, import_viem5.getAddress)(deployer),
+          blockNumber: log.blockNumber,
+          logIndex: log.logIndex,
+          transactionHash: log.transactionHash,
+          timestampMs: null,
+          usdValue,
+          explorer: links(base, token, deployer, log.transactionHash, pool ?? void 0),
+          pool: pool ? (0, import_viem5.getAddress)(pool) : null,
+          pairToken: pairToken ? (0, import_viem5.getAddress)(pairToken) : null,
+          initialBuyAmount,
+          positionId: log.args.positionId ?? null,
+          // NOXA has no bonding curve at all: a launch is already a listing.
+          instantListing: true
+        });
+      }
+      return stampTimes(ctx, events);
+    }
+  };
+}
+function createOdysseyLaunchSource(ctx) {
+  const base = explorerBase(ctx.client.network);
+  return {
+    id: "odyssey:launch",
+    label: "Odyssey launches",
+    startBlock: import_hoodchain3.NOXA_ADDRESSES.deployBlock,
+    async poll(from, to) {
+      const logs = await fetchLogRange(
+        (lo, hi) => ctx.client.public.getLogs({
+          address: ODYSSEY_FACTORIES2,
+          event: import_hoodchain3.odysseyTokenCreatedEvent,
+          fromBlock: lo,
+          toBlock: hi
+        }),
+        from,
+        to,
+        ctx.logOptions ?? {}
+      );
+      const events = [];
+      for (const log of logs) {
+        const token = log.args.token;
+        const creator = log.args.creator;
+        if (!token || !creator) continue;
+        const meta = await ctx.tokens.get(token);
+        events.push({
+          id: eventId("launch", log.transactionHash, log.logIndex),
+          kind: "launch",
+          launchpad: "odyssey",
+          token: (0, import_viem5.getAddress)(token),
+          symbol: meta.symbol,
+          name: meta.name,
+          actor: (0, import_viem5.getAddress)(creator),
+          blockNumber: log.blockNumber,
+          logIndex: log.logIndex,
+          transactionHash: log.transactionHash,
+          timestampMs: null,
+          // The curve holds liquidity until graduation, so a new Odyssey token
+          // has no pool and no priceable notional at creation time.
+          usdValue: null,
+          explorer: links(base, token, creator, log.transactionHash),
+          pool: null,
+          pairToken: null,
+          initialBuyAmount: 0n,
+          positionId: null,
+          instantListing: log.address.toLowerCase() === import_hoodchain3.ODYSSEY_ADDRESSES.instantFactory.toLowerCase()
+        });
+      }
+      return stampTimes(ctx, events);
+    }
+  };
+}
+function createOdysseyCurveTradeSource(ctx) {
+  const base = explorerBase(ctx.client.network);
+  return {
+    id: "odyssey:curve_trade",
+    label: "Odyssey curve trades",
+    startBlock: import_hoodchain3.NOXA_ADDRESSES.deployBlock,
+    async poll(from, to) {
+      const logs = await fetchLogRange(
+        (lo, hi) => ctx.client.public.getLogs({
+          address: ODYSSEY_FACTORIES2,
+          event: import_hoodchain3.odysseyTradedEvent,
+          fromBlock: lo,
+          toBlock: hi
+        }),
+        from,
+        to,
+        ctx.logOptions ?? {}
+      );
+      const events = [];
+      for (const log of logs) {
+        const token = log.args.token;
+        const trader = log.args.trader;
+        if (!token || !trader) continue;
+        const tokenAmount = log.args.tokenAmount ?? 0n;
+        const quoteAmountWei = log.args.quoteAmount ?? 0n;
+        const meta = await ctx.tokens.get(token);
+        const usdValue = await ctx.oracle.weiToUsd(quoteAmountWei);
+        const priceEth = tokenAmount > 0n ? Number(quoteAmountWei) / Number(tokenAmount) : null;
+        events.push({
+          id: eventId("curve_trade", log.transactionHash, log.logIndex),
+          kind: "curve_trade",
+          launchpad: "odyssey",
+          token: (0, import_viem5.getAddress)(token),
+          symbol: meta.symbol,
+          name: meta.name,
+          actor: (0, import_viem5.getAddress)(trader),
+          blockNumber: log.blockNumber,
+          logIndex: log.logIndex,
+          transactionHash: log.transactionHash,
+          timestampMs: null,
+          usdValue,
+          explorer: links(base, token, trader, log.transactionHash),
+          side: log.args.isBuy ? "buy" : "sell",
+          tokenAmount,
+          quoteAmountWei,
+          feeWei: log.args.fee ?? 0n,
+          virtualQuoteWei: log.args.virtualQuote ?? 0n,
+          virtualTokenAmount: log.args.virtualToken ?? 0n,
+          priceEth
+        });
+      }
+      return stampTimes(ctx, events);
+    }
+  };
+}
+function createOdysseyGraduationSource(ctx) {
+  const base = explorerBase(ctx.client.network);
+  return {
+    id: "odyssey:graduation",
+    label: "Odyssey graduations",
+    startBlock: import_hoodchain3.NOXA_ADDRESSES.deployBlock,
+    async poll(from, to) {
+      const logs = await fetchLogRange(
+        (lo, hi) => ctx.client.public.getLogs({
+          address: ODYSSEY_FACTORIES2,
+          event: import_hoodchain3.odysseyPoolMigratedEvent,
+          fromBlock: lo,
+          toBlock: hi
+        }),
+        from,
+        to,
+        ctx.logOptions ?? {}
+      );
+      const events = [];
+      for (const log of logs) {
+        const token = log.args.token;
+        const pool = log.args.pool;
+        if (!token || !pool) continue;
+        const quoteUsed = log.args.usdcUsed ?? 0n;
+        let quoteToken = null;
+        try {
+          const info = await (0, import_hoodkit.loadPoolInfo)(ctx.client, pool);
+          quoteToken = info.token0.toLowerCase() === token.toLowerCase() ? info.token1 : info.token0;
+          await ctx.registry.record({
+            pool: (0, import_viem5.getAddress)(pool),
+            token: (0, import_viem5.getAddress)(token),
+            quoteToken,
+            launchpad: "odyssey",
+            createdBlock: log.blockNumber
+          });
+        } catch {
+          quoteToken = null;
+        }
+        const meta = await ctx.tokens.get(token);
+        const usdValue = quoteToken ? await valueQuote(ctx, quoteToken, quoteUsed) : null;
+        events.push({
+          id: eventId("graduation", log.transactionHash, log.logIndex),
+          kind: "graduation",
+          launchpad: "odyssey",
+          token: (0, import_viem5.getAddress)(token),
+          symbol: meta.symbol,
+          name: meta.name,
+          // A migration is executed by the factory on behalf of the curve, so
+          // the closest thing to an actor is the factory that emitted it.
+          actor: (0, import_viem5.getAddress)(log.address),
+          blockNumber: log.blockNumber,
+          logIndex: log.logIndex,
+          transactionHash: log.transactionHash,
+          timestampMs: null,
+          usdValue,
+          explorer: links(base, token, log.address, log.transactionHash, pool),
+          pool: (0, import_viem5.getAddress)(pool),
+          positionId: log.args.tokenId ?? 0n,
+          liquidity: log.args.liquidity ?? 0n,
+          tokenUsed: log.args.tokenUsed ?? 0n,
+          quoteUsed
+        });
+      }
+      return stampTimes(ctx, events);
+    }
+  };
+}
+function createWhaleTradeSource(ctx) {
+  const base = explorerBase(ctx.client.network);
+  const poolInfoCache = /* @__PURE__ */ new Map();
+  const minUsd = ctx.whaleMinUsd ?? 1e3;
+  async function poolInfo(pool) {
+    const key = pool.toLowerCase();
+    const hit = poolInfoCache.get(key);
+    if (hit) return hit;
+    try {
+      const info = await (0, import_hoodkit.loadPoolInfo)(ctx.client, pool);
+      poolInfoCache.set(key, info);
+      return info;
+    } catch {
+      return null;
+    }
+  }
+  return {
+    id: "uniswap:whale_trade",
+    label: "Whale trades",
+    startBlock: import_hoodchain3.NOXA_ADDRESSES.deployBlock,
+    async poll(from, to) {
+      const pinned = ctx.pinnedTokens ? await ctx.pinnedTokens() : [];
+      const entries = await ctx.registry.active(ctx.whalePoolLimit ?? 400, pinned);
+      if (entries.length === 0) return [];
+      const byPool = new Map(entries.map((entry) => [entry.pool.toLowerCase(), entry]));
+      const batches = batchAddresses(
+        entries.map((entry) => entry.pool),
+        ctx.whalePoolBatchSize ?? 200
+      );
+      const logs = (await Promise.all(
+        batches.map(
+          (batch) => fetchLogRange(
+            (lo, hi) => ctx.client.public.getLogs({
+              address: batch,
+              event: import_hoodkit.uniswapV3SwapEvent,
+              fromBlock: lo,
+              toBlock: hi
+            }),
+            from,
+            to,
+            ctx.logOptions ?? {}
+          )
+        )
+      )).flat();
+      const events = [];
+      for (const log of logs) {
+        const entry = byPool.get(log.address.toLowerCase());
+        if (!entry) continue;
+        const info = await poolInfo(entry.pool);
+        if (!info) continue;
+        const amount0 = log.args.amount0 ?? 0n;
+        const amount1 = log.args.amount1 ?? 0n;
+        const quoteIsToken0 = info.token0.toLowerCase() === entry.quoteToken.toLowerCase();
+        const quoteRaw = quoteIsToken0 ? amount0 : amount1;
+        const tokenRaw = quoteIsToken0 ? amount1 : amount0;
+        if (quoteRaw === 0n || tokenRaw === 0n) continue;
+        const usdValue = await valueQuote(ctx, entry.quoteToken, quoteRaw);
+        if (usdValue === null || usdValue < minUsd) continue;
+        const quoteDecimals = quoteIsToken0 ? info.decimals0 : info.decimals1;
+        const tokenDecimals = quoteIsToken0 ? info.decimals1 : info.decimals0;
+        const quoteAmount = Math.abs(Number(quoteRaw)) / 10 ** quoteDecimals;
+        const tokenAmount = Math.abs(Number(tokenRaw)) / 10 ** tokenDecimals;
+        const [tokenMeta, quoteMeta] = await Promise.all([
+          ctx.tokens.get(entry.token),
+          ctx.tokens.get(entry.quoteToken)
+        ]);
+        const trader = log.args.recipient ?? log.args.sender;
+        events.push({
+          id: eventId("whale_trade", log.transactionHash, log.logIndex),
+          kind: "whale_trade",
+          launchpad: entry.launchpad,
+          token: entry.token,
+          symbol: tokenMeta.symbol,
+          name: tokenMeta.name,
+          actor: (0, import_viem5.getAddress)(trader),
+          blockNumber: log.blockNumber,
+          logIndex: log.logIndex,
+          transactionHash: log.transactionHash,
+          timestampMs: null,
+          usdValue,
+          explorer: links(base, entry.token, trader, log.transactionHash, entry.pool),
+          pool: entry.pool,
+          quoteToken: entry.quoteToken,
+          quoteSymbol: quoteMeta.symbol ?? "quote",
+          // The memecoin left the pool (negative delta) means the trader bought it.
+          side: tokenRaw < 0n ? "buy" : "sell",
+          tokenAmount,
+          quoteAmount,
+          price: tokenAmount > 0 ? quoteAmount / tokenAmount : 0,
+          feeTier: info.fee
+        });
+      }
+      return stampTimes(ctx, events);
+    }
+  };
+}
+
+// src/events/liquidity.ts
+var import_viem6 = require("viem");
+var import_hoodchain4 = require("hoodchain");
+function createLiquidityReader(client, oracle, registry, options = {}) {
+  const ttlMs = options.ttlMs ?? 6e4;
+  const now = options.now ?? Date.now;
+  const cache = /* @__PURE__ */ new Map();
+  const { weth, usdg } = quoteTokens(client);
+  async function readPool(pool, quoteToken) {
+    const quote = quoteToken.toLowerCase();
+    if (quote !== weth.toLowerCase() && quote !== usdg.toLowerCase()) return null;
+    const balance = await client.public.readContract({
+      address: quoteToken,
+      abi: import_hoodchain4.erc20Abi,
+      functionName: "balanceOf",
+      args: [pool]
+    });
+    if (quote === usdg.toLowerCase()) {
+      return Number((0, import_viem6.formatUnits)(balance, import_hoodchain4.USDG_DECIMALS)) * 2;
+    }
+    const usd = await oracle.weiToUsd(balance);
+    return usd === null ? null : usd * 2;
+  }
+  async function poolLiquidityUsd(pool, quoteToken) {
+    const key = pool.toLowerCase();
+    const hit = cache.get(key);
+    if (hit && now() - hit.at < ttlMs) return hit.value;
+    let value;
+    try {
+      value = await readPool(pool, quoteToken);
+    } catch {
+      value = null;
+    }
+    cache.set(key, { value, at: now() });
+    return value;
+  }
+  return {
+    poolLiquidityUsd,
+    async tokenLiquidityUsd(token) {
+      const pools = await registry.poolsFor(token);
+      if (pools.length === 0) return null;
+      const values = await Promise.all(
+        pools.map((entry) => poolLiquidityUsd(entry.pool, entry.quoteToken))
+      );
+      const known = values.filter((v) => v !== null);
+      return known.length === 0 ? null : Math.max(...known);
+    }
+  };
+}
+
+// src/events/tokens.ts
+var import_viem7 = require("viem");
+var import_hoodchain5 = require("hoodchain");
+function createTokenMetaReader(client, maxEntries = 5e3) {
+  const cache = /* @__PURE__ */ new Map();
+  const inflight = /* @__PURE__ */ new Map();
+  function remember(meta) {
+    if (cache.size >= maxEntries) {
+      const oldest = cache.keys().next();
+      if (!oldest.done) cache.delete(oldest.value);
+    }
+    cache.set(meta.address.toLowerCase(), meta);
+  }
+  async function load(token) {
+    const results = await client.public.multicall({
+      contracts: [
+        { address: token, abi: import_hoodchain5.erc20Abi, functionName: "symbol" },
+        { address: token, abi: import_hoodchain5.erc20Abi, functionName: "name" },
+        { address: token, abi: import_hoodchain5.erc20Abi, functionName: "decimals" }
+      ],
+      allowFailure: true
+    });
+    const [symbolResult, nameResult, decimalsResult] = results;
+    const meta = {
+      address: (0, import_viem7.getAddress)(token),
+      symbol: symbolResult && symbolResult.status === "success" ? String(symbolResult.result) : null,
+      name: nameResult && nameResult.status === "success" ? String(nameResult.result) : null,
+      decimals: decimalsResult && decimalsResult.status === "success" ? Number(decimalsResult.result) : 18
+    };
+    remember(meta);
+    return meta;
+  }
+  return {
+    async get(token) {
+      const key = token.toLowerCase();
+      const hit = cache.get(key);
+      if (hit) return hit;
+      const pending = inflight.get(key);
+      if (pending) return pending;
+      const promise = load(token).catch(() => {
+        const fallback = { address: (0, import_viem7.getAddress)(token), symbol: null, name: null, decimals: 18 };
+        remember(fallback);
+        return fallback;
+      }).finally(() => {
+        inflight.delete(key);
+      });
+      inflight.set(key, promise);
+      return promise;
+    },
+    prime(meta) {
+      remember(meta);
+    }
+  };
+}
+
+// src/bot/commands.ts
+var import_node_crypto = require("crypto");
+var import_viem10 = require("viem");
+
+// src/tiers/entitlements.ts
+var import_viem8 = require("viem");
+var import_hoodchain6 = require("hoodchain");
+var import_viem9 = require("viem");
+var free = (subscriberId, source) => ({
+  subscriberId,
+  tier: "free",
+  expiresAtMs: null,
+  source
+});
+function createStaticEntitlementProvider(options) {
+  const premium = new Set((options.premiumSubscribers ?? []).map((id) => id.trim()).filter(Boolean));
+  return {
+    async get(subscriberId) {
+      if (options.allPremium === true || premium.has(subscriberId)) {
+        return { subscriberId, tier: "premium", expiresAtMs: null, source: "static" };
+      }
+      return free(subscriberId, "static");
+    }
+  };
+}
+var transferEvent = {
+  type: "event",
+  name: "Transfer",
+  inputs: [
+    { name: "from", type: "address", indexed: true },
+    { name: "to", type: "address", indexed: true },
+    { name: "value", type: "uint256", indexed: false }
+  ]
+};
+function accrueExpiry(payments, pricePerPeriodUsdg, periodDays) {
+  if (pricePerPeriodUsdg <= 0) return null;
+  const periodMs = periodDays * 864e5;
+  const ordered = [...payments].sort((a, b) => a.atMs - b.atMs);
+  let expiry = null;
+  for (const payment of ordered) {
+    const periods = Math.floor(payment.amountUsdg / pricePerPeriodUsdg);
+    if (periods < 1) continue;
+    const start = expiry !== null && expiry > payment.atMs ? expiry : payment.atMs;
+    expiry = start + periods * periodMs;
+  }
+  return expiry;
+}
+function createUsdgEntitlementProvider(options) {
+  const ttlMs = options.ttlMs ?? 3e5;
+  const now = options.now ?? Date.now;
+  const periodDays = options.periodDays ?? 30;
+  const usdg = options.client.network === "testnet" ? "0x7E955252E15c84f5768B83c41a71F9eba181802F" : "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168";
+  const cache = /* @__PURE__ */ new Map();
+  async function resolve(subscriberId) {
+    const wallet = await options.links.walletOf(subscriberId);
+    if (!wallet) return free(subscriberId, "usdg:no-linked-wallet");
+    const head = await options.client.public.getBlockNumber();
+    const logs = await fetchLogRange(
+      (from, to) => options.client.public.getLogs({
+        address: usdg,
+        event: transferEvent,
+        args: { from: wallet, to: (0, import_viem8.getAddress)(options.receiver) },
+        fromBlock: from,
+        toBlock: to
+      }),
+      options.fromBlock ?? 0n,
+      head,
+      options.logOptions ?? {}
+    );
+    if (logs.length === 0) return free(subscriberId, "usdg:no-payments");
+    const payments = [];
+    for (const log of logs) {
+      const value = log.args.value;
+      if (value === void 0 || value === 0n) continue;
+      const block = await options.client.public.getBlock({
+        blockNumber: log.blockNumber,
+        includeTransactions: false
+      });
+      payments.push({
+        atMs: Number(block.timestamp) * 1e3,
+        amountUsdg: Number((0, import_viem9.formatUnits)(value, import_hoodchain6.USDG_DECIMALS))
+      });
+    }
+    const expiresAtMs = accrueExpiry(payments, options.pricePerPeriodUsdg, periodDays);
+    if (expiresAtMs === null || expiresAtMs <= now()) {
+      return { subscriberId, tier: "free", expiresAtMs, source: "usdg:lapsed" };
+    }
+    return { subscriberId, tier: "premium", expiresAtMs, source: "usdg" };
+  }
+  return {
+    async get(subscriberId) {
+      const hit = cache.get(subscriberId);
+      if (hit && now() - hit.at < ttlMs) return hit.entitlement;
+      try {
+        const entitlement = await resolve(subscriberId);
+        cache.set(subscriberId, { entitlement, at: now() });
+        return entitlement;
+      } catch (error) {
+        if (hit) return hit.entitlement;
+        const message = error instanceof Error ? error.message : String(error);
+        return free(subscriberId, `usdg:unavailable (${message})`);
+      }
+    }
+  };
+}
+function chainEntitlementProviders(...providers) {
+  return {
+    async get(subscriberId) {
+      let last = free(subscriberId, "chain:empty");
+      for (const provider of providers) {
+        const entitlement = await provider.get(subscriberId);
+        if (entitlement.tier === "premium") return entitlement;
+        last = entitlement;
+      }
+      return last;
+    }
+  };
+}
+function linkMessage(subscriberId, nonce) {
+  return `hood-alerts wallet link
+subscriber: ${subscriberId}
+nonce: ${nonce}`;
+}
+async function verifyWalletLink(subscriberId, nonce, address, signature) {
+  if (!/^0x[0-9a-fA-F]{130}$/.test(signature)) return null;
+  if (!/^0x[0-9a-fA-F]{40}$/.test(address)) return null;
+  try {
+    const valid = await (0, import_viem8.verifyMessage)({
+      address: (0, import_viem8.getAddress)(address),
+      message: linkMessage(subscriberId, nonce),
+      signature
+    });
+    return valid ? (0, import_viem8.getAddress)(address) : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/bot/commands.ts
+var reply = (text) => ({ html: escapeHtml(text), text });
+var html = (htmlText, plain) => ({ html: htmlText, text: plain });
+var COMMANDS = [
+  { name: "start", description: "Set up alerts in this chat", usage: "/start" },
+  { name: "help", description: "Show every command", usage: "/help" },
+  {
+    name: "subscribe",
+    description: "Send alerts here, with a starter rule set",
+    usage: "/subscribe [target]",
+    options: [
+      {
+        name: "target",
+        description: "Discord webhook URL or channel id. Defaults to this channel.",
+        required: false
+      }
+    ]
+  },
+  {
+    name: "unsubscribe",
+    description: "Stop alerts for a subscription",
+    usage: "/unsubscribe [subscription id]",
+    options: [{ name: "id", description: "Subscription id from /status", required: false }]
+  },
+  { name: "rules", description: "List your rules", usage: "/rules" },
+  {
+    name: "rule",
+    description: "Add, remove, enable or disable a rule",
+    usage: "/rule add <json> | /rule rm <id> | /rule on <id> | /rule off <id>",
+    options: [{ name: "input", description: "add <json> | rm <id> | on <id> | off <id>", required: true }]
+  },
+  {
+    name: "threshold",
+    description: "Set a rule minimum USD value",
+    usage: "/threshold <rule id> <usd>",
+    options: [
+      { name: "rule", description: "Rule id", required: true },
+      { name: "usd", description: "Minimum USD value", required: true }
+    ]
+  },
+  {
+    name: "watch",
+    description: "Add a token to a rule watchlist",
+    usage: "/watch <token address> [rule id]",
+    options: [
+      { name: "token", description: "Token contract address", required: true },
+      { name: "rule", description: "Rule id (defaults to the first rule)", required: false }
+    ]
+  },
+  {
+    name: "unwatch",
+    description: "Remove a token from a rule watchlist",
+    usage: "/unwatch <token address> [rule id]",
+    options: [
+      { name: "token", description: "Token contract address", required: true },
+      { name: "rule", description: "Rule id (defaults to the first rule)", required: false }
+    ]
+  },
+  { name: "tier", description: "Show your tier and its limits", usage: "/tier" },
+  { name: "status", description: "Show your subscriptions and delivery state", usage: "/status" },
+  {
+    name: "link",
+    description: "Link a paying wallet (signature verified)",
+    usage: "/link [address] [signature]",
+    options: [
+      { name: "address", description: "Wallet address that pays", required: false },
+      { name: "signature", description: "Signature of the link message", required: false }
+    ]
+  },
+  { name: "upgrade", description: "How to go premium", usage: "/upgrade" }
+];
+function ruleSummary(rule) {
+  const parts = [
+    `${rule.enabled ? "on " : "off"} ${rule.id}`,
+    rule.name ? `"${rule.name}"` : null,
+    `kinds=${rule.kinds.join("/")}`,
+    `pads=${rule.launchpads.join("/")}`,
+    rule.minUsd !== void 0 ? `minUsd=${rule.minUsd}` : null,
+    rule.maxUsd !== void 0 ? `maxUsd=${rule.maxUsd}` : null,
+    rule.minLiquidityUsd !== void 0 ? `minLiq=${rule.minLiquidityUsd}` : null,
+    rule.maxLiquidityUsd !== void 0 ? `maxLiq=${rule.maxLiquidityUsd}` : null,
+    rule.side !== "any" ? `side=${rule.side}` : null,
+    rule.tokens.length > 0 ? `tokens=${rule.tokens.length}` : null,
+    rule.deployers.length > 0 ? `deployers=${rule.deployers.length}` : null,
+    rule.rateLimit ? `rate=${JSON.stringify(rule.rateLimit)}` : null,
+    `filters=${ruleComplexity(rule)}`
+  ].filter((part) => part !== null);
+  return parts.join(" ");
+}
+function createCommandRouter(deps) {
+  const now = deps.now ?? Date.now;
+  const newId = deps.newId ?? import_node_crypto.randomUUID;
+  function subscriptionsOf(context) {
+    return deps.store.listSubscriptionsFor(context.subscriberId);
+  }
+  function firstSubscription(context) {
+    return subscriptionsOf(context)[0] ?? null;
+  }
+  async function handleSubscribe(context) {
+    const target = context.args[0]?.trim() || context.defaultTarget;
+    if (!target) {
+      return reply(
+        "I could not work out where to send alerts. Pass a target: /subscribe <discord webhook URL or channel id>"
+      );
+    }
+    const existing = subscriptionsOf(context);
+    if (existing.some((sub) => sub.target === target)) {
+      return reply(`This target is already subscribed. Use /rules to edit it, or /unsubscribe to stop.`);
+    }
+    const decision = await deps.gate.checkAddSubscription(context.subscriberId, existing.length);
+    if (!decision.allowed) return reply(`Cannot subscribe: ${decision.reason}`);
+    const { policy } = await deps.gate.resolve(context.subscriberId);
+    const rules = defaultRules().filter(
+      (rule) => rule.kinds.every((kind) => policy.allowedKinds.includes(kind))
+    );
+    const subscription = parseSubscription({
+      id: newId(),
+      subscriberId: context.subscriberId,
+      platform: context.platform,
+      target,
+      enabled: true,
+      rules: rules.slice(0, policy.maxRulesPerSubscription),
+      createdAtMs: now()
+    });
+    deps.store.saveSubscription(subscription);
+    return html(
+      [
+        `<b>Subscribed.</b> Alerts will arrive here.`,
+        `Subscription id: <code>${escapeHtml(subscription.id)}</code>`,
+        `Tier: <b>${policy.tier}</b> (delivery delay ${policy.deliveryDelayMs / 1e3}s, ${policy.maxAlertsPerHour} alerts/hour)`,
+        "",
+        "Starter rules:",
+        ...subscription.rules.map((rule) => `\u2022 <code>${escapeHtml(ruleSummary(rule))}</code>`),
+        "",
+        "Edit them with /threshold, /watch and /rule. See /help."
+      ].join("\n"),
+      `Subscribed. id=${subscription.id} tier=${policy.tier}`
+    );
+  }
+  async function handleUnsubscribe(context) {
+    const subs = subscriptionsOf(context);
+    if (subs.length === 0) return reply("You have no subscriptions. Use /subscribe to start one.");
+    const id = context.args[0]?.trim();
+    if (!id) {
+      if (subs.length > 1) {
+        return html(
+          [
+            "You have several subscriptions. Name the one to remove:",
+            ...subs.map((sub) => `\u2022 <code>${escapeHtml(sub.id)}</code> \u2192 ${escapeHtml(sub.target)}`),
+            "",
+            "Usage: /unsubscribe &lt;subscription id&gt;"
+          ].join("\n"),
+          "Name the subscription to remove: " + subs.map((sub) => sub.id).join(", ")
+        );
+      }
+      const only = subs[0];
+      deps.store.deleteSubscription(only.id);
+      return reply("Unsubscribed. No more alerts will be delivered here.");
+    }
+    const match = subs.find((sub) => sub.id === id);
+    if (!match) return reply(`No subscription with id "${id}". Use /status to list yours.`);
+    deps.store.deleteSubscription(match.id);
+    return reply(`Unsubscribed ${match.id}.`);
+  }
+  function handleRules(context) {
+    const subs = subscriptionsOf(context);
+    if (subs.length === 0) return reply("You have no subscriptions yet. Use /subscribe to start one.");
+    const lines = [];
+    for (const sub of subs) {
+      lines.push(`<b>${escapeHtml(sub.target)}</b> (<code>${escapeHtml(sub.id)}</code>)`);
+      if (sub.rules.length === 0) lines.push("  no rules: nothing will be delivered");
+      for (const rule of sub.rules) lines.push(`  \u2022 <code>${escapeHtml(ruleSummary(rule))}</code>`);
+    }
+    return html(lines.join("\n"), lines.join("\n").replace(/<[^>]+>/g, ""));
+  }
+  async function handleRule(context) {
+    const action = context.args[0]?.toLowerCase();
+    const subscription = firstSubscription(context);
+    if (!subscription) return reply("Subscribe first with /subscribe, then add rules.");
+    if (action === "add") {
+      const json2 = context.rest.slice(context.rest.indexOf("add") + 3).trim();
+      if (!json2) {
+        return html(
+          [
+            'Usage: <code>/rule add {"id":"big-whales","kinds":["whale_trade"],"minUsd":25000}</code>',
+            "",
+            "Fields: id, name, enabled, kinds, launchpads, minUsd, maxUsd, minLiquidityUsd,",
+            "maxLiquidityUsd, tokens, deployers, excludeDeployers, side, reputation, rateLimit."
+          ].join("\n"),
+          'Usage: /rule add {"id":"big-whales","kinds":["whale_trade"],"minUsd":25000}'
+        );
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(json2);
+      } catch {
+        return reply('That is not valid JSON. Example: /rule add {"id":"whales","kinds":["whale_trade"],"minUsd":5000}');
+      }
+      const result = safeParseRule(parsed);
+      if (!result.success) return reply(`Rule rejected: ${formatValidationError(result.error)}`);
+      const rule = result.data;
+      if (subscription.rules.some((existing) => existing.id === rule.id)) {
+        return reply(`A rule with id "${rule.id}" already exists. Remove it first with /rule rm ${rule.id}.`);
+      }
+      const decision = await deps.gate.checkAddRule(context.subscriberId, rule, subscription.rules.length);
+      if (!decision.allowed) return reply(`Rule rejected: ${decision.reason}`);
+      subscription.rules.push(rule);
+      deps.store.saveSubscription(subscription);
+      return html(
+        `Rule added: <code>${escapeHtml(ruleSummary(rule))}</code>`,
+        `Rule added: ${ruleSummary(rule)}`
+      );
+    }
+    if (action === "rm" || action === "remove" || action === "delete") {
+      const id = context.args[1]?.trim();
+      if (!id) return reply("Usage: /rule rm <rule id>. List them with /rules.");
+      const index = subscription.rules.findIndex((rule) => rule.id === id);
+      if (index === -1) return reply(`No rule with id "${id}". List them with /rules.`);
+      subscription.rules.splice(index, 1);
+      deps.store.saveSubscription(subscription);
+      return reply(`Rule ${id} removed.`);
+    }
+    if (action === "on" || action === "off") {
+      const id = context.args[1]?.trim();
+      if (!id) return reply(`Usage: /rule ${action} <rule id>. List them with /rules.`);
+      const rule = subscription.rules.find((entry) => entry.id === id);
+      if (!rule) return reply(`No rule with id "${id}". List them with /rules.`);
+      rule.enabled = action === "on";
+      deps.store.saveSubscription(subscription);
+      return reply(`Rule ${id} is now ${rule.enabled ? "enabled" : "disabled"}.`);
+    }
+    return html(
+      [
+        "Usage:",
+        "\u2022 <code>/rule add {json}</code>",
+        "\u2022 <code>/rule rm &lt;id&gt;</code>",
+        "\u2022 <code>/rule on &lt;id&gt;</code>",
+        "\u2022 <code>/rule off &lt;id&gt;</code>"
+      ].join("\n"),
+      "Usage: /rule add {json} | /rule rm <id> | /rule on <id> | /rule off <id>"
+    );
+  }
+  async function handleThreshold(context) {
+    const subscription = firstSubscription(context);
+    if (!subscription) return reply("Subscribe first with /subscribe.");
+    const [ruleId, rawUsd] = context.args;
+    if (!ruleId || !rawUsd) {
+      return reply("Usage: /threshold <rule id> <usd>. Example: /threshold whales 5000");
+    }
+    const rule = subscription.rules.find((entry) => entry.id === ruleId);
+    if (!rule) return reply(`No rule with id "${ruleId}". List them with /rules.`);
+    const usd = Number(rawUsd);
+    if (!Number.isFinite(usd) || usd < 0) {
+      return reply(`"${rawUsd}" is not a valid amount. Use a positive number, for example /threshold ${ruleId} 5000`);
+    }
+    if (rule.maxUsd !== void 0 && usd > rule.maxUsd) {
+      return reply(`minUsd ${usd} would exceed this rule's maxUsd ${rule.maxUsd}. Lower it or raise maxUsd first.`);
+    }
+    rule.minUsd = usd;
+    const decision = await deps.gate.checkRule(context.subscriberId, rule);
+    if (!decision.allowed) return reply(`Change rejected: ${decision.reason}`);
+    deps.store.saveSubscription(subscription);
+    return reply(`Rule ${ruleId} now requires at least $${usd} of value.`);
+  }
+  async function handleWatch(context, add) {
+    const subscription = firstSubscription(context);
+    if (!subscription) return reply("Subscribe first with /subscribe.");
+    const rawToken = context.args[0]?.trim();
+    if (!rawToken) {
+      return reply(`Usage: /${add ? "watch" : "unwatch"} <token address> [rule id]`);
+    }
+    if (!/^0x[0-9a-fA-F]{40}$/.test(rawToken)) {
+      return reply(`"${rawToken}" is not a token address. Pass the 0x contract address from the alert.`);
+    }
+    const token = (0, import_viem10.getAddress)(rawToken).toLowerCase();
+    const ruleId = context.args[1]?.trim();
+    const rule = ruleId ? subscription.rules.find((entry) => entry.id === ruleId) : subscription.rules[0];
+    if (!rule) {
+      return reply(
+        ruleId ? `No rule with id "${ruleId}". List them with /rules.` : "This subscription has no rules yet. Add one with /rule add."
+      );
+    }
+    if (add) {
+      if (rule.tokens.includes(token)) return reply(`${rawToken} is already on rule ${rule.id}.`);
+      rule.tokens.push(token);
+      const decision = await deps.gate.checkRule(context.subscriberId, rule);
+      if (!decision.allowed) {
+        rule.tokens.pop();
+        return reply(`Cannot add: ${decision.reason}`);
+      }
+      deps.store.saveSubscription(subscription);
+      return reply(`Watching ${rawToken} on rule ${rule.id} (${rule.tokens.length} tokens).`);
+    }
+    const index = rule.tokens.indexOf(token);
+    if (index === -1) return reply(`${rawToken} is not on rule ${rule.id}.`);
+    rule.tokens.splice(index, 1);
+    deps.store.saveSubscription(subscription);
+    return reply(`Stopped watching ${rawToken} on rule ${rule.id}.`);
+  }
+  async function handleTier(context) {
+    const { entitlement, policy } = await deps.gate.resolve(context.subscriberId);
+    const expiry = entitlement.expiresAtMs === null ? "no expiry" : `expires ${new Date(entitlement.expiresAtMs).toISOString()}`;
+    const lines = [
+      `<b>Tier: ${escapeHtml(policy.tier)}</b> (${escapeHtml(expiry)}, source ${escapeHtml(entitlement.source)})`,
+      `Subscriptions: up to ${policy.maxSubscriptions}`,
+      `Rules per subscription: up to ${policy.maxRulesPerSubscription}`,
+      `Filters per rule: up to ${policy.maxRuleComplexity}`,
+      `Watchlist size: up to ${policy.maxWatchlistTokens}`,
+      `Alerts per hour: up to ${policy.maxAlertsPerHour}`,
+      `Delivery delay: ${policy.deliveryDelayMs / 1e3}s`,
+      `Liquidity and reputation filters: ${policy.allowOnChainLookupFilters ? "included" : "premium only"}`,
+      `Event kinds: ${policy.allowedKinds.join(", ")}`
+    ];
+    return html(lines.join("\n"), lines.join("\n").replace(/<[^>]+>/g, ""));
+  }
+  async function handleStatus(context) {
+    const subs = subscriptionsOf(context);
+    if (subs.length === 0) return reply("No subscriptions. Use /subscribe to start one.");
+    const delivered2 = deps.store.countDeliveriesForSubscriber(context.subscriberId, now() - 36e5);
+    const { policy } = await deps.gate.resolve(context.subscriberId);
+    const lines = [
+      `<b>${subs.length} subscription${subs.length === 1 ? "" : "s"}</b>, ${delivered2} alerts in the last hour (cap ${policy.maxAlertsPerHour})`,
+      ...subs.map(
+        (sub) => `\u2022 <code>${escapeHtml(sub.id)}</code> \u2192 ${escapeHtml(sub.target)} (${sub.rules.length} rules, ${sub.enabled ? "enabled" : "disabled"})`
+      )
+    ];
+    return html(lines.join("\n"), lines.join("\n").replace(/<[^>]+>/g, ""));
+  }
+  async function handleLink(context) {
+    const [address, signature] = context.args;
+    if (!address) {
+      const nonce2 = deps.store.issueLinkNonce(context.subscriberId, newId());
+      const message = linkMessage(context.subscriberId, nonce2);
+      return html(
+        [
+          "Sign this exact message with the wallet that pays, then send",
+          `<code>/link &lt;address&gt; &lt;signature&gt;</code>`,
+          "",
+          `<pre>${escapeHtml(message)}</pre>`
+        ].join("\n"),
+        `Sign this message and reply with /link <address> <signature>:
+${message}`
+      );
+    }
+    if (!signature) {
+      return reply("Usage: /link <address> <signature>. Send /link on its own to get the message to sign.");
+    }
+    const nonce = deps.store.getLinkNonce(context.subscriberId);
+    if (!nonce) {
+      return reply("No pending link request. Send /link on its own first to get a fresh message to sign.");
+    }
+    const verified = await verifyWalletLink(context.subscriberId, nonce, address, signature);
+    if (!verified) {
+      return reply("That signature does not match. Sign the exact message from /link with the wallet you named.");
+    }
+    deps.store.linkWallet(context.subscriberId, verified);
+    deps.store.clearLinkNonce(context.subscriberId);
+    return reply(`Wallet ${verified} linked. Payments from it now count towards your subscription.`);
+  }
+  function handleUpgrade() {
+    if (!deps.upgradeInstructions) {
+      return reply(
+        "This deployment does not sell premium access. The operator grants it through configuration; ask them."
+      );
+    }
+    return html(escapeHtml(deps.upgradeInstructions), deps.upgradeInstructions);
+  }
+  function handleHelp() {
+    const header = "hood-alerts: Robinhood Chain memecoin alerts.";
+    const kinds = "Event kinds: launch, curve_trade, graduation, whale_trade.";
+    const lifecycle = "NOXA lists instantly (no bonding curve), so it never produces curve_trade or graduation. The Odyssey produces all four.";
+    return html(
+      [
+        `<b>${escapeHtml(header)}</b>`,
+        "",
+        ...COMMANDS.map(
+          (command) => `<code>${escapeHtml(command.usage)}</code> - ${escapeHtml(command.description)}`
+        ),
+        "",
+        escapeHtml(kinds),
+        escapeHtml(lifecycle)
+      ].join("\n"),
+      [
+        header,
+        "",
+        ...COMMANDS.map((command) => `${command.usage} - ${command.description}`),
+        "",
+        kinds,
+        lifecycle
+      ].join("\n")
+    );
+  }
+  return {
+    commands: COMMANDS,
+    async handle(command, context) {
+      const name = command.replace(/^\//, "").split("@")[0]?.toLowerCase() ?? "";
+      try {
+        switch (name) {
+          case "start":
+          case "help":
+            return handleHelp();
+          case "subscribe":
+            return await handleSubscribe(context);
+          case "unsubscribe":
+            return await handleUnsubscribe(context);
+          case "rules":
+            return handleRules(context);
+          case "rule":
+            return await handleRule(context);
+          case "threshold":
+            return await handleThreshold(context);
+          case "watch":
+            return await handleWatch(context, true);
+          case "unwatch":
+            return await handleWatch(context, false);
+          case "tier":
+            return await handleTier(context);
+          case "status":
+            return await handleStatus(context);
+          case "link":
+            return await handleLink(context);
+          case "upgrade":
+            return handleUpgrade();
+          default:
+            return reply(`Unknown command "${name}". Send /help for the list.`);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return reply(`That command failed: ${message}. Try /help, or report this if it keeps happening.`);
+      }
+    }
+  };
+}
+
+// src/bot/discord-bot.ts
+var import_node_crypto2 = require("crypto");
+
+// src/notifiers/http.ts
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+function resolveFetch(injected) {
+  if (injected) return injected;
+  if (typeof globalThis.fetch !== "function") {
+    throw new Error("hood-alerts: global fetch is unavailable (Node 20+ required), and none was injected");
+  }
+  return globalThis.fetch;
+}
+async function postJson(fetchImpl, url, payload, headers = {}) {
+  const response = await fetchImpl(url, {
+    method: "POST",
+    headers: { "content-type": "application/json", ...headers },
+    body: JSON.stringify(payload)
+  });
+  const raw = await response.text();
+  let body = null;
+  if (raw) {
+    try {
+      body = JSON.parse(raw);
+    } catch {
+      body = null;
+    }
+  }
+  return { status: response.status, ok: response.ok, headers: response.headers, body, raw };
+}
+function numericHeader(headers, name) {
+  const value = headers.get(name);
+  if (value === null) return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function pick(body, ...path) {
+  let current = body;
+  for (const key of path) {
+    if (typeof current !== "object" || current === null) return void 0;
+    current = current[key];
+  }
+  return current;
+}
+
+// src/bot/discord-bot.ts
+var INTERACTION_TYPE = { PING: 1, APPLICATION_COMMAND: 2 };
+var CALLBACK_TYPE = { PONG: 1, CHANNEL_MESSAGE_WITH_SOURCE: 4 };
+var EPHEMERAL_FLAG = 1 << 6;
+var ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
+function verifyDiscordSignature(publicKey, signature, timestamp, rawBody) {
+  if (!/^[0-9a-fA-F]{64}$/.test(publicKey)) return false;
+  if (!/^[0-9a-fA-F]{128}$/.test(signature)) return false;
+  if (!timestamp) return false;
+  try {
+    const key = (0, import_node_crypto2.createPublicKey)({
+      key: Buffer.concat([ED25519_SPKI_PREFIX, Buffer.from(publicKey, "hex")]),
+      format: "der",
+      type: "spki"
+    });
+    return (0, import_node_crypto2.verify)(
+      null,
+      Buffer.from(timestamp + rawBody, "utf8"),
+      key,
+      Buffer.from(signature, "hex")
+    );
+  } catch {
+    return false;
+  }
+}
+function createDiscordInteractionHandler(options) {
+  const ephemeral = options.ephemeral ?? true;
+  return {
+    async handle(request) {
+      if (!request.signature || !request.timestamp || !verifyDiscordSignature(options.publicKey, request.signature, request.timestamp, request.rawBody)) {
+        return { status: 401, body: { error: "invalid request signature" } };
+      }
+      let interaction;
+      try {
+        interaction = JSON.parse(request.rawBody);
+      } catch {
+        return { status: 400, body: { error: "body is not JSON" } };
+      }
+      if (interaction.type === INTERACTION_TYPE.PING) {
+        return { status: 200, body: { type: CALLBACK_TYPE.PONG } };
+      }
+      if (interaction.type !== INTERACTION_TYPE.APPLICATION_COMMAND) {
+        return { status: 400, body: { error: `unsupported interaction type ${interaction.type}` } };
+      }
+      const name = interaction.data?.name;
+      if (!name) return { status: 400, body: { error: "interaction carried no command name" } };
+      const values = (interaction.data?.options ?? []).map((option) => option.value === void 0 ? "" : String(option.value)).filter((value) => value.length > 0);
+      const rest = values.join(" ");
+      const args = values.length === 1 ? values[0].split(/\s+/) : values;
+      const userId = interaction.member?.user?.id ?? interaction.user?.id ?? "";
+      const context = {
+        // A guild pays once for all its channels; a DM is billed to the user.
+        subscriberId: `discord:${interaction.guild_id ?? userId}`,
+        platform: "discord",
+        defaultTarget: interaction.channel_id ?? "",
+        args,
+        rest: `${name} ${rest}`.trim()
+      };
+      const reply2 = await options.router.handle(name, context);
+      return {
+        status: 200,
+        body: {
+          type: CALLBACK_TYPE.CHANNEL_MESSAGE_WITH_SOURCE,
+          data: {
+            // Discord hard-caps message content at 2000 characters.
+            content: truncate(reply2.text, 1900),
+            ...ephemeral ? { flags: EPHEMERAL_FLAG } : {}
+          }
+        }
+      };
+    }
+  };
+}
+
+// src/notifiers/types.ts
+function delivered(status, attempts, messageId) {
+  return { ok: true, status, attempts, messageId, error: null, retryable: false };
+}
+function failed(status, attempts, error, retryable) {
+  return { ok: false, status, attempts, messageId: null, error, retryable };
+}
+
+// src/notifiers/telegram.ts
+var PERMANENT_STATUSES = /* @__PURE__ */ new Set([400, 401, 403, 404]);
+function createTelegramClient(options) {
+  if (!/^\d+:[A-Za-z0-9_-]+$/.test(options.botToken)) {
+    throw new Error('hood-alerts: TELEGRAM_BOT_TOKEN must look like "<bot id>:<secret>"');
+  }
+  const fetchImpl = resolveFetch(options.fetch);
+  const apiBase = (options.apiBase ?? "https://api.telegram.org").replace(/\/+$/, "");
+  const maxAttempts = options.maxAttempts ?? 4;
+  const backoffMs = options.backoffMs ?? 500;
+  const maxWaitMs = options.maxWaitMs ?? 6e4;
+  const sleep2 = options.sleep ?? sleep;
+  let lastAttempts = 0;
+  return {
+    get lastAttempts() {
+      return lastAttempts;
+    },
+    async call(method, params) {
+      const url = `${apiBase}/bot${options.botToken}/${method}`;
+      let attempt = 0;
+      let last = {
+        ok: false,
+        status: 0,
+        result: null,
+        description: "no attempt was made",
+        retryAfterSeconds: null
+      };
+      while (attempt < maxAttempts) {
+        attempt += 1;
+        lastAttempts = attempt;
+        let response;
+        try {
+          response = await postJson(fetchImpl, url, params);
+        } catch (error) {
+          last = {
+            ok: false,
+            status: 0,
+            result: null,
+            description: error instanceof Error ? error.message : String(error),
+            retryAfterSeconds: null
+          };
+          if (attempt >= maxAttempts) break;
+          await sleep2(backoffMs * 2 ** (attempt - 1));
+          continue;
+        }
+        const description = typeof pick(response.body, "description") === "string" ? pick(response.body, "description") : null;
+        const retryAfterField = pick(response.body, "parameters", "retry_after");
+        const retryAfterSeconds = typeof retryAfterField === "number" ? retryAfterField : numericHeader(response.headers, "retry-after");
+        last = {
+          ok: response.status === 200 && pick(response.body, "ok") === true,
+          status: response.status,
+          result: pick(response.body, "result") ?? null,
+          description,
+          retryAfterSeconds
+        };
+        if (last.ok) return last;
+        if (response.status === 429) {
+          const waitMs = (retryAfterSeconds ?? backoffMs / 1e3) * 1e3;
+          if (waitMs > maxWaitMs || attempt >= maxAttempts) return last;
+          await sleep2(waitMs);
+          continue;
+        }
+        if (PERMANENT_STATUSES.has(response.status)) return last;
+        if (attempt >= maxAttempts) return last;
+        await sleep2(backoffMs * 2 ** (attempt - 1));
+      }
+      return last;
+    }
+  };
+}
+function createTelegramNotifier(options) {
+  const client = options.client ?? createTelegramClient(options);
+  const disableWebPagePreview = options.disableWebPagePreview ?? true;
+  const disableNotification = options.disableNotification ?? false;
+  return {
+    platform: "telegram",
+    kind: "bot",
+    async send(target, alert) {
+      if (!/^-?\d+$|^@[A-Za-z][A-Za-z0-9_]{4,}$/.test(target)) {
+        return failed(
+          null,
+          0,
+          `invalid Telegram chat id "${target}": expected a numeric id or an @username`,
+          false
+        );
+      }
+      const response = await client.call("sendMessage", {
+        chat_id: /^-?\d+$/.test(target) ? Number(target) : target,
+        text: alert.text,
+        parse_mode: alert.parseMode,
+        link_preview_options: { is_disabled: disableWebPagePreview },
+        disable_notification: disableNotification
+      });
+      const attempts = client.lastAttempts;
+      if (response.ok) {
+        const messageId = pick(response.result, "message_id");
+        return delivered(response.status, attempts, messageId === void 0 ? null : String(messageId));
+      }
+      const retryable = response.status === 429 || response.status >= 500 || response.status === 0;
+      return failed(
+        response.status || null,
+        attempts,
+        response.description ?? `Telegram sendMessage failed with status ${response.status}`,
+        retryable
+      );
+    }
+  };
+}
+
+// src/bot/telegram-bot.ts
+function parseCommand(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("/")) return null;
+  const [head, ...tail] = trimmed.split(/\s+/);
+  if (!head) return null;
+  return { command: head, args: tail, rest: trimmed.slice(head.length).trim() };
+}
+function createTelegramBot(options) {
+  const client = options.client ?? createTelegramClient(options);
+  const logger = options.logger ?? createSilentLogger();
+  const pollTimeout = options.pollTimeoutSeconds ?? 30;
+  let offset = options.offsetStore?.get() ?? 0;
+  let running = false;
+  async function handleUpdate(update) {
+    const message = update.message;
+    const text = message?.text;
+    const chatId = message?.chat?.id;
+    const fromId = message?.from?.id;
+    if (!text || chatId === void 0 || fromId === void 0 || message?.from?.is_bot === true) return;
+    const parsed = parseCommand(text);
+    if (!parsed) return;
+    const context = {
+      subscriberId: `telegram:${fromId}`,
+      platform: "telegram",
+      defaultTarget: String(chatId),
+      args: parsed.args,
+      rest: parsed.rest
+    };
+    const reply2 = await options.router.handle(parsed.command, context);
+    const response = await client.call("sendMessage", {
+      chat_id: chatId,
+      text: reply2.html,
+      parse_mode: "HTML",
+      link_preview_options: { is_disabled: true }
+    });
+    if (!response.ok) {
+      logger.warn("telegram reply failed", {
+        chatId,
+        command: parsed.command,
+        error: response.description
+      });
+    }
+  }
+  return {
+    async publishCommands() {
+      const response = await client.call("setMyCommands", {
+        commands: options.router.commands.map((command) => ({
+          command: command.name,
+          description: command.description.slice(0, 256)
+        }))
+      });
+      if (!response.ok) logger.warn("setMyCommands failed", { error: response.description });
+      return response.ok;
+    },
+    async pollOnce() {
+      const response = await client.call("getUpdates", {
+        ...offset > 0 ? { offset } : {},
+        timeout: pollTimeout,
+        allowed_updates: ["message"]
+      });
+      if (!response.ok) {
+        logger.warn("getUpdates failed", { error: response.description });
+        return 0;
+      }
+      const updates = Array.isArray(response.result) ? response.result : [];
+      for (const update of updates) {
+        try {
+          await handleUpdate(update);
+        } catch (error) {
+          logger.error("telegram update handler threw", {
+            updateId: update.update_id,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+        offset = update.update_id + 1;
+        options.offsetStore?.set(offset);
+      }
+      return updates.length;
+    },
+    async start() {
+      running = true;
+      logger.info("telegram bot started", { offset });
+      while (running) {
+        try {
+          await this.pollOnce();
+        } catch (error) {
+          logger.error("telegram poll failed", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+          await new Promise((resolve) => setTimeout(resolve, 2e3));
+        }
+      }
+      logger.info("telegram bot stopped");
+    },
+    stop() {
+      running = false;
+    }
+  };
+}
+
+// src/notifiers/capture.ts
+function createCaptureNotifier(platform, onSend, now = Date.now) {
+  const sent = [];
+  return {
+    platform,
+    kind: "capture",
+    sent,
+    clear() {
+      sent.length = 0;
+    },
+    async send(target, alert) {
+      const delivery = { platform, target, alert, atMs: now() };
+      sent.push(delivery);
+      onSend?.(delivery);
+      return delivered(200, 1, `capture-${sent.length}`);
+    }
+  };
+}
+
+// src/notifiers/discord.ts
+function createDiscordRateLimiter(now = Date.now, sleep2 = sleep) {
+  const buckets = /* @__PURE__ */ new Map();
+  let globalResetAtMs = 0;
+  return {
+    async acquire(route) {
+      const globalWait = globalResetAtMs - now();
+      if (globalWait > 0) await sleep2(globalWait);
+      const bucket = buckets.get(route);
+      if (!bucket) return;
+      if (bucket.remaining > 0) return;
+      const wait = bucket.resetAtMs - now();
+      if (wait > 0) await sleep2(wait);
+    },
+    update(route, headers) {
+      const remaining = numericHeader(headers, "x-ratelimit-remaining");
+      const resetAfter = numericHeader(headers, "x-ratelimit-reset-after");
+      if (remaining === null && resetAfter === null) return;
+      buckets.set(route, {
+        remaining: remaining ?? 1,
+        resetAtMs: now() + (resetAfter ?? 0) * 1e3
+      });
+    },
+    penalise(route, retryAfterMs, global) {
+      const resetAtMs = now() + retryAfterMs;
+      if (global) globalResetAtMs = Math.max(globalResetAtMs, resetAtMs);
+      buckets.set(route, { remaining: 0, resetAtMs });
+    }
+  };
+}
+var PERMANENT_STATUSES2 = /* @__PURE__ */ new Set([400, 401, 403, 404, 405]);
+async function deliver(args, options, fetchImpl, limiter) {
+  const maxAttempts = options.maxAttempts ?? 4;
+  const backoffMs = options.backoffMs ?? 500;
+  const maxWaitMs = options.maxWaitMs ?? 6e4;
+  const sleep2 = options.sleep ?? sleep;
+  let attempt = 0;
+  let lastStatus = null;
+  let lastError = "no attempt was made";
+  let retryable = true;
+  while (attempt < maxAttempts) {
+    attempt += 1;
+    await limiter.acquire(args.route);
+    let response;
+    try {
+      response = await postJson(fetchImpl, args.url, args.payload, args.headers);
+    } catch (error) {
+      lastStatus = null;
+      lastError = error instanceof Error ? error.message : String(error);
+      retryable = true;
+      if (attempt >= maxAttempts) break;
+      await sleep2(backoffMs * 2 ** (attempt - 1));
+      continue;
+    }
+    limiter.update(args.route, response.headers);
+    lastStatus = response.status;
+    if (response.status === 429) {
+      const retryAfterField = pick(response.body, "retry_after");
+      const retryAfterSeconds = typeof retryAfterField === "number" ? retryAfterField : numericHeader(response.headers, "retry-after") ?? backoffMs / 1e3;
+      const isGlobal = pick(response.body, "global") === true || response.headers.get("x-ratelimit-global") === "true";
+      const waitMs = retryAfterSeconds * 1e3;
+      limiter.penalise(args.route, waitMs, isGlobal);
+      lastError = `rate limited, retry after ${retryAfterSeconds}s${isGlobal ? " (global)" : ""}`;
+      retryable = true;
+      if (waitMs > maxWaitMs || attempt >= maxAttempts) break;
+      await sleep2(waitMs);
+      continue;
+    }
+    if (response.ok) {
+      const messageId = pick(response.body, "id");
+      return delivered(response.status, attempt, messageId === void 0 ? null : String(messageId));
+    }
+    const message = (typeof pick(response.body, "message") === "string" ? pick(response.body, "message") : null) ?? response.raw.slice(0, 200);
+    lastError = message || `Discord request failed with status ${response.status}`;
+    if (PERMANENT_STATUSES2.has(response.status)) {
+      retryable = false;
+      break;
+    }
+    retryable = true;
+    if (attempt >= maxAttempts) break;
+    await sleep2(backoffMs * 2 ** (attempt - 1));
+  }
+  return failed(lastStatus, attempt, lastError, retryable);
+}
+var WEBHOOK_PATTERN = /^https:\/\/(?:\w+\.)?discord(?:app)?\.com\/api(?:\/v\d+)?\/webhooks\/\d+\/[\w-]+$/;
+function createDiscordWebhookNotifier(options = {}) {
+  const fetchImpl = resolveFetch(options.fetch);
+  const limiter = options.limiter ?? createDiscordRateLimiter(options.now ?? Date.now, options.sleep ?? sleep);
+  return {
+    platform: "discord",
+    kind: "webhook",
+    async send(target, alert) {
+      const url = target || options.webhookUrl;
+      if (!url || !WEBHOOK_PATTERN.test(url)) {
+        return failed(
+          null,
+          0,
+          `invalid Discord webhook URL "${target}": expected https://discord.com/api/webhooks/<id>/<token>`,
+          false
+        );
+      }
+      return deliver(
+        {
+          url: `${url}?wait=true`,
+          // Discord buckets webhook routes per webhook id.
+          route: `webhook:${url.split("/").slice(-2, -1)[0] ?? url}`,
+          payload: {
+            embeds: [alert.embed],
+            ...options.username ? { username: options.username } : {}
+          },
+          headers: {}
+        },
+        options,
+        fetchImpl,
+        limiter
+      );
+    }
+  };
+}
+function createDiscordBotNotifier(options) {
+  if (!options.botToken.trim()) {
+    throw new Error("hood-alerts: DISCORD_BOT_TOKEN is required for the Discord bot notifier");
+  }
+  const fetchImpl = resolveFetch(options.fetch);
+  const apiBase = (options.apiBase ?? "https://discord.com/api/v10").replace(/\/+$/, "");
+  const limiter = options.limiter ?? createDiscordRateLimiter(options.now ?? Date.now, options.sleep ?? sleep);
+  return {
+    platform: "discord",
+    kind: "bot",
+    async send(target, alert) {
+      if (!/^\d{5,25}$/.test(target)) {
+        return failed(null, 0, `invalid Discord channel id "${target}": expected a numeric snowflake`, false);
+      }
+      return deliver(
+        {
+          url: `${apiBase}/channels/${target}/messages`,
+          route: `channel:${target}`,
+          payload: { embeds: [alert.embed] },
+          headers: { authorization: `Bot ${options.botToken}` }
+        },
+        options,
+        fetchImpl,
+        limiter
+      );
+    }
+  };
+}
+
+// src/tiers/policy.ts
+var TIER_POLICIES = {
+  free: {
+    tier: "free",
+    maxSubscriptions: 1,
+    maxRulesPerSubscription: 3,
+    maxRuleComplexity: 3,
+    maxWatchlistTokens: 5,
+    maxAlertsPerHour: 30,
+    deliveryDelayMs: 6e4,
+    allowOnChainLookupFilters: false,
+    allowedKinds: ["launch", "graduation", "whale_trade"]
+  },
+  premium: {
+    tier: "premium",
+    maxSubscriptions: 10,
+    maxRulesPerSubscription: 50,
+    maxRuleComplexity: 24,
+    maxWatchlistTokens: 500,
+    maxAlertsPerHour: 2e3,
+    deliveryDelayMs: 0,
+    allowOnChainLookupFilters: true,
+    allowedKinds: ["launch", "curve_trade", "graduation", "whale_trade"]
+  }
+};
+var OK = { allowed: true, reason: null };
+var deny = (reason) => ({ allowed: false, reason });
+function canAddSubscription(policy, currentCount) {
+  if (currentCount >= policy.maxSubscriptions) {
+    return deny(
+      `the ${policy.tier} tier allows ${policy.maxSubscriptions} subscription${policy.maxSubscriptions === 1 ? "" : "s"} and you have ${currentCount}. Upgrade with /upgrade, or remove one with /unsubscribe.`
+    );
+  }
+  return OK;
+}
+function canAddRule(policy, rule, currentRuleCount) {
+  if (currentRuleCount >= policy.maxRulesPerSubscription) {
+    return deny(
+      `the ${policy.tier} tier allows ${policy.maxRulesPerSubscription} rules per subscription and you have ${currentRuleCount}.`
+    );
+  }
+  return isRuleAllowed(policy, rule);
+}
+function isRuleAllowed(policy, rule) {
+  const disallowedKinds = rule.kinds.filter((kind) => !policy.allowedKinds.includes(kind));
+  if (disallowedKinds.length > 0) {
+    return deny(
+      `the ${policy.tier} tier does not include ${disallowedKinds.join(", ")} alerts. Allowed: ${policy.allowedKinds.join(", ")}.`
+    );
+  }
+  const complexity = ruleComplexity(rule);
+  if (complexity > policy.maxRuleComplexity) {
+    return deny(
+      `this rule uses ${complexity} filters and the ${policy.tier} tier allows ${policy.maxRuleComplexity}.`
+    );
+  }
+  if (rule.tokens.length > policy.maxWatchlistTokens) {
+    return deny(
+      `the ${policy.tier} tier allows ${policy.maxWatchlistTokens} watchlist tokens and this rule has ${rule.tokens.length}.`
+    );
+  }
+  if (rule.deployers.length + rule.excludeDeployers.length > policy.maxWatchlistTokens) {
+    return deny(
+      `the ${policy.tier} tier allows ${policy.maxWatchlistTokens} watched deployers per rule.`
+    );
+  }
+  if (!policy.allowOnChainLookupFilters && usesOnChainLookups(rule)) {
+    return deny(
+      `liquidity and deployer-reputation filters are a premium feature: each one costs an on-chain read per candidate event.`
+    );
+  }
+  return OK;
+}
+function policyFor(tier, overrides) {
+  const base = TIER_POLICIES[tier];
+  const override = overrides?.[tier];
+  return override ? { ...base, ...override, tier } : base;
+}
+
+// src/tiers/enforce.ts
+function createEntitlementGate(options) {
+  async function resolve(subscriberId) {
+    const entitlement = await options.provider.get(subscriberId);
+    return { entitlement, policy: policyFor(entitlement.tier, options.policyOverrides) };
+  }
+  return {
+    resolve,
+    async checkAddSubscription(subscriberId, currentCount) {
+      const { policy } = await resolve(subscriberId);
+      return canAddSubscription(policy, currentCount);
+    },
+    async checkAddRule(subscriberId, rule, currentRuleCount) {
+      const { policy } = await resolve(subscriberId);
+      return canAddRule(policy, rule, currentRuleCount);
+    },
+    async checkRule(subscriberId, rule) {
+      const { policy } = await resolve(subscriberId);
+      return isRuleAllowed(policy, rule);
+    },
+    async deliveryDelayMs(subscriberId) {
+      const { policy } = await resolve(subscriberId);
+      return policy.deliveryDelayMs;
+    },
+    async checkThroughput(subscriberId, deliveredInLastHour) {
+      const { policy } = await resolve(subscriberId);
+      if (deliveredInLastHour >= policy.maxAlertsPerHour) {
+        return {
+          allowed: false,
+          reason: `hourly alert cap reached (${policy.maxAlertsPerHour} on the ${policy.tier} tier)`
+        };
+      }
+      return { allowed: true, reason: null };
+    }
+  };
+}
+
+// src/service/runner.ts
+var VERSION = "0.1.0";
+function buildEntitlements(config, client, store) {
+  const staticProvider = createStaticEntitlementProvider({
+    premiumSubscribers: config.premiumSubscribers,
+    allPremium: config.allPremium
+  });
+  if (config.entitlements === "static") return staticProvider;
+  const usdgProvider = createUsdgEntitlementProvider({
+    client,
+    receiver: config.usdgReceiver,
+    pricePerPeriodUsdg: config.premiumPriceUsdg,
+    periodDays: config.premiumPeriodDays,
+    links: store.walletLinks(),
+    fromBlock: config.paymentsFromBlock
+  });
+  if (config.entitlements === "usdg") return usdgProvider;
+  return chainEntitlementProviders(staticProvider, usdgProvider);
+}
+function createService(options) {
+  const config = options.config;
+  const logger = options.logger ?? createLogger({ level: config.logLevel, base: { service: "hood-alerts" } });
+  const client = options.client ?? (0, import_hoodchain7.createHoodClient)({
+    chain: config.network,
+    ...config.rpcUrl ? { rpcUrl: config.rpcUrl } : {}
+  });
+  const store = options.store ?? new AlertStore(config.dbPath);
+  const oracle = createPriceOracle(client);
+  const tokens = createTokenMetaReader(client);
+  const registry = store.poolRegistry();
+  const liquidity = createLiquidityReader(client, oracle, registry);
+  const reputation = createRpcReputationProvider(client, oracle);
+  const sources = createEventSources({
+    client,
+    oracle,
+    tokens,
+    registry,
+    pinnedTokens: async () => store.watchlistTokens(),
+    whaleMinUsd: config.whaleMinUsd,
+    whalePoolLimit: config.whalePoolLimit
+  });
+  const entitlements = buildEntitlements(config, client, store);
+  const gate = createEntitlementGate({ provider: entitlements });
+  const platforms = [];
+  let telegramNotifier = null;
+  let discordWebhookNotifier = null;
+  let discordBotNotifier = null;
+  const telegramClient = config.telegramBotToken ? createTelegramClient({ botToken: config.telegramBotToken }) : null;
+  if (config.dryRun) {
+    telegramNotifier = createCaptureNotifier(
+      "telegram",
+      (delivery) => logger.info("dry run: telegram alert", { target: delivery.target, text: delivery.alert.plain })
+    );
+    discordWebhookNotifier = createCaptureNotifier(
+      "discord",
+      (delivery) => logger.info("dry run: discord alert", { target: delivery.target, text: delivery.alert.plain })
+    );
+    discordBotNotifier = discordWebhookNotifier;
+    platforms.push("dry-run");
+  } else {
+    if (telegramClient) {
+      telegramNotifier = createTelegramNotifier({
+        botToken: config.telegramBotToken,
+        client: telegramClient
+      });
+      platforms.push("telegram");
+    }
+    discordWebhookNotifier = createDiscordWebhookNotifier({});
+    platforms.push("discord-webhook");
+    if (config.discordBotToken) {
+      discordBotNotifier = createDiscordBotNotifier({ botToken: config.discordBotToken });
+      platforms.push("discord-bot");
+    }
+  }
+  function notifierFor(subscription) {
+    if (subscription.platform === "telegram") return telegramNotifier;
+    if (subscription.target.startsWith("https://")) return discordWebhookNotifier;
+    return discordBotNotifier;
+  }
+  const dispatcher = createDispatcher({
+    store,
+    sources,
+    gate,
+    rateLimits: store.rateLimitStore(),
+    notifierFor,
+    getBlockNumber: () => client.public.getBlockNumber(),
+    logger,
+    evaluation: {
+      liquidityUsd: (event) => liquidity.tokenLiquidityUsd(event.token),
+      reputation: (deployer) => reputation.get(deployer),
+      isLpLocked: (positionId) => reputation.isLpLocked(positionId)
+    },
+    confirmations: config.confirmations,
+    chunkSize: config.chunkSize,
+    initialLookbackBlocks: config.initialLookbackBlocks,
+    flushBatchSize: config.flushBatchSize,
+    maxDeliveryAttempts: config.maxDeliveryAttempts,
+    retryBackoffMs: config.retryBackoffMs
+  });
+  const router = createCommandRouter({
+    store,
+    gate,
+    ...config.upgradeInstructions ? { upgradeInstructions: config.upgradeInstructions } : {}
+  });
+  let telegramBot = null;
+  if (telegramClient && !config.dryRun) {
+    telegramBot = createTelegramBot({
+      botToken: config.telegramBotToken,
+      client: telegramClient,
+      router,
+      logger: logger.child({ component: "telegram-bot" }),
+      offsetStore: {
+        get: () => {
+          const raw = store.getMeta("telegram:offset");
+          return raw === null ? null : Number(raw);
+        },
+        set: (offset) => store.setMeta("telegram:offset", String(offset))
+      }
+    });
+  }
+  const discordHandler = config.discordPublicKey ? createDiscordInteractionHandler({ router, publicKey: config.discordPublicKey }) : null;
+  const startedAtMs = Date.now();
+  let headBlock = null;
+  let lastPollAtMs = null;
+  let lastError = null;
+  const health = () => ({
+    headBlock,
+    lastPollAtMs,
+    lastError,
+    platforms,
+    version: VERSION,
+    startedAtMs
+  });
+  const server = createHttpServer({
+    store,
+    logger: logger.child({ component: "http" }),
+    health,
+    ...discordHandler ? { discord: { path: config.discordInteractionsPath, handle: discordHandler.handle } } : {}
+  });
+  let running = false;
+  const loops = [];
+  let stopping = null;
+  const waiters = /* @__PURE__ */ new Set();
+  function delay(ms) {
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        waiters.delete(wake);
+        resolve();
+      }, ms);
+      const wake = () => {
+        clearTimeout(timer);
+        waiters.delete(wake);
+        resolve();
+      };
+      waiters.add(wake);
+    });
+  }
+  async function pollLoop() {
+    while (running) {
+      try {
+        headBlock = await client.public.getBlockNumber();
+        const stats = await dispatcher.pollOnce();
+        lastPollAtMs = Date.now();
+        lastError = stats.errors.length > 0 ? stats.errors[0]?.error ?? null : null;
+        if (stats.eventsDecoded > 0 || stats.enqueued > 0) {
+          logger.info("poll complete", {
+            head: headBlock,
+            events: stats.eventsDecoded,
+            enqueued: stats.enqueued,
+            deduped: stats.deduped,
+            suppressed: stats.suppressed,
+            errors: stats.errors.length
+          });
+        }
+      } catch (error) {
+        lastError = error instanceof Error ? error.message : String(error);
+        logger.error("poll loop error", { error: lastError });
+      }
+      await delay(config.pollIntervalMs);
+    }
+  }
+  async function flushLoop() {
+    while (running) {
+      try {
+        const stats = await dispatcher.flushOnce();
+        if (stats.claimed > 0) logger.debug("flush complete", { ...stats });
+      } catch (error) {
+        logger.error("flush loop error", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+      await delay(config.flushIntervalMs);
+    }
+  }
+  async function pruneLoop() {
+    while (running) {
+      await delay(36e5);
+      if (!running) break;
+      try {
+        const cutoff = Date.now() - config.outboxRetentionHours * 36e5;
+        const outbox = store.pruneOutbox(cutoff);
+        const deliveries = store.pruneDeliveries(Date.now() - 25 * 36e5);
+        if (outbox > 0 || deliveries > 0) logger.info("pruned", { outbox, deliveries });
+      } catch (error) {
+        logger.error("prune failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+  return {
+    config,
+    store,
+    dispatcher,
+    logger,
+    health,
+    async start() {
+      if (running) return;
+      running = true;
+      dispatcher.recover();
+      await new Promise((resolve, reject) => {
+        const onError = (error) => reject(error);
+        server.once("error", onError);
+        server.listen(config.port, () => {
+          server.removeListener("error", onError);
+          resolve();
+        });
+      });
+      logger.info("service started", {
+        port: config.port,
+        network: config.network,
+        dryRun: config.dryRun,
+        platforms,
+        entitlements: config.entitlements,
+        sources: sources.map((source) => source.id)
+      });
+      loops.push(pollLoop(), flushLoop(), pruneLoop());
+      if (telegramBot) {
+        await telegramBot.publishCommands();
+        loops.push(telegramBot.start());
+      }
+    },
+    async stop() {
+      stopping ??= (async () => {
+        logger.info("service stopping");
+        running = false;
+        telegramBot?.stop();
+        for (const wake of [...waiters]) wake();
+        await new Promise((resolve) => {
+          server.close(() => resolve());
+          server.closeAllConnections?.();
+        });
+        await Promise.allSettled(loops);
+        store.close();
+        logger.info("service stopped");
+      })();
+      return stopping;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AlertStore,
+  LEVELS,
+  VERSION,
+  createDispatcher,
+  createHttpServer,
+  createLogger,
+  createService,
+  createSilentLogger,
+  decode,
+  decodeEvent,
+  encode,
+  encodeEvent,
+  loadConfig,
+  renderMetrics
+});
+//# sourceMappingURL=index.cjs.map