hood-alerts 0.1.0

package/dist/bot/index.cjs

@@ -0,0 +1,1008 @@
+"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/bot/index.ts
+var bot_exports = {};
+__export(bot_exports, {
+  CALLBACK_TYPE: () => CALLBACK_TYPE,
+  COMMANDS: () => COMMANDS,
+  EPHEMERAL_FLAG: () => EPHEMERAL_FLAG,
+  INTERACTION_TYPE: () => INTERACTION_TYPE,
+  createCommandRouter: () => createCommandRouter,
+  createDiscordInteractionHandler: () => createDiscordInteractionHandler,
+  createTelegramBot: () => createTelegramBot,
+  discordCommandDefinitions: () => discordCommandDefinitions,
+  registerDiscordCommands: () => registerDiscordCommands,
+  verifyDiscordSignature: () => verifyDiscordSignature
+});
+module.exports = __toCommonJS(bot_exports);
+
+// src/bot/commands.ts
+var import_node_crypto = require("crypto");
+var import_viem3 = require("viem");
+
+// src/notifiers/escape.ts
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+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`;
+}
+
+// src/rules/schema.ts
+var import_zod = 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_zod.z.string().regex(addressPattern, "must be a 0x-prefixed 20-byte address").transform((value) => value.toLowerCase());
+var eventKindSchema = import_zod.z.enum(["launch", "curve_trade", "graduation", "whale_trade"]);
+var launchpadSchema = import_zod.z.enum(["noxa", "odyssey"]);
+var sideSchema = import_zod.z.enum(["buy", "sell", "any"]);
+var reputationFilterSchema = import_zod.z.object({
+  /** Require the deployer to have launched at least this many tokens before. */
+  minPriorLaunches: import_zod.z.number().int().min(0).max(1e4).optional(),
+  /** Reject serial deployers above this prior-launch count. */
+  maxPriorLaunches: import_zod.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_zod.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_zod.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_zod.z.object({
+  /** Hard cap on alerts this rule may deliver per rolling hour. */
+  maxPerHour: import_zod.z.number().int().min(1).max(1e4).optional(),
+  /** Minimum gap between two alerts from this rule, in seconds. */
+  minIntervalSeconds: import_zod.z.number().int().min(1).max(86400).optional()
+}).strict();
+var ruleSchema = import_zod.z.object({
+  /** Stable id, unique within a subscription. Used in bot commands. */
+  id: import_zod.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_zod.z.string().min(1).max(64).optional(),
+  enabled: import_zod.z.boolean().default(true),
+  /** Event kinds this rule reacts to. Defaults to all four. */
+  kinds: import_zod.z.array(eventKindSchema).min(1).max(4).default(["launch", "curve_trade", "graduation", "whale_trade"]),
+  /** Launchpads this rule reacts to. Defaults to both. */
+  launchpads: import_zod.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_zod.z.number().min(0).max(1e12).optional(),
+  /** Maximum USD value of the event. */
+  maxUsd: import_zod.z.number().min(0).max(1e12).optional(),
+  /** Minimum USD liquidity of the token's deepest known pool. */
+  minLiquidityUsd: import_zod.z.number().min(0).max(1e12).optional(),
+  /** Maximum USD liquidity of the token's deepest known pool. */
+  maxLiquidityUsd: import_zod.z.number().min(0).max(1e12).optional(),
+  /** Watchlist. When non-empty, only these tokens match. */
+  tokens: import_zod.z.array(addressSchema).max(500).default([]),
+  /** Deployer watchlist. When non-empty, only these actors match. */
+  deployers: import_zod.z.array(addressSchema).max(500).default([]),
+  /** Deployers to always reject, applied after every other filter. */
+  excludeDeployers: import_zod.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_zod.z.enum(["telegram", "discord"]);
+var subscriptionSchema = import_zod.z.object({
+  id: import_zod.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_zod.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_zod.z.string().min(1).max(512),
+  enabled: import_zod.z.boolean().default(true),
+  rules: import_zod.z.array(ruleSchema).max(100).default([]),
+  createdAtMs: import_zod.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 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/tiers/entitlements.ts
+var import_viem = require("viem");
+var import_hoodchain = require("hoodchain");
+var import_viem2 = require("viem");
+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_viem.verifyMessage)({
+      address: (0, import_viem.getAddress)(address),
+      message: linkMessage(subscriberId, nonce),
+      signature
+    });
+    return valid ? (0, import_viem.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 json = context.rest.slice(context.rest.indexOf("add") + 3).trim();
+      if (!json) {
+        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(json);
+      } 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_viem3.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 delivered = 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>, ${delivered} 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/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/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;
+    }
+  };
+}
+
+// src/service/logger.ts
+function createSilentLogger() {
+  const silent = {
+    debug: () => void 0,
+    info: () => void 0,
+    warn: () => void 0,
+    error: () => void 0,
+    child: () => silent
+  };
+  return silent;
+}
+
+// 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/bot/discord-bot.ts
+var import_node_crypto2 = require("crypto");
+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 discordCommandDefinitions(commands) {
+  return commands.map((command) => ({
+    name: command.name,
+    // Discord caps descriptions at 100 characters and rejects the whole
+    // registration if any one is longer.
+    description: truncate(command.description, 100),
+    ...command.options && command.options.length > 0 ? {
+      options: command.options.map((option) => ({
+        type: 3,
+        name: option.name,
+        description: truncate(option.description, 100),
+        required: option.required
+      }))
+    } : {}
+  }));
+}
+async function registerDiscordCommands(commands, options) {
+  const fetchImpl = resolveFetch(options.fetch);
+  const apiBase = (options.apiBase ?? "https://discord.com/api/v10").replace(/\/+$/, "");
+  const url = options.guildId ? `${apiBase}/applications/${options.applicationId}/guilds/${options.guildId}/commands` : `${apiBase}/applications/${options.applicationId}/commands`;
+  const response = await fetchImpl(url, {
+    method: "PUT",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bot ${options.botToken}`
+    },
+    body: JSON.stringify(discordCommandDefinitions(commands))
+  });
+  const raw = await response.text();
+  if (!response.ok) {
+    throw new Error(`hood-alerts: Discord rejected the command registration (${response.status}): ${raw}`);
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.length : 0;
+  } catch {
+    return 0;
+  }
+}
+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 } : {}
+          }
+        }
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CALLBACK_TYPE,
+  COMMANDS,
+  EPHEMERAL_FLAG,
+  INTERACTION_TYPE,
+  createCommandRouter,
+  createDiscordInteractionHandler,
+  createTelegramBot,
+  discordCommandDefinitions,
+  registerDiscordCommands,
+  verifyDiscordSignature
+});
+//# sourceMappingURL=index.cjs.map