hood-alerts 0.1.0

package/dist/rules/index.cjs

@@ -0,0 +1,614 @@
+"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/rules/index.ts
+var rules_exports = {};
+__export(rules_exports, {
+  addressSchema: () => addressSchema,
+  canEmit: () => canEmit,
+  checkRateLimit: () => checkRateLimit,
+  createMemoryRateLimitStore: () => createMemoryRateLimitStore,
+  createRpcReputationProvider: () => createRpcReputationProvider,
+  defaultRules: () => defaultRules,
+  evaluateRule: () => evaluateRule,
+  eventKindSchema: () => eventKindSchema,
+  formatValidationError: () => formatValidationError,
+  launchpadSchema: () => launchpadSchema,
+  matchRules: () => matchRules,
+  parseRule: () => parseRule,
+  parseSubscription: () => parseSubscription,
+  platformSchema: () => platformSchema,
+  priorLaunchesBefore: () => priorLaunchesBefore,
+  rateLimitKey: () => rateLimitKey,
+  rateLimitSchema: () => rateLimitSchema,
+  reputationFilterSchema: () => reputationFilterSchema,
+  ruleComplexity: () => ruleComplexity,
+  ruleSchema: () => ruleSchema,
+  safeParseRule: () => safeParseRule,
+  safeParseSubscription: () => safeParseSubscription,
+  sideSchema: () => sideSchema,
+  subscriptionSchema: () => subscriptionSchema,
+  usesOnChainLookups: () => usesOnChainLookups
+});
+module.exports = __toCommonJS(rules_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);
+}
+function parseRule(input) {
+  return ruleSchema.parse(input);
+}
+function safeParseRule(input) {
+  return ruleSchema.safeParse(input);
+}
+function parseSubscription(input) {
+  return subscriptionSchema.parse(input);
+}
+function safeParseSubscription(input) {
+  return subscriptionSchema.safeParse(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/rules/reputation.ts
+var import_viem2 = require("viem");
+var import_hoodchain2 = require("hoodchain");
+
+// src/events/logs.ts
+var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function isResultTooLarge(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /exceeds limit|too many results|response size exceeded|query returned more than/i.test(message);
+}
+function isRetryableRpcError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /too many requests|rate limit|timed out|timeout|429|503|502|ECONNRESET|socket hang up|fetch failed/i.test(
+    message
+  );
+}
+async function fetchLogRange(fetcher, from, to, options = {}) {
+  const minSpan = options.minSpan ?? 1n;
+  const retries = options.retries ?? 5;
+  const backoffMs = options.backoffMs ?? 500;
+  const 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/events/pricing.ts
+var import_viem = require("viem");
+var import_hoodchain = require("hoodchain");
+function quoteTokens(client) {
+  return client.network === "testnet" ? { weth: import_hoodchain.TESTNET_ADDRESSES.weth, usdg: import_hoodchain.TESTNET_ADDRESSES.usdg } : { weth: import_hoodchain.MAINNET_ADDRESSES.weth, usdg: import_hoodchain.MAINNET_ADDRESSES.usdg };
+}
+
+// src/rules/reputation.ts
+var positionManagerAbi = [
+  {
+    type: "function",
+    name: "ownerOf",
+    stateMutability: "view",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ type: "address" }]
+  }
+];
+var ODYSSEY_FACTORIES = [
+  import_hoodchain2.ODYSSEY_ADDRESSES.bondingCurveFactory,
+  import_hoodchain2.ODYSSEY_ADDRESSES.reflectionFactory,
+  import_hoodchain2.ODYSSEY_ADDRESSES.instantFactory
+];
+function createRpcReputationProvider(client, oracle, options = {}) {
+  const ttlMs = options.ttlMs ?? 6e5;
+  const maxHistory = options.maxHistory ?? 200;
+  const maxInspect = options.maxInspect ?? 25;
+  const rugThresholdUsd = options.rugThresholdUsd ?? 50;
+  const now = options.now ?? Date.now;
+  const cache = /* @__PURE__ */ new Map();
+  const inflight = /* @__PURE__ */ new Map();
+  const lockCache = /* @__PURE__ */ new Map();
+  const { weth, usdg } = quoteTokens(client);
+  async function reserveUsd(pool, quoteToken) {
+    const quote = quoteToken.toLowerCase();
+    if (quote !== weth.toLowerCase() && quote !== usdg.toLowerCase()) return null;
+    const balance = await client.public.readContract({
+      address: quoteToken,
+      abi: import_hoodchain2.erc20Abi,
+      functionName: "balanceOf",
+      args: [pool]
+    });
+    if (quote === usdg.toLowerCase()) return Number((0, import_viem2.formatUnits)(balance, import_hoodchain2.USDG_DECIMALS));
+    return oracle.weiToUsd(balance);
+  }
+  async function isLpLocked(positionId) {
+    const key = positionId.toString();
+    const hit = lockCache.get(key);
+    if (hit !== void 0) return hit;
+    try {
+      const owner = await client.public.readContract({
+        address: import_hoodchain2.MAINNET_ADDRESSES.nonfungiblePositionManager,
+        abi: positionManagerAbi,
+        functionName: "ownerOf",
+        args: [positionId]
+      });
+      const locked = owner.toLowerCase() === import_hoodchain2.NOXA_ADDRESSES.locker.toLowerCase();
+      lockCache.set(key, locked);
+      return locked;
+    } catch {
+      return false;
+    }
+  }
+  async function load(deployer) {
+    const head = await client.public.getBlockNumber();
+    const [noxaLogs, odysseyLogs] = await Promise.all([
+      fetchLogRange(
+        (from, to) => client.public.getLogs({
+          address: import_hoodchain2.NOXA_ADDRESSES.launchFactory,
+          event: import_hoodchain2.noxaTokenLaunchedEvent,
+          args: { deployer },
+          fromBlock: from,
+          toBlock: to
+        }),
+        import_hoodchain2.NOXA_ADDRESSES.deployBlock,
+        head,
+        options.logOptions ?? {}
+      ),
+      fetchLogRange(
+        (from, to) => client.public.getLogs({
+          address: ODYSSEY_FACTORIES,
+          event: import_hoodchain2.odysseyTokenCreatedEvent,
+          args: { creator: deployer },
+          fromBlock: from,
+          toBlock: to
+        }),
+        import_hoodchain2.NOXA_ADDRESSES.deployBlock,
+        head,
+        options.logOptions ?? {}
+      )
+    ]);
+    const launches = [];
+    for (const log of noxaLogs) {
+      const token = log.args.token;
+      if (!token) continue;
+      const pool = log.args.pool ?? null;
+      const pairToken = log.args.pairToken ?? null;
+      launches.push({
+        launchpad: "noxa",
+        token: (0, import_viem2.getAddress)(token),
+        pool: pool ? (0, import_viem2.getAddress)(pool) : null,
+        quoteToken: pairToken ? (0, import_viem2.getAddress)(pairToken) : null,
+        positionId: log.args.positionId ?? null,
+        blockNumber: log.blockNumber
+      });
+    }
+    for (const log of odysseyLogs) {
+      const token = log.args.token;
+      if (!token) continue;
+      launches.push({
+        launchpad: "odyssey",
+        token: (0, import_viem2.getAddress)(token),
+        pool: null,
+        quoteToken: null,
+        positionId: null,
+        blockNumber: log.blockNumber
+      });
+    }
+    launches.sort((a, b) => a.blockNumber < b.blockNumber ? -1 : a.blockNumber > b.blockNumber ? 1 : 0);
+    const kept = launches.slice(-maxHistory);
+    const inspectable = kept.slice(-maxInspect);
+    let lockedLaunches = 0;
+    let ruggedLaunches = 0;
+    for (const launch of inspectable) {
+      if (launch.positionId !== null && await isLpLocked(launch.positionId)) lockedLaunches += 1;
+      if (launch.pool && launch.quoteToken) {
+        try {
+          const usd = await reserveUsd(launch.pool, launch.quoteToken);
+          if (usd !== null && usd < rugThresholdUsd) ruggedLaunches += 1;
+        } catch {
+        }
+      }
+    }
+    return {
+      deployer: (0, import_viem2.getAddress)(deployer),
+      launches: kept,
+      lockedLaunches,
+      ruggedLaunches,
+      inspected: inspectable.length,
+      computedAtMs: now()
+    };
+  }
+  return {
+    async get(deployer) {
+      const key = deployer.toLowerCase();
+      const hit = cache.get(key);
+      if (hit && now() - hit.computedAtMs < ttlMs) return hit;
+      const pending = inflight.get(key);
+      if (pending) return pending;
+      const promise = load(deployer).then((record) => {
+        cache.set(key, record);
+        return record;
+      }).finally(() => {
+        inflight.delete(key);
+      });
+      inflight.set(key, promise);
+      return promise;
+    },
+    isLpLocked
+  };
+}
+function priorLaunchesBefore(record, blockNumber) {
+  return record.launches.filter((launch) => launch.blockNumber < blockNumber).length;
+}
+
+// src/rules/engine.ts
+var matchOk = (rule) => ({ matched: true, reason: `rule ${rule.id} matched` });
+var miss = (reason) => ({ matched: false, reason });
+function eventSide(event) {
+  if (event.kind === "curve_trade" || event.kind === "whale_trade") return event.side;
+  return null;
+}
+function eventPositionId(event) {
+  if (event.kind === "launch") return event.positionId;
+  if (event.kind === "graduation") return event.positionId;
+  return null;
+}
+async function evaluateRule(rule, event, context = {}) {
+  if (!rule.enabled) return miss(`rule ${rule.id} is disabled`);
+  if (!rule.kinds.includes(event.kind)) {
+    return miss(`kind ${event.kind} not in [${rule.kinds.join(", ")}]`);
+  }
+  if (!rule.launchpads.includes(event.launchpad)) {
+    return miss(`launchpad ${event.launchpad} not in [${rule.launchpads.join(", ")}]`);
+  }
+  const actor = event.actor.toLowerCase();
+  if (rule.excludeDeployers.includes(actor)) {
+    return miss(`actor ${event.actor} is on the exclude list`);
+  }
+  if (rule.tokens.length > 0 && !rule.tokens.includes(event.token.toLowerCase())) {
+    return miss(`token ${event.token} is not on the watchlist`);
+  }
+  if (rule.deployers.length > 0 && !rule.deployers.includes(actor)) {
+    return miss(`actor ${event.actor} is not on the deployer watchlist`);
+  }
+  if (rule.side !== "any") {
+    const side = eventSide(event);
+    if (side === null) return miss(`side filter does not apply to ${event.kind} events`);
+    if (side !== rule.side) return miss(`side ${side} is not ${rule.side}`);
+  }
+  if (rule.minUsd !== void 0) {
+    if (event.usdValue === null) return miss("event has no USD value to compare against minUsd");
+    if (event.usdValue < rule.minUsd) {
+      return miss(`usdValue ${event.usdValue.toFixed(2)} below minUsd ${rule.minUsd}`);
+    }
+  }
+  if (rule.maxUsd !== void 0) {
+    if (event.usdValue === null) return miss("event has no USD value to compare against maxUsd");
+    if (event.usdValue > rule.maxUsd) {
+      return miss(`usdValue ${event.usdValue.toFixed(2)} above maxUsd ${rule.maxUsd}`);
+    }
+  }
+  if (rule.minLiquidityUsd !== void 0 || rule.maxLiquidityUsd !== void 0) {
+    if (!context.liquidityUsd) {
+      return miss("rule filters on liquidity but no liquidity reader was provided");
+    }
+    const liquidity = await context.liquidityUsd(event);
+    if (liquidity === null) return miss("token liquidity is unknown");
+    if (rule.minLiquidityUsd !== void 0 && liquidity < rule.minLiquidityUsd) {
+      return miss(`liquidity ${liquidity.toFixed(2)} below minLiquidityUsd ${rule.minLiquidityUsd}`);
+    }
+    if (rule.maxLiquidityUsd !== void 0 && liquidity > rule.maxLiquidityUsd) {
+      return miss(`liquidity ${liquidity.toFixed(2)} above maxLiquidityUsd ${rule.maxLiquidityUsd}`);
+    }
+  }
+  const reputationFilter = rule.reputation;
+  if (reputationFilter) {
+    const needsRecord = reputationFilter.minPriorLaunches !== void 0 || reputationFilter.maxPriorLaunches !== void 0 || reputationFilter.maxRuggedLaunches !== void 0;
+    if (needsRecord) {
+      if (!context.reputation) {
+        return miss("rule filters on reputation but no reputation provider was configured");
+      }
+      const record = await context.reputation(event.actor);
+      const prior = priorLaunchesBefore(record, event.blockNumber);
+      if (reputationFilter.minPriorLaunches !== void 0 && prior < reputationFilter.minPriorLaunches) {
+        return miss(`deployer had ${prior} prior launches, needs ${reputationFilter.minPriorLaunches}`);
+      }
+      if (reputationFilter.maxPriorLaunches !== void 0 && prior > reputationFilter.maxPriorLaunches) {
+        return miss(`deployer had ${prior} prior launches, max is ${reputationFilter.maxPriorLaunches}`);
+      }
+      if (reputationFilter.maxRuggedLaunches !== void 0 && record.ruggedLaunches > reputationFilter.maxRuggedLaunches) {
+        return miss(
+          `deployer has ${record.ruggedLaunches} drained pools, max is ${reputationFilter.maxRuggedLaunches}`
+        );
+      }
+    }
+    if (reputationFilter.requireLpLocked === true) {
+      const positionId = eventPositionId(event);
+      if (positionId === null) return miss("event carries no LP position to check for a lock");
+      if (!context.isLpLocked) {
+        return miss("rule requires an LP lock check but no reputation provider was configured");
+      }
+      if (!await context.isLpLocked(positionId)) {
+        return miss(`LP position ${positionId} is not held by the launchpad locker`);
+      }
+    }
+  }
+  return matchOk(rule);
+}
+async function matchRules(rules, event, context = {}) {
+  const results = await Promise.all(
+    rules.map(async (rule) => {
+      try {
+        return { rule, result: await evaluateRule(rule, event, context) };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { rule, result: miss(`evaluation failed: ${message}`) };
+      }
+    })
+  );
+  return results.filter((entry) => entry.result.matched);
+}
+
+// src/rules/ratelimit.ts
+var ALLOWED = { allowed: true, reason: null, retryAtMs: null };
+async function checkRateLimit(store, key, config, nowMs) {
+  if (!config) return ALLOWED;
+  if (config.minIntervalSeconds !== void 0) {
+    const last = await store.lastAt(key);
+    if (last !== null) {
+      const nextAllowed = last + config.minIntervalSeconds * 1e3;
+      if (nowMs < nextAllowed) {
+        return {
+          allowed: false,
+          reason: `minIntervalSeconds=${config.minIntervalSeconds} not elapsed`,
+          retryAtMs: nextAllowed
+        };
+      }
+    }
+  }
+  if (config.maxPerHour !== void 0) {
+    const windowStart = nowMs - 36e5;
+    const used = await store.countSince(key, windowStart);
+    if (used >= config.maxPerHour) {
+      return {
+        allowed: false,
+        reason: `maxPerHour=${config.maxPerHour} reached (${used} in the last hour)`,
+        retryAtMs: windowStart + 36e5
+      };
+    }
+  }
+  return ALLOWED;
+}
+function createMemoryRateLimitStore() {
+  const byKey = /* @__PURE__ */ new Map();
+  const bySubscriber = /* @__PURE__ */ new Map();
+  const push = (map, id, atMs) => {
+    const list = map.get(id) ?? [];
+    list.push(atMs);
+    map.set(
+      id,
+      list.filter((at) => at >= atMs - 36e5)
+    );
+  };
+  return {
+    async countSince(key, sinceMs) {
+      return (byKey.get(key) ?? []).filter((at) => at >= sinceMs).length;
+    },
+    async lastAt(key) {
+      const list = byKey.get(key);
+      if (!list || list.length === 0) return null;
+      return list[list.length - 1] ?? null;
+    },
+    async record(key, subscriberId, atMs) {
+      push(byKey, key, atMs);
+      push(bySubscriber, subscriberId, atMs);
+    },
+    async countForSubscriberSince(subscriberId, sinceMs) {
+      return (bySubscriber.get(subscriberId) ?? []).filter((at) => at >= sinceMs).length;
+    }
+  };
+}
+function rateLimitKey(subscriptionId, ruleId) {
+  return `${subscriptionId}:${ruleId}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addressSchema,
+  canEmit,
+  checkRateLimit,
+  createMemoryRateLimitStore,
+  createRpcReputationProvider,
+  defaultRules,
+  evaluateRule,
+  eventKindSchema,
+  formatValidationError,
+  launchpadSchema,
+  matchRules,
+  parseRule,
+  parseSubscription,
+  platformSchema,
+  priorLaunchesBefore,
+  rateLimitKey,
+  rateLimitSchema,
+  reputationFilterSchema,
+  ruleComplexity,
+  ruleSchema,
+  safeParseRule,
+  safeParseSubscription,
+  sideSchema,
+  subscriptionSchema,
+  usesOnChainLookups
+});
+//# sourceMappingURL=index.cjs.map