hood-alerts 0.1.0

package/dist/tiers/index.cjs

@@ -0,0 +1,471 @@
+"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/tiers/index.ts
+var tiers_exports = {};
+__export(tiers_exports, {
+  TIER_POLICIES: () => TIER_POLICIES,
+  accrueExpiry: () => accrueExpiry,
+  canAddRule: () => canAddRule,
+  canAddSubscription: () => canAddSubscription,
+  chainEntitlementProviders: () => chainEntitlementProviders,
+  createEntitlementGate: () => createEntitlementGate,
+  createStaticEntitlementProvider: () => createStaticEntitlementProvider,
+  createUsdgEntitlementProvider: () => createUsdgEntitlementProvider,
+  isRuleAllowed: () => isRuleAllowed,
+  linkMessage: () => linkMessage,
+  policyFor: () => policyFor,
+  verifyWalletLink: () => verifyWalletLink
+});
+module.exports = __toCommonJS(tiers_exports);
+
+// 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 usesOnChainLookups(rule) {
+  return rule.minLiquidityUsd !== void 0 || rule.maxLiquidityUsd !== void 0 || rule.reputation !== void 0 && Object.values(rule.reputation).some((value) => value !== void 0);
+}
+
+// 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/entitlements.ts
+var import_viem = require("viem");
+var import_hoodchain = require("hoodchain");
+var import_viem2 = require("viem");
+
+// 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 sleep = 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 sleep(backoffMs * 2 ** attempt);
+          attempt += 1;
+          continue;
+        }
+        throw error;
+      }
+    }
+  };
+  if (to < from) return [];
+  return run(from, to);
+}
+
+// src/tiers/entitlements.ts
+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_viem.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_viem2.formatUnits)(value, import_hoodchain.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_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/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 };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TIER_POLICIES,
+  accrueExpiry,
+  canAddRule,
+  canAddSubscription,
+  chainEntitlementProviders,
+  createEntitlementGate,
+  createStaticEntitlementProvider,
+  createUsdgEntitlementProvider,
+  isRuleAllowed,
+  linkMessage,
+  policyFor,
+  verifyWalletLink
+});
+//# sourceMappingURL=index.cjs.map

package/dist/tiers/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/tiers/index.ts","../../src/rules/schema.ts","../../src/events/types.ts","../../src/tiers/policy.ts","../../src/tiers/entitlements.ts","../../src/events/logs.ts","../../src/tiers/enforce.ts"],"sourcesContent":["/**\n * Tiering and entitlements: what free and premium may do, and who is premium.\n *\n * @packageDocumentation\n */\n\nexport {\n  TIER_POLICIES,\n  canAddRule,\n  canAddSubscription,\n  isRuleAllowed,\n  policyFor,\n} from './policy.js'\nexport type { PolicyDecision, Tier, TierPolicy } from './policy.js'\n\nexport {\n  accrueExpiry,\n  chainEntitlementProviders,\n  createStaticEntitlementProvider,\n  createUsdgEntitlementProvider,\n  linkMessage,\n  verifyWalletLink,\n} from './entitlements.js'\nexport type {\n  Entitlement,\n  EntitlementProvider,\n  UsdgEntitlementOptions,\n  WalletLinkStore,\n} from './entitlements.js'\n\nexport { createEntitlementGate } from './enforce.js'\nexport type { EntitlementGate, EntitlementGateOptions } from './enforce.js'\n","import { z } from 'zod'\nimport { LAUNCHPAD_EVENT_KINDS, type AlertEventKind, type Launchpad } from '../events/types.js'\n\n/**\n * Rules are data, not code.\n *\n * Every filter a subscriber can set is expressed as a JSON document validated\n * by these schemas, which means a rule can be stored in SQLite, edited from a\n * Telegram or Discord command, diffed, exported and re-imported without any\n * of it going through `eval`, a DSL parser or a hand-rolled validator. The\n * schema is the single source of truth for what a valid rule is: the bot, the\n * service and the tier policy all validate through it.\n */\n\nconst addressPattern = /^0x[0-9a-fA-F]{40}$/\n\n/** An EVM address, stored lowercase so comparisons never depend on checksum casing. */\nexport const addressSchema = z\n  .string()\n  .regex(addressPattern, 'must be a 0x-prefixed 20-byte address')\n  .transform((value) => value.toLowerCase())\n\n/** The four alert kinds. */\nexport const eventKindSchema = z.enum(['launch', 'curve_trade', 'graduation', 'whale_trade'])\n\n/** The two launchpads. */\nexport const launchpadSchema = z.enum(['noxa', 'odyssey'])\n\n/** Trade direction filter. `any` disables the filter. */\nexport const sideSchema = z.enum(['buy', 'sell', 'any'])\n\n/**\n * Deployer reputation filters, all derived from on-chain history (see\n * `hood-alerts/rules` `createRpcReputationProvider`). Every bound is inclusive.\n */\nexport const reputationFilterSchema = z\n  .object({\n    /** Require the deployer to have launched at least this many tokens before. */\n    minPriorLaunches: z.number().int().min(0).max(10_000).optional(),\n    /** Reject serial deployers above this prior-launch count. */\n    maxPriorLaunches: z.number().int().min(0).max(10_000).optional(),\n    /**\n     * Reject a deployer with more than this many prior launches whose pool\n     * liquidity has since been drained below the rug threshold.\n     */\n    maxRuggedLaunches: z.number().int().min(0).max(10_000).optional(),\n    /**\n     * Require this launch's own LP position to be held by the launchpad's\n     * locker contract. Only meaningful for `launch` events that carry a pool\n     * (NOXA); events without a pool never satisfy it.\n     */\n    requireLpLocked: z.boolean().optional(),\n  })\n  .strict()\n  .refine(\n    (value) =>\n      value.minPriorLaunches === undefined ||\n      value.maxPriorLaunches === undefined ||\n      value.minPriorLaunches <= value.maxPriorLaunches,\n    { message: 'minPriorLaunches must not exceed maxPriorLaunches' },\n  )\n\n/** Per-rule delivery rate limits. */\nexport const rateLimitSchema = z\n  .object({\n    /** Hard cap on alerts this rule may deliver per rolling hour. */\n    maxPerHour: z.number().int().min(1).max(10_000).optional(),\n    /** Minimum gap between two alerts from this rule, in seconds. */\n    minIntervalSeconds: z.number().int().min(1).max(86_400).optional(),\n  })\n  .strict()\n\n/** A single alert rule. */\nexport const ruleSchema = z\n  .object({\n    /** Stable id, unique within a subscription. Used in bot commands. */\n    id: z\n      .string()\n      .min(1)\n      .max(32)\n      .regex(/^[a-z0-9][a-z0-9_-]*$/, 'must be lowercase letters, digits, hyphen or underscore'),\n    /** Human label shown in `/rules`. */\n    name: z.string().min(1).max(64).optional(),\n    enabled: z.boolean().default(true),\n    /** Event kinds this rule reacts to. Defaults to all four. */\n    kinds: z.array(eventKindSchema).min(1).max(4).default(['launch', 'curve_trade', 'graduation', 'whale_trade']),\n    /** Launchpads this rule reacts to. Defaults to both. */\n    launchpads: z.array(launchpadSchema).min(1).max(2).default(['noxa', 'odyssey']),\n    /** Minimum USD value of the event. Events with an unknown value never pass. */\n    minUsd: z.number().min(0).max(1e12).optional(),\n    /** Maximum USD value of the event. */\n    maxUsd: z.number().min(0).max(1e12).optional(),\n    /** Minimum USD liquidity of the token's deepest known pool. */\n    minLiquidityUsd: z.number().min(0).max(1e12).optional(),\n    /** Maximum USD liquidity of the token's deepest known pool. */\n    maxLiquidityUsd: z.number().min(0).max(1e12).optional(),\n    /** Watchlist. When non-empty, only these tokens match. */\n    tokens: z.array(addressSchema).max(500).default([]),\n    /** Deployer watchlist. When non-empty, only these actors match. */\n    deployers: z.array(addressSchema).max(500).default([]),\n    /** Deployers to always reject, applied after every other filter. */\n    excludeDeployers: z.array(addressSchema).max(500).default([]),\n    /** Trade direction. Ignored by `launch` and `graduation` events. */\n    side: sideSchema.default('any'),\n    reputation: reputationFilterSchema.optional(),\n    rateLimit: rateLimitSchema.optional(),\n  })\n  .strict()\n  .refine((rule) => rule.minUsd === undefined || rule.maxUsd === undefined || rule.minUsd <= rule.maxUsd, {\n    message: 'minUsd must not exceed maxUsd',\n    path: ['minUsd'],\n  })\n  .refine(\n    (rule) =>\n      rule.minLiquidityUsd === undefined ||\n      rule.maxLiquidityUsd === undefined ||\n      rule.minLiquidityUsd <= rule.maxLiquidityUsd,\n    { message: 'minLiquidityUsd must not exceed maxLiquidityUsd', path: ['minLiquidityUsd'] },\n  )\n  .refine((rule) => rule.kinds.some((kind) => rule.launchpads.some((pad) => canEmit(pad, kind))), {\n    message:\n      'this combination can never fire: NOXA is an instant launcher with no bonding curve, so it emits no curve_trade and no graduation',\n    path: ['kinds'],\n  })\n\n/** A validated rule. */\nexport type Rule = z.output<typeof ruleSchema>\n/** A rule as accepted on input, before defaults are applied. */\nexport type RuleInput = z.input<typeof ruleSchema>\n/** Validated reputation filter. */\nexport type ReputationFilter = z.output<typeof reputationFilterSchema>\n/** Validated rate limit block. */\nexport type RateLimitConfig = z.output<typeof rateLimitSchema>\n\n/** Delivery platforms a subscription can target. */\nexport const platformSchema = z.enum(['telegram', 'discord'])\n/** A delivery platform. */\nexport type Platform = z.output<typeof platformSchema>\n\n/** A subscription: one delivery target plus the rules that feed it. */\nexport const subscriptionSchema = z\n  .object({\n    id: z.string().min(1).max(64),\n    /**\n     * The account that owns this subscription, and the unit entitlements are\n     * checked against. For Telegram this is the user id, for Discord the guild\n     * id (a server pays once for its channels) or user id for a DM.\n     */\n    subscriberId: z.string().min(1).max(128),\n    platform: platformSchema,\n    /**\n     * Where alerts go: a Telegram chat id, a Discord channel id, or a Discord\n     * webhook URL. Validated per platform by the notifier, not here, because\n     * the same subscription record serves all three shapes.\n     */\n    target: z.string().min(1).max(512),\n    enabled: z.boolean().default(true),\n    rules: z.array(ruleSchema).max(100).default([]),\n    createdAtMs: z.number().int().nonnegative(),\n  })\n  .strict()\n  .refine((sub) => new Set(sub.rules.map((rule) => rule.id)).size === sub.rules.length, {\n    message: 'rule ids must be unique within a subscription',\n    path: ['rules'],\n  })\n\n/** A validated subscription. */\nexport type Subscription = z.output<typeof subscriptionSchema>\n/** A subscription as accepted on input. */\nexport type SubscriptionInput = z.input<typeof subscriptionSchema>\n\n/** Can a launchpad emit this event kind at all? */\nexport function canEmit(launchpad: Launchpad, kind: AlertEventKind): boolean {\n  return LAUNCHPAD_EVENT_KINDS[launchpad].includes(kind)\n}\n\n/**\n * How many filters a rule actually uses. The tier policy caps this so free\n * subscribers get real filtering without turning the service into an unpaid\n * on-chain query engine.\n */\nexport function ruleComplexity(rule: Rule): number {\n  let score = 0\n  if (rule.minUsd !== undefined) score += 1\n  if (rule.maxUsd !== undefined) score += 1\n  if (rule.minLiquidityUsd !== undefined) score += 1\n  if (rule.maxLiquidityUsd !== undefined) score += 1\n  if (rule.tokens.length > 0) score += 1\n  if (rule.deployers.length > 0) score += 1\n  if (rule.excludeDeployers.length > 0) score += 1\n  if (rule.side !== 'any') score += 1\n  if (rule.reputation) score += Object.values(rule.reputation).filter((v) => v !== undefined).length\n  if (rule.rateLimit) score += 1\n  return score\n}\n\n/** Filters that cost an extra on-chain read per candidate event. */\nexport function usesOnChainLookups(rule: Rule): boolean {\n  return (\n    rule.minLiquidityUsd !== undefined ||\n    rule.maxLiquidityUsd !== undefined ||\n    (rule.reputation !== undefined &&\n      Object.values(rule.reputation).some((value) => value !== undefined))\n  )\n}\n\n/**\n * Parse and validate a rule, applying defaults.\n *\n * @throws {@link z.ZodError} with a field-level message the bot renders back\n * to the user verbatim.\n *\n * @example\n * ```ts\n * const rule = parseRule({ id: 'whales', kinds: ['whale_trade'], minUsd: 5000 })\n * console.log(rule.launchpads) // ['noxa', 'odyssey'] (defaulted)\n * ```\n */\nexport function parseRule(input: unknown): Rule {\n  return ruleSchema.parse(input)\n}\n\n/** Non-throwing {@link parseRule}. */\nexport function safeParseRule(input: unknown): z.ZodSafeParseResult<Rule> {\n  return ruleSchema.safeParse(input)\n}\n\n/** Parse and validate a subscription. */\nexport function parseSubscription(input: unknown): Subscription {\n  return subscriptionSchema.parse(input)\n}\n\n/** Non-throwing {@link parseSubscription}. */\nexport function safeParseSubscription(input: unknown): z.ZodSafeParseResult<Subscription> {\n  return subscriptionSchema.safeParse(input)\n}\n\n/**\n * Render a Zod error as one line of human-readable text, for bot replies.\n * A user who typed `/threshold abc` gets \"minUsd: expected number\", not a\n * stack trace and not a silent failure.\n */\nexport function formatValidationError(error: z.ZodError): string {\n  return error.issues\n    .map((issue) => {\n      const path = issue.path.join('.')\n      return path ? `${path}: ${issue.message}` : issue.message\n    })\n    .join('; ')\n}\n\n/** A ready-to-use starter rule set, used by `/subscribe` before any editing. */\nexport function defaultRules(): Rule[] {\n  return [\n    parseRule({ id: 'launches', name: 'New launches', kinds: ['launch'] }),\n    parseRule({\n      id: 'graduations',\n      name: 'Odyssey graduations',\n      kinds: ['graduation'],\n      launchpads: ['odyssey'],\n    }),\n    parseRule({ id: 'whales', name: 'Whale trades over $5k', kinds: ['whale_trade'], minUsd: 5000 }),\n  ]\n}\n","import type { Address, Hash } from 'viem'\n\n/**\n * The normalized alert event taxonomy for Robinhood Chain memecoins.\n *\n * Two launchpads run on mainnet (chain 4663) and they have genuinely\n * different lifecycles. The taxonomy models that difference instead of\n * pretending they are the same product:\n *\n * - **NOXA** (`fun.noxa.fi/robinhood`) is an *instant* launcher. One\n *   transaction deploys the ERC-20, creates a Uniswap v3 pool, seeds\n *   single-sided liquidity and locks the LP NFT. There is no bonding curve,\n *   so NOXA emits `launch` and (through its pool) `whale_trade`, and it can\n *   never emit `curve_trade` or `graduation`.\n * - **The Odyssey** (`theodyssey.fun`) is a pump.fun-style native-ETH bonding\n *   curve with virtual reserves. It emits `launch` when a curve opens,\n *   `curve_trade` for every buy/sell on the curve, and `graduation` when the\n *   curve fills and liquidity migrates to a locked Uniswap v3 pool. After\n *   graduation its tokens also produce `whale_trade` from the migrated pool.\n *\n * A `graduation` alert therefore covers The Odyssey only. Claiming NOXA\n * \"graduations\" would be describing an event that does not exist on chain.\n */\n\n/** Which launchpad an event originated from. */\nexport type Launchpad = 'noxa' | 'odyssey'\n\n/** The kinds of alert this package emits. */\nexport type AlertEventKind = 'launch' | 'curve_trade' | 'graduation' | 'whale_trade'\n\n/** Buy or sell, from the trader's perspective. */\nexport type TradeSide = 'buy' | 'sell'\n\n/** Explorer deep links attached to every event. */\nexport interface ExplorerLinks {\n  /** The transaction that produced the event. */\n  tx: string\n  /** The token contract. */\n  token: string\n  /** The actor (deployer or trader). */\n  actor: string\n  /** The Uniswap v3 pool, when the event has one. */\n  pool?: string\n}\n\n/** Fields every alert event carries. */\nexport interface AlertEventBase {\n  /**\n   * Stable, content-addressed identity for this event: `kind:txHash:logIndex`.\n   * Reprocessing the same block range regenerates the identical id, which is\n   * what makes the delivery dedupe table work across restarts and reorg\n   * re-reads.\n   */\n  id: string\n  kind: AlertEventKind\n  launchpad: Launchpad\n  /** The memecoin the event is about. */\n  token: Address\n  /** Token symbol read from the ERC-20, or `null` when the call reverts. */\n  symbol: string | null\n  /** Token name read from the ERC-20, or `null` when the call reverts. */\n  name: string | null\n  /** The wallet responsible: the deployer for launches, the trader for trades. */\n  actor: Address\n  blockNumber: bigint\n  logIndex: number\n  transactionHash: Hash\n  /**\n   * Block timestamp in milliseconds since epoch, or `null` when the event was\n   * decoded without a block fetch (the source fills it whenever available).\n   */\n  timestampMs: number | null\n  /**\n   * USD value of the event, or `null` when it cannot be derived from a real\n   * price source. Never guessed: launches carry the seeded/initial-buy value,\n   * trades carry the traded notional, and `null` means \"no USDG or WETH leg to\n   * price against\", which rules treat as \"does not satisfy a min-USD filter\".\n   */\n  usdValue: number | null\n  explorer: ExplorerLinks\n}\n\n/**\n * A new token launch.\n *\n * NOXA: decoded from `TokenLaunched` on the launch factory. `pool` is present\n * immediately and `initialBuyAmount` is the deployer's own first buy.\n * Odyssey: decoded from `TokenCreated` on a bonding-curve factory. `pool` is\n * `null` because the curve holds the liquidity until graduation.\n */\nexport interface LaunchEvent extends AlertEventBase {\n  kind: 'launch'\n  /** The Uniswap v3 pool, or `null` for an Odyssey token still on its curve. */\n  pool: Address | null\n  /** The quote token of the pool (NOXA only, `null` on Odyssey). */\n  pairToken: Address | null\n  /** Raw initial buy in the pair token's units (NOXA), else `0n`. */\n  initialBuyAmount: bigint\n  /**\n   * The Uniswap v3 LP position NFT minted for this launch (NOXA), or `null`\n   * when the launchpad did not mint one at launch time (every Odyssey token,\n   * whose LP appears at graduation). Reputation rules read its owner to prove\n   * the LP is locked.\n   */\n  positionId: bigint | null\n  /**\n   * `true` when this launchpad lists instantly with no bonding curve, so no\n   * `graduation` event will ever follow. Always `true` for NOXA. For Odyssey\n   * it is `true` only for launches from the instant factory variant.\n   */\n  instantListing: boolean\n}\n\n/**\n * A bonding-curve buy or sell. The Odyssey only: NOXA has no curve.\n * Decoded from `Traded` on an Odyssey factory.\n */\nexport interface CurveTradeEvent extends AlertEventBase {\n  kind: 'curve_trade'\n  launchpad: 'odyssey'\n  side: TradeSide\n  /** Token amount bought or sold, raw (18 decimals). */\n  tokenAmount: bigint\n  /** Native ETH paid or received, in wei. */\n  quoteAmountWei: bigint\n  /** Protocol fee taken on this trade, in wei. */\n  feeWei: bigint\n  /** Curve virtual quote reserve after the trade, in wei. */\n  virtualQuoteWei: bigint\n  /** Curve virtual token reserve after the trade, raw. */\n  virtualTokenAmount: bigint\n  /** Price of one token in ETH implied by this fill, or `null` for a zero-size fill. */\n  priceEth: number | null\n}\n\n/**\n * A curve that filled and migrated to a locked Uniswap v3 pool.\n * The Odyssey only. Decoded from `PoolMigrated`.\n */\nexport interface GraduationEvent extends AlertEventBase {\n  kind: 'graduation'\n  launchpad: 'odyssey'\n  /** The Uniswap v3 pool liquidity migrated into. */\n  pool: Address\n  /** The position manager token id holding the migrated liquidity. */\n  positionId: bigint\n  /** Uniswap v3 liquidity units minted at migration. */\n  liquidity: bigint\n  /** Token side used to seed the pool, raw. */\n  tokenUsed: bigint\n  /** Quote side used to seed the pool, raw (6 decimals when the quote is USDG). */\n  quoteUsed: bigint\n}\n\n/**\n * A Uniswap v3 swap on a memecoin pool above the configured USD threshold.\n * Both launchpads produce these: NOXA from block one, Odyssey after\n * graduation.\n */\nexport interface WhaleTradeEvent extends AlertEventBase {\n  kind: 'whale_trade'\n  pool: Address\n  /** The pool's quote token (the non-memecoin side). */\n  quoteToken: Address\n  /** Quote token symbol, e.g. `WETH` or `USDG`. */\n  quoteSymbol: string\n  side: TradeSide\n  /** Memecoin amount that moved, in human units. */\n  tokenAmount: number\n  /** Quote amount that moved, in human units. */\n  quoteAmount: number\n  /** Executed price of the memecoin in quote-token units. */\n  price: number\n  /** Uniswap v3 fee tier of the pool, in hundredths of a bip (3000 = 0.3%). */\n  feeTier: number\n}\n\n/** Any normalized alert event. */\nexport type AlertEvent = LaunchEvent | CurveTradeEvent | GraduationEvent | WhaleTradeEvent\n\n/** Narrow an event to a kind. */\nexport function isKind<K extends AlertEventKind>(\n  event: AlertEvent,\n  kind: K,\n): event is Extract<AlertEvent, { kind: K }> {\n  return event.kind === kind\n}\n\n/**\n * Human-readable one-line label for an event kind, used by the bot and the\n * notifier formatters.\n */\nexport const EVENT_KIND_LABELS: Record<AlertEventKind, string> = {\n  launch: 'New launch',\n  curve_trade: 'Curve trade',\n  graduation: 'Graduation',\n  whale_trade: 'Whale trade',\n}\n\n/**\n * Which event kinds each launchpad can actually produce. The rule engine uses\n * this to reject impossible rules (for example: Odyssey-only `graduation`\n * combined with a NOXA-only launchpad filter would never fire).\n */\nexport const LAUNCHPAD_EVENT_KINDS: Record<Launchpad, readonly AlertEventKind[]> = {\n  noxa: ['launch', 'whale_trade'],\n  odyssey: ['launch', 'curve_trade', 'graduation', 'whale_trade'],\n}\n","import type { AlertEventKind } from '../events/types.js'\nimport { ruleComplexity, usesOnChainLookups, type Rule } from '../rules/schema.js'\n\n/**\n * Tiering, as an enforced policy layer rather than a marketing page.\n *\n * Every limit here exists because it maps to a real cost the service pays:\n *\n * - `maxSubscriptions` / `maxRulesPerSubscription` bound the per-event fan-out.\n * - `maxRuleComplexity` bounds how much work one rule can ask for.\n * - `allowOnChainLookupFilters` gates the filters that cost an RPC read per\n *   candidate event (liquidity, deployer reputation). This is the expensive\n *   one, so it is the clearest free/premium line.\n * - `maxAlertsPerHour` bounds delivery throughput.\n * - `deliveryDelayMs` is the latency difference. Free alerts are held briefly;\n *   premium alerts go out as soon as the block is confirmed. It is enforced in\n *   the outbox (the delivery row carries `not_before`), so it survives a\n *   restart instead of being a `setTimeout` that a crash erases.\n * - `allowedKinds` keeps the highest-volume stream (every bonding-curve trade)\n *   on the paid tier, because it is a firehose, not an alert.\n */\n\n/** The two tiers. */\nexport type Tier = 'free' | 'premium'\n\n/** What a tier is allowed to do. */\nexport interface TierPolicy {\n  tier: Tier\n  /** Max delivery targets one subscriber may have. */\n  maxSubscriptions: number\n  /** Max rules per subscription. */\n  maxRulesPerSubscription: number\n  /** Max {@link ruleComplexity} score for a single rule. */\n  maxRuleComplexity: number\n  /** Max entries in a rule's token or deployer watchlist. */\n  maxWatchlistTokens: number\n  /** Max alerts delivered per subscriber per rolling hour. */\n  maxAlertsPerHour: number\n  /** How long alerts are held before delivery, in ms. */\n  deliveryDelayMs: number\n  /** May rules use liquidity and reputation filters (each costs an RPC read). */\n  allowOnChainLookupFilters: boolean\n  /** Event kinds this tier may subscribe to. */\n  allowedKinds: readonly AlertEventKind[]\n}\n\n/** The shipped policy table. Override per deployment through the service config. */\nexport const TIER_POLICIES: Record<Tier, TierPolicy> = {\n  free: {\n    tier: 'free',\n    maxSubscriptions: 1,\n    maxRulesPerSubscription: 3,\n    maxRuleComplexity: 3,\n    maxWatchlistTokens: 5,\n    maxAlertsPerHour: 30,\n    deliveryDelayMs: 60_000,\n    allowOnChainLookupFilters: false,\n    allowedKinds: ['launch', 'graduation', 'whale_trade'],\n  },\n  premium: {\n    tier: 'premium',\n    maxSubscriptions: 10,\n    maxRulesPerSubscription: 50,\n    maxRuleComplexity: 24,\n    maxWatchlistTokens: 500,\n    maxAlertsPerHour: 2_000,\n    deliveryDelayMs: 0,\n    allowOnChainLookupFilters: true,\n    allowedKinds: ['launch', 'curve_trade', 'graduation', 'whale_trade'],\n  },\n}\n\n/** A policy decision. `allowed: false` always carries a user-facing reason. */\nexport interface PolicyDecision {\n  allowed: boolean\n  /** Present when `allowed` is false. Written to be shown to the subscriber. */\n  reason: string | null\n}\n\nconst OK: PolicyDecision = { allowed: true, reason: null }\nconst deny = (reason: string): PolicyDecision => ({ allowed: false, reason })\n\n/** May this subscriber add another subscription? */\nexport function canAddSubscription(policy: TierPolicy, currentCount: number): PolicyDecision {\n  if (currentCount >= policy.maxSubscriptions) {\n    return deny(\n      `the ${policy.tier} tier allows ${policy.maxSubscriptions} subscription${\n        policy.maxSubscriptions === 1 ? '' : 's'\n      } and you have ${currentCount}. Upgrade with /upgrade, or remove one with /unsubscribe.`,\n    )\n  }\n  return OK\n}\n\n/** May this rule be added to a subscription that already has `currentRuleCount` rules? */\nexport function canAddRule(\n  policy: TierPolicy,\n  rule: Rule,\n  currentRuleCount: number,\n): PolicyDecision {\n  if (currentRuleCount >= policy.maxRulesPerSubscription) {\n    return deny(\n      `the ${policy.tier} tier allows ${policy.maxRulesPerSubscription} rules per subscription and you have ${currentRuleCount}.`,\n    )\n  }\n  return isRuleAllowed(policy, rule)\n}\n\n/** Is this rule within the tier's limits, regardless of how many exist? */\nexport function isRuleAllowed(policy: TierPolicy, rule: Rule): PolicyDecision {\n  const disallowedKinds = rule.kinds.filter((kind) => !policy.allowedKinds.includes(kind))\n  if (disallowedKinds.length > 0) {\n    return deny(\n      `the ${policy.tier} tier does not include ${disallowedKinds.join(', ')} alerts. Allowed: ${policy.allowedKinds.join(', ')}.`,\n    )\n  }\n  const complexity = ruleComplexity(rule)\n  if (complexity > policy.maxRuleComplexity) {\n    return deny(\n      `this rule uses ${complexity} filters and the ${policy.tier} tier allows ${policy.maxRuleComplexity}.`,\n    )\n  }\n  if (rule.tokens.length > policy.maxWatchlistTokens) {\n    return deny(\n      `the ${policy.tier} tier allows ${policy.maxWatchlistTokens} watchlist tokens and this rule has ${rule.tokens.length}.`,\n    )\n  }\n  if (rule.deployers.length + rule.excludeDeployers.length > policy.maxWatchlistTokens) {\n    return deny(\n      `the ${policy.tier} tier allows ${policy.maxWatchlistTokens} watched deployers per rule.`,\n    )\n  }\n  if (!policy.allowOnChainLookupFilters && usesOnChainLookups(rule)) {\n    return deny(\n      `liquidity and deployer-reputation filters are a premium feature: each one costs an on-chain read per candidate event.`,\n    )\n  }\n  return OK\n}\n\n/** Resolve the policy for a tier. */\nexport function policyFor(tier: Tier, overrides?: Partial<Record<Tier, Partial<TierPolicy>>>): TierPolicy {\n  const base = TIER_POLICIES[tier]\n  const override = overrides?.[tier]\n  return override ? { ...base, ...override, tier } : base\n}\n","import { getAddress, verifyMessage, type Address } from 'viem'\nimport { USDG_DECIMALS, erc20Abi, type HoodClient } from 'hoodchain'\nimport { formatUnits } from 'viem'\nimport { fetchLogRange, type FetchLogRangeOptions } from '../events/logs.js'\nimport type { Tier } from './policy.js'\n\n/**\n * Entitlements: who is premium, and why.\n *\n * The service resolves a subscriber's tier through exactly one interface, so\n * there is a single place to audit and a single place to swap the commercial\n * model. Two implementations ship:\n *\n * 1. {@link createStaticEntitlementProvider} is the documented default. Premium\n *    subscribers come from configuration (`PREMIUM_SUBSCRIBERS` in the\n *    environment). It has no dependencies, works offline, and is what a\n *    self-hoster running the bot for their own community wants.\n * 2. {@link createUsdgEntitlementProvider} is a working on-chain rail. It reads\n *    USDG `Transfer` logs to the operator's receiving address from a wallet\n *    the subscriber has linked, and accrues subscription time from those real\n *    payments. It needs no facilitator, no card processor and no third-party\n *    service: USDG is the chain's own dollar and the ledger is the chain.\n *\n * Wallet linking is signature-verified (EIP-191 `personal_sign` over a\n * server-issued nonce), so a subscriber cannot claim someone else's payments\n * by pasting their address.\n */\n\n/** A resolved entitlement. */\nexport interface Entitlement {\n  subscriberId: string\n  tier: Tier\n  /** When premium lapses, ms since epoch. `null` for free or for a permanent grant. */\n  expiresAtMs: number | null\n  /** Which provider decided this, for support and for `/tier`. */\n  source: string\n}\n\n/** The single entitlement chokepoint. */\nexport interface EntitlementProvider {\n  /** Resolve a subscriber's tier. Must never throw: fall back to free. */\n  get(subscriberId: string): Promise<Entitlement>\n}\n\nconst free = (subscriberId: string, source: string): Entitlement => ({\n  subscriberId,\n  tier: 'free',\n  expiresAtMs: null,\n  source,\n})\n\n/**\n * Configuration-driven entitlements: the documented default.\n *\n * @example\n * ```ts\n * const entitlements = createStaticEntitlementProvider({\n *   premiumSubscribers: ['telegram:12345', 'discord:987654321'],\n * })\n * ```\n */\nexport function createStaticEntitlementProvider(options: {\n  premiumSubscribers?: readonly string[]\n  /** Treat everyone as premium. For a private self-hosted deployment. */\n  allPremium?: boolean\n}): EntitlementProvider {\n  const premium = new Set((options.premiumSubscribers ?? []).map((id) => id.trim()).filter(Boolean))\n  return {\n    async get(subscriberId: string): Promise<Entitlement> {\n      if (options.allPremium === true || premium.has(subscriberId)) {\n        return { subscriberId, tier: 'premium', expiresAtMs: null, source: 'static' }\n      }\n      return free(subscriberId, 'static')\n    },\n  }\n}\n\n/** Lookup of the wallet a subscriber has verifiably linked. */\nexport interface WalletLinkStore {\n  /** The linked, signature-verified wallet for a subscriber, or `null`. */\n  walletOf(subscriberId: string): Promise<Address | null>\n}\n\n/** Options for {@link createUsdgEntitlementProvider}. */\nexport interface UsdgEntitlementOptions {\n  client: HoodClient\n  /** The operator's receiving address. Payments to any other address are ignored. */\n  receiver: Address\n  /** Price of one subscription period, in whole USDG. */\n  pricePerPeriodUsdg: number\n  /** Length of a period in days. @defaultValue `30` */\n  periodDays?: number\n  /** Where verified wallet links come from. */\n  links: WalletLinkStore\n  /** First block to scan for payments. @defaultValue `0n` */\n  fromBlock?: bigint\n  /** Cache lifetime per subscriber, in ms. @defaultValue `300_000` (5 minutes) */\n  ttlMs?: number\n  /** Retry/bisect options for the payment scan. */\n  logOptions?: FetchLogRangeOptions\n  /** Clock injection point for tests. @defaultValue `Date.now` */\n  now?: () => number\n}\n\nconst transferEvent = {\n  type: 'event',\n  name: 'Transfer',\n  inputs: [\n    { name: 'from', type: 'address', indexed: true },\n    { name: 'to', type: 'address', indexed: true },\n    { name: 'value', type: 'uint256', indexed: false },\n  ],\n} as const\n\n/**\n * Accrue an expiry from a payment history. Each payment buys\n * `floor(amount / price)` periods, starting from whenever the current\n * entitlement would have lapsed, so renewing early extends rather than\n * overwrites.\n *\n * Exported because it is the part worth testing on its own: everything else in\n * the provider is a log query.\n */\nexport function accrueExpiry(\n  payments: readonly { atMs: number; amountUsdg: number }[],\n  pricePerPeriodUsdg: number,\n  periodDays: number,\n): number | null {\n  if (pricePerPeriodUsdg <= 0) return null\n  const periodMs = periodDays * 86_400_000\n  const ordered = [...payments].sort((a, b) => a.atMs - b.atMs)\n  let expiry: number | null = null\n  for (const payment of ordered) {\n    const periods = Math.floor(payment.amountUsdg / pricePerPeriodUsdg)\n    if (periods < 1) continue\n    const start: number = expiry !== null && expiry > payment.atMs ? expiry : payment.atMs\n    expiry = start + periods * periodMs\n  }\n  return expiry\n}\n\n/**\n * On-chain USDG entitlements.\n *\n * @example\n * ```ts\n * const entitlements = createUsdgEntitlementProvider({\n *   client: hood,\n *   receiver: '0xYourReceivingAddress',\n *   pricePerPeriodUsdg: 25,\n *   links: store,           // the service's SQLite store implements WalletLinkStore\n * })\n * const entitlement = await entitlements.get('telegram:12345')\n * ```\n */\nexport function createUsdgEntitlementProvider(options: UsdgEntitlementOptions): EntitlementProvider {\n  const ttlMs = options.ttlMs ?? 300_000\n  const now = options.now ?? Date.now\n  const periodDays = options.periodDays ?? 30\n  const usdg =\n    options.client.network === 'testnet'\n      ? '0x7E955252E15c84f5768B83c41a71F9eba181802F'\n      : '0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168'\n  const cache = new Map<string, { entitlement: Entitlement; at: number }>()\n\n  async function resolve(subscriberId: string): Promise<Entitlement> {\n    const wallet = await options.links.walletOf(subscriberId)\n    if (!wallet) return free(subscriberId, 'usdg:no-linked-wallet')\n\n    const head = await options.client.public.getBlockNumber()\n    const logs = await fetchLogRange(\n      (from, to) =>\n        options.client.public.getLogs({\n          address: usdg as Address,\n          event: transferEvent,\n          args: { from: wallet, to: getAddress(options.receiver) },\n          fromBlock: from,\n          toBlock: to,\n        }),\n      options.fromBlock ?? 0n,\n      head,\n      options.logOptions ?? {},\n    )\n    if (logs.length === 0) return free(subscriberId, 'usdg:no-payments')\n\n    const payments: { atMs: number; amountUsdg: number }[] = []\n    for (const log of logs) {\n      const value = log.args.value as bigint | undefined\n      if (value === undefined || value === 0n) continue\n      const block = await options.client.public.getBlock({\n        blockNumber: log.blockNumber,\n        includeTransactions: false,\n      })\n      payments.push({\n        atMs: Number(block.timestamp) * 1000,\n        amountUsdg: Number(formatUnits(value, USDG_DECIMALS)),\n      })\n    }\n\n    const expiresAtMs = accrueExpiry(payments, options.pricePerPeriodUsdg, periodDays)\n    if (expiresAtMs === null || expiresAtMs <= now()) {\n      return { subscriberId, tier: 'free', expiresAtMs, source: 'usdg:lapsed' }\n    }\n    return { subscriberId, tier: 'premium', expiresAtMs, source: 'usdg' }\n  }\n\n  return {\n    async get(subscriberId: string): Promise<Entitlement> {\n      const hit = cache.get(subscriberId)\n      if (hit && now() - hit.at < ttlMs) return hit.entitlement\n      try {\n        const entitlement = await resolve(subscriberId)\n        cache.set(subscriberId, { entitlement, at: now() })\n        return entitlement\n      } catch (error) {\n        // An RPC failure must never silently downgrade a paying subscriber to\n        // free with no explanation, and must never upgrade a free one. Serve\n        // the last known answer if there is one, otherwise free with a source\n        // that says exactly what happened.\n        if (hit) return hit.entitlement\n        const message = error instanceof Error ? error.message : String(error)\n        return free(subscriberId, `usdg:unavailable (${message})`)\n      }\n    },\n  }\n}\n\n/**\n * Chain several providers: the first one that returns premium wins. Lets an\n * operator grant comps by configuration while still selling on chain.\n */\nexport function chainEntitlementProviders(\n  ...providers: readonly EntitlementProvider[]\n): EntitlementProvider {\n  return {\n    async get(subscriberId: string): Promise<Entitlement> {\n      let last: Entitlement = free(subscriberId, 'chain:empty')\n      for (const provider of providers) {\n        const entitlement = await provider.get(subscriberId)\n        if (entitlement.tier === 'premium') return entitlement\n        last = entitlement\n      }\n      return last\n    },\n  }\n}\n\n/** The message a subscriber signs to link a wallet. */\nexport function linkMessage(subscriberId: string, nonce: string): string {\n  return `hood-alerts wallet link\\nsubscriber: ${subscriberId}\\nnonce: ${nonce}`\n}\n\n/**\n * Verify a wallet link signature (EIP-191 `personal_sign`).\n *\n * The subscriber signs {@link linkMessage} with the wallet that pays, and the\n * service checks the signature before storing the link. Without this step,\n * anyone could paste a paying subscriber's address and inherit their\n * entitlement.\n *\n * @returns the checksummed address on success, `null` on any failure (bad\n * signature shape, wrong signer, malformed address).\n *\n * @example\n * ```ts\n * const nonce = crypto.randomUUID()\n * // the user signs linkMessage('telegram:12345', nonce) in their wallet\n * const address = await verifyWalletLink('telegram:12345', nonce, wallet, signature)\n * if (address) await store.linkWallet('telegram:12345', address)\n * ```\n */\nexport async function verifyWalletLink(\n  subscriberId: string,\n  nonce: string,\n  address: string,\n  signature: string,\n): Promise<Address | null> {\n  if (!/^0x[0-9a-fA-F]{130}$/.test(signature)) return null\n  if (!/^0x[0-9a-fA-F]{40}$/.test(address)) return null\n  try {\n    const valid = await verifyMessage({\n      address: getAddress(address),\n      message: linkMessage(subscriberId, nonce),\n      signature: signature as `0x${string}`,\n    })\n    return valid ? getAddress(address) : null\n  } catch {\n    return null\n  }\n}\n","import type { Address } from 'viem'\n\n/**\n * Resilient log fetching for Robinhood Chain's public RPC.\n *\n * Two behaviours of the public endpoint drive this helper, both measured\n * against `https://rpc.mainnet.chain.robinhood.com` while building this\n * package:\n *\n * 1. **There is no block-range cap, but there is a 10,000-log result cap.**\n *    A query spanning millions of blocks succeeds if it is selective enough\n *    (the three Odyssey factories return every log they ever emitted in one\n *    call); a query spanning 2,000 blocks fails with\n *    `logs matched by query exceeds limit of 10000` if it is not (a topic-only\n *    Uniswap v3 `Swap` query does). Fixed-size range chunking therefore\n *    cannot guarantee success, so {@link fetchLogRange} bisects the range on\n *    that specific error until each half fits.\n * 2. **It rate limits bursts with `Too Many Requests`.** Those are retried\n *    with exponential backoff rather than surfaced, because a retryable 429\n *    must never advance a caller's block cursor.\n */\n\n/** Options for {@link fetchLogRange}. */\nexport interface FetchLogRangeOptions {\n  /**\n   * Smallest range the bisector will produce. A single block that still\n   * overflows the result cap throws, because there is nothing left to split.\n   * @defaultValue `1n`\n   */\n  minSpan?: bigint\n  /** Retries for rate-limit and transient transport errors. @defaultValue `5` */\n  retries?: number\n  /** Base backoff in ms, doubled per attempt. @defaultValue `500` */\n  backoffMs?: number\n  /** Sleep injection point for tests. @defaultValue a real timer */\n  sleep?: (ms: number) => Promise<void>\n}\n\nconst defaultSleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms))\n\n/** `true` when the RPC rejected the query for returning too many logs. */\nexport function isResultTooLarge(error: unknown): boolean {\n  const message = error instanceof Error ? error.message : String(error)\n  return /exceeds limit|too many results|response size exceeded|query returned more than/i.test(message)\n}\n\n/** `true` when the error is a transient rate limit or timeout worth retrying. */\nexport function isRetryableRpcError(error: unknown): boolean {\n  const message = error instanceof Error ? error.message : String(error)\n  return /too many requests|rate limit|timed out|timeout|429|503|502|ECONNRESET|socket hang up|fetch failed/i.test(\n    message,\n  )\n}\n\n/**\n * Fetch logs for `[from, to]` inclusive through `fetcher`, bisecting the range\n * when the RPC reports too many results and retrying transient failures.\n *\n * @throws the underlying error when a single block still overflows the result\n * cap, or when retries are exhausted. Callers must treat a throw as \"range not\n * processed\" and leave their cursor untouched.\n *\n * @example\n * ```ts\n * const logs = await fetchLogRange(\n *   (from, to) => hood.public.getLogs({ address: factory, event, fromBlock: from, toBlock: to }),\n *   0n,\n *   await hood.public.getBlockNumber(),\n * )\n * ```\n */\nexport async function fetchLogRange<T>(\n  fetcher: (from: bigint, to: bigint) => Promise<readonly T[]>,\n  from: bigint,\n  to: bigint,\n  options: FetchLogRangeOptions = {},\n): Promise<T[]> {\n  const minSpan = options.minSpan ?? 1n\n  const retries = options.retries ?? 5\n  const backoffMs = options.backoffMs ?? 500\n  const sleep = options.sleep ?? defaultSleep\n\n  const run = async (lo: bigint, hi: bigint): Promise<T[]> => {\n    let attempt = 0\n    for (;;) {\n      try {\n        return [...(await fetcher(lo, hi))]\n      } catch (error) {\n        if (isResultTooLarge(error)) {\n          const span = hi - lo\n          if (span < minSpan || span === 0n) throw error\n          const mid = lo + span / 2n\n          const left = await run(lo, mid)\n          const right = await run(mid + 1n, hi)\n          return [...left, ...right]\n        }\n        if (isRetryableRpcError(error) && attempt < retries) {\n          await sleep(backoffMs * 2 ** attempt)\n          attempt += 1\n          continue\n        }\n        throw error\n      }\n    }\n  }\n\n  if (to < from) return []\n  return run(from, to)\n}\n\n/**\n * Split a list of addresses into query-sized batches. The RPC accepts long\n * address arrays, but batching keeps any single response under the result cap\n * and keeps one failing batch from invalidating the whole set.\n */\nexport function batchAddresses(addresses: readonly Address[], size = 200): Address[][] {\n  const batches: Address[][] = []\n  for (let i = 0; i < addresses.length; i += size) {\n    batches.push(addresses.slice(i, i + size) as Address[])\n  }\n  return batches\n}\n","import type { Rule } from '../rules/schema.js'\nimport type { Entitlement, EntitlementProvider } from './entitlements.js'\nimport {\n  canAddRule,\n  canAddSubscription,\n  isRuleAllowed,\n  policyFor,\n  type PolicyDecision,\n  type Tier,\n  type TierPolicy,\n} from './policy.js'\n\n/**\n * The entitlement chokepoint.\n *\n * Every tier question in the codebase goes through this object: the bot asks\n * it before accepting a subscription or a rule, and the dispatcher asks it\n * before queuing a delivery. Nothing else reads {@link TIER_POLICIES}\n * directly. One place to audit, one place to change the commercial model, no\n * chance of the bot and the dispatcher disagreeing about who is premium.\n */\nexport interface EntitlementGate {\n  /** Resolve tier, policy and expiry for a subscriber. */\n  resolve(subscriberId: string): Promise<{ entitlement: Entitlement; policy: TierPolicy }>\n  /** May they add another subscription? */\n  checkAddSubscription(subscriberId: string, currentCount: number): Promise<PolicyDecision>\n  /** May they add this rule to a subscription with `currentRuleCount` rules? */\n  checkAddRule(subscriberId: string, rule: Rule, currentRuleCount: number): Promise<PolicyDecision>\n  /** Is this rule within their tier, ignoring counts (used when editing)? */\n  checkRule(subscriberId: string, rule: Rule): Promise<PolicyDecision>\n  /** How long a delivery for this subscriber is held before sending, in ms. */\n  deliveryDelayMs(subscriberId: string): Promise<number>\n  /** Have they exhausted their hourly delivery budget? */\n  checkThroughput(subscriberId: string, deliveredInLastHour: number): Promise<PolicyDecision>\n}\n\n/** Options for {@link createEntitlementGate}. */\nexport interface EntitlementGateOptions {\n  provider: EntitlementProvider\n  /** Per-deployment overrides of the shipped tier table. */\n  policyOverrides?: Partial<Record<Tier, Partial<TierPolicy>>>\n}\n\n/** Build the gate. */\nexport function createEntitlementGate(options: EntitlementGateOptions): EntitlementGate {\n  async function resolve(\n    subscriberId: string,\n  ): Promise<{ entitlement: Entitlement; policy: TierPolicy }> {\n    const entitlement = await options.provider.get(subscriberId)\n    return { entitlement, policy: policyFor(entitlement.tier, options.policyOverrides) }\n  }\n\n  return {\n    resolve,\n    async checkAddSubscription(subscriberId: string, currentCount: number): Promise<PolicyDecision> {\n      const { policy } = await resolve(subscriberId)\n      return canAddSubscription(policy, currentCount)\n    },\n    async checkAddRule(\n      subscriberId: string,\n      rule: Rule,\n      currentRuleCount: number,\n    ): Promise<PolicyDecision> {\n      const { policy } = await resolve(subscriberId)\n      return canAddRule(policy, rule, currentRuleCount)\n    },\n    async checkRule(subscriberId: string, rule: Rule): Promise<PolicyDecision> {\n      const { policy } = await resolve(subscriberId)\n      return isRuleAllowed(policy, rule)\n    },\n    async deliveryDelayMs(subscriberId: string): Promise<number> {\n      const { policy } = await resolve(subscriberId)\n      return policy.deliveryDelayMs\n    },\n    async checkThroughput(\n      subscriberId: string,\n      deliveredInLastHour: number,\n    ): Promise<PolicyDecision> {\n      const { policy } = await resolve(subscriberId)\n      if (deliveredInLastHour >= policy.maxAlertsPerHour) {\n        return {\n          allowed: false,\n          reason: `hourly alert cap reached (${policy.maxAlertsPerHour} on the ${policy.tier} tier)`,\n        }\n      }\n      return { allowed: true, reason: null }\n    },\n  }\n}\n"],"mappings":"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","names":["import_viem"]}