hood-alerts 0.1.0

package/dist/events/index.cjs

@@ -0,0 +1,820 @@
+"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/events/index.ts
+var events_exports = {};
+__export(events_exports, {
+  EVENT_KIND_LABELS: () => EVENT_KIND_LABELS,
+  LAUNCHPAD_EVENT_KINDS: () => LAUNCHPAD_EVENT_KINDS,
+  MAINNET_EXPLORER: () => MAINNET_EXPLORER,
+  SUPPORTED_LAUNCHPADS: () => SUPPORTED_LAUNCHPADS,
+  TESTNET_EXPLORER: () => TESTNET_EXPLORER,
+  addressUrl: () => addressUrl,
+  batchAddresses: () => batchAddresses,
+  blockUrl: () => blockUrl,
+  createBlockTimeReader: () => createBlockTimeReader,
+  createEventSources: () => createEventSources,
+  createLiquidityReader: () => createLiquidityReader,
+  createMemoryPoolRegistry: () => createMemoryPoolRegistry,
+  createNoxaLaunchSource: () => createNoxaLaunchSource,
+  createOdysseyCurveTradeSource: () => createOdysseyCurveTradeSource,
+  createOdysseyGraduationSource: () => createOdysseyGraduationSource,
+  createOdysseyLaunchSource: () => createOdysseyLaunchSource,
+  createPriceOracle: () => createPriceOracle,
+  createStaticPriceOracle: () => createStaticPriceOracle,
+  createTokenMetaReader: () => createTokenMetaReader,
+  createWhaleTradeSource: () => createWhaleTradeSource,
+  eventId: () => eventId,
+  explorerBase: () => explorerBase,
+  fetchLogRange: () => fetchLogRange,
+  isKind: () => isKind,
+  isResultTooLarge: () => isResultTooLarge,
+  isRetryableRpcError: () => isRetryableRpcError,
+  quoteTokens: () => quoteTokens,
+  tokenUrl: () => tokenUrl,
+  txUrl: () => txUrl
+});
+module.exports = __toCommonJS(events_exports);
+
+// src/events/types.ts
+function isKind(event, kind) {
+  return event.kind === kind;
+}
+var EVENT_KIND_LABELS = {
+  launch: "New launch",
+  curve_trade: "Curve trade",
+  graduation: "Graduation",
+  whale_trade: "Whale trade"
+};
+var LAUNCHPAD_EVENT_KINDS = {
+  noxa: ["launch", "whale_trade"],
+  odyssey: ["launch", "curve_trade", "graduation", "whale_trade"]
+};
+
+// src/events/explorer.ts
+var MAINNET_EXPLORER = "https://robinhoodchain.blockscout.com";
+var TESTNET_EXPLORER = "https://explorer.testnet.chain.robinhood.com";
+function explorerBase(network) {
+  return network === "testnet" ? TESTNET_EXPLORER : MAINNET_EXPLORER;
+}
+function txUrl(base, hash) {
+  return `${base}/tx/${hash}`;
+}
+function addressUrl(base, address) {
+  return `${base}/address/${address}`;
+}
+function tokenUrl(base, token) {
+  return `${base}/token/${token}`;
+}
+function blockUrl(base, blockNumber) {
+  return `${base}/block/${blockNumber}`;
+}
+
+// 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 };
+}
+function createPriceOracle(client, options = {}) {
+  const ttlMs = options.ttlMs ?? 3e4;
+  const probeWei = options.probeWei ?? 10n ** 18n;
+  const now = options.now ?? Date.now;
+  const { weth, usdg } = quoteTokens(client);
+  let cached = null;
+  let cachedAt = 0;
+  let inflight = null;
+  async function refresh() {
+    try {
+      const quote = await (0, import_hoodchain.quoteSwap)(client, { tokenIn: weth, tokenOut: usdg, amountIn: probeWei });
+      const usdgOut = Number((0, import_viem.formatUnits)(quote.amountOut, import_hoodchain.USDG_DECIMALS));
+      const ethIn = Number((0, import_viem.formatUnits)(probeWei, 18));
+      const rate = ethIn > 0 ? usdgOut / ethIn : 0;
+      cached = rate > 0 ? rate : null;
+    } catch {
+      cached = null;
+    }
+    cachedAt = now();
+    return cached;
+  }
+  async function ethUsd() {
+    if (cachedAt !== 0 && now() - cachedAt < ttlMs) return cached;
+    inflight ??= refresh().finally(() => {
+      inflight = null;
+    });
+    return inflight;
+  }
+  return {
+    ethUsd,
+    async weiToUsd(wei) {
+      const rate = await ethUsd();
+      if (rate === null) return null;
+      return Number((0, import_viem.formatUnits)(wei < 0n ? -wei : wei, 18)) * rate;
+    },
+    usdgToUsd(atomic) {
+      return Number((0, import_viem.formatUnits)(atomic < 0n ? -atomic : atomic, import_hoodchain.USDG_DECIMALS));
+    }
+  };
+}
+function createStaticPriceOracle(ethUsdRate) {
+  return {
+    async ethUsd() {
+      return ethUsdRate;
+    },
+    async weiToUsd(wei) {
+      if (ethUsdRate === null) return null;
+      return Number((0, import_viem.formatUnits)(wei < 0n ? -wei : wei, 18)) * ethUsdRate;
+    },
+    usdgToUsd(atomic) {
+      return Number((0, import_viem.formatUnits)(atomic < 0n ? -atomic : atomic, import_hoodchain.USDG_DECIMALS));
+    }
+  };
+}
+
+// src/events/tokens.ts
+var import_viem2 = require("viem");
+var import_hoodchain2 = require("hoodchain");
+function createTokenMetaReader(client, maxEntries = 5e3) {
+  const cache = /* @__PURE__ */ new Map();
+  const inflight = /* @__PURE__ */ new Map();
+  function remember(meta) {
+    if (cache.size >= maxEntries) {
+      const oldest = cache.keys().next();
+      if (!oldest.done) cache.delete(oldest.value);
+    }
+    cache.set(meta.address.toLowerCase(), meta);
+  }
+  async function load(token) {
+    const results = await client.public.multicall({
+      contracts: [
+        { address: token, abi: import_hoodchain2.erc20Abi, functionName: "symbol" },
+        { address: token, abi: import_hoodchain2.erc20Abi, functionName: "name" },
+        { address: token, abi: import_hoodchain2.erc20Abi, functionName: "decimals" }
+      ],
+      allowFailure: true
+    });
+    const [symbolResult, nameResult, decimalsResult] = results;
+    const meta = {
+      address: (0, import_viem2.getAddress)(token),
+      symbol: symbolResult && symbolResult.status === "success" ? String(symbolResult.result) : null,
+      name: nameResult && nameResult.status === "success" ? String(nameResult.result) : null,
+      decimals: decimalsResult && decimalsResult.status === "success" ? Number(decimalsResult.result) : 18
+    };
+    remember(meta);
+    return meta;
+  }
+  return {
+    async get(token) {
+      const key = token.toLowerCase();
+      const hit = cache.get(key);
+      if (hit) return hit;
+      const pending = inflight.get(key);
+      if (pending) return pending;
+      const promise = load(token).catch(() => {
+        const fallback = { address: (0, import_viem2.getAddress)(token), symbol: null, name: null, decimals: 18 };
+        remember(fallback);
+        return fallback;
+      }).finally(() => {
+        inflight.delete(key);
+      });
+      inflight.set(key, promise);
+      return promise;
+    },
+    prime(meta) {
+      remember(meta);
+    }
+  };
+}
+
+// src/events/blocktime.ts
+function createBlockTimeReader(client, maxEntries = 2e3) {
+  const cache = /* @__PURE__ */ new Map();
+  function remember(block, ts) {
+    if (cache.size >= maxEntries) {
+      const oldest = cache.keys().next();
+      if (!oldest.done) cache.delete(oldest.value);
+    }
+    cache.set(block.toString(), ts);
+  }
+  async function get(blockNumber) {
+    const hit = cache.get(blockNumber.toString());
+    if (hit !== void 0) return hit;
+    try {
+      const block = await client.public.getBlock({ blockNumber, includeTransactions: false });
+      const ms = Number(block.timestamp) * 1e3;
+      remember(blockNumber, ms);
+      return ms;
+    } catch {
+      return null;
+    }
+  }
+  return {
+    get,
+    async getMany(blocks, maxLookups) {
+      const unique = [...new Set(blocks.map((b) => b.toString()))].map((b) => BigInt(b));
+      const out = /* @__PURE__ */ new Map();
+      let budget = maxLookups;
+      for (const block of unique) {
+        const cached = cache.get(block.toString());
+        if (cached !== void 0) {
+          out.set(block, cached);
+          continue;
+        }
+        if (budget <= 0) {
+          out.set(block, null);
+          continue;
+        }
+        budget -= 1;
+        out.set(block, await get(block));
+      }
+      return out;
+    }
+  };
+}
+
+// src/events/registry.ts
+var import_viem3 = require("viem");
+function createMemoryPoolRegistry(entries = []) {
+  const pools = /* @__PURE__ */ new Map();
+  for (const entry of entries) pools.set(entry.pool.toLowerCase(), entry);
+  return {
+    async record(entry) {
+      pools.set(entry.pool.toLowerCase(), {
+        ...entry,
+        pool: (0, import_viem3.getAddress)(entry.pool),
+        token: (0, import_viem3.getAddress)(entry.token),
+        quoteToken: (0, import_viem3.getAddress)(entry.quoteToken)
+      });
+    },
+    async active(limit, pinned = []) {
+      const pinnedSet = new Set(pinned.map((a) => a.toLowerCase()));
+      const all = [...pools.values()].sort((a, b) => a.createdBlock > b.createdBlock ? -1 : 1);
+      const isPinned = (entry) => pinnedSet.has(entry.token.toLowerCase());
+      const picked = all.filter(isPinned);
+      let recent = 0;
+      for (const entry of all) {
+        if (recent >= limit) break;
+        if (isPinned(entry)) continue;
+        picked.push(entry);
+        recent += 1;
+      }
+      return picked;
+    },
+    async originOf(token) {
+      const key = token.toLowerCase();
+      for (const entry of pools.values()) {
+        if (entry.token.toLowerCase() === key) return entry.launchpad;
+      }
+      return null;
+    },
+    async poolsFor(token) {
+      const key = token.toLowerCase();
+      return [...pools.values()].filter((entry) => entry.token.toLowerCase() === key);
+    },
+    async size() {
+      return pools.size;
+    }
+  };
+}
+
+// src/events/liquidity.ts
+var import_viem4 = require("viem");
+var import_hoodchain3 = require("hoodchain");
+function createLiquidityReader(client, oracle, registry, options = {}) {
+  const ttlMs = options.ttlMs ?? 6e4;
+  const now = options.now ?? Date.now;
+  const cache = /* @__PURE__ */ new Map();
+  const { weth, usdg } = quoteTokens(client);
+  async function readPool(pool, quoteToken) {
+    const quote = quoteToken.toLowerCase();
+    if (quote !== weth.toLowerCase() && quote !== usdg.toLowerCase()) return null;
+    const balance = await client.public.readContract({
+      address: quoteToken,
+      abi: import_hoodchain3.erc20Abi,
+      functionName: "balanceOf",
+      args: [pool]
+    });
+    if (quote === usdg.toLowerCase()) {
+      return Number((0, import_viem4.formatUnits)(balance, import_hoodchain3.USDG_DECIMALS)) * 2;
+    }
+    const usd = await oracle.weiToUsd(balance);
+    return usd === null ? null : usd * 2;
+  }
+  async function poolLiquidityUsd(pool, quoteToken) {
+    const key = pool.toLowerCase();
+    const hit = cache.get(key);
+    if (hit && now() - hit.at < ttlMs) return hit.value;
+    let value;
+    try {
+      value = await readPool(pool, quoteToken);
+    } catch {
+      value = null;
+    }
+    cache.set(key, { value, at: now() });
+    return value;
+  }
+  return {
+    poolLiquidityUsd,
+    async tokenLiquidityUsd(token) {
+      const pools = await registry.poolsFor(token);
+      if (pools.length === 0) return null;
+      const values = await Promise.all(
+        pools.map((entry) => poolLiquidityUsd(entry.pool, entry.quoteToken))
+      );
+      const known = values.filter((v) => v !== null);
+      return known.length === 0 ? null : Math.max(...known);
+    }
+  };
+}
+
+// src/events/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);
+}
+function batchAddresses(addresses, size = 200) {
+  const batches = [];
+  for (let i = 0; i < addresses.length; i += size) {
+    batches.push(addresses.slice(i, i + size));
+  }
+  return batches;
+}
+
+// src/events/sources.ts
+var import_viem5 = require("viem");
+var import_hoodchain4 = require("hoodchain");
+var import_hoodkit = require("hoodkit");
+var ODYSSEY_FACTORIES = [
+  import_hoodchain4.ODYSSEY_ADDRESSES.bondingCurveFactory,
+  import_hoodchain4.ODYSSEY_ADDRESSES.reflectionFactory,
+  import_hoodchain4.ODYSSEY_ADDRESSES.instantFactory
+];
+function eventId(kind, transactionHash, logIndex) {
+  return `${kind}:${transactionHash.toLowerCase()}:${logIndex}`;
+}
+function links(base, token, actor, hash, pool) {
+  return {
+    tx: txUrl(base, hash),
+    token: tokenUrl(base, token),
+    actor: addressUrl(base, actor),
+    ...pool ? { pool: addressUrl(base, pool) } : {}
+  };
+}
+async function valueQuote(ctx, quoteToken, raw) {
+  const { weth, usdg } = quoteTokens(ctx.client);
+  const token = quoteToken.toLowerCase();
+  if (token === usdg.toLowerCase()) return ctx.oracle.usdgToUsd(raw);
+  if (token === weth.toLowerCase()) return ctx.oracle.weiToUsd(raw);
+  return null;
+}
+function assertMainnet(client) {
+  if (client.network !== "mainnet") {
+    throw new Error(
+      'hood-alerts: the NOXA and Odyssey launchpads are deployed on Robinhood Chain mainnet (chain 4663) only. Create the client with { chain: "mainnet" } (the default) to watch them.'
+    );
+  }
+}
+function createEventSources(ctx) {
+  assertMainnet(ctx.client);
+  return [
+    createNoxaLaunchSource(ctx),
+    createOdysseyLaunchSource(ctx),
+    createOdysseyCurveTradeSource(ctx),
+    createOdysseyGraduationSource(ctx),
+    createWhaleTradeSource(ctx)
+  ];
+}
+function blockTimes(ctx) {
+  ctx.blockTimes ??= createBlockTimeReader(ctx.client);
+  return ctx.blockTimes;
+}
+async function stampTimes(ctx, events) {
+  if (events.length === 0) return events;
+  const reader = blockTimes(ctx);
+  const times = await reader.getMany(
+    events.map((e) => e.blockNumber),
+    ctx.maxBlockTimeLookupsPerPoll ?? 25
+  );
+  for (const event of events) event.timestampMs = times.get(event.blockNumber) ?? null;
+  return events;
+}
+function createNoxaLaunchSource(ctx) {
+  const base = explorerBase(ctx.client.network);
+  return {
+    id: "noxa:launch",
+    label: "NOXA launches",
+    startBlock: import_hoodchain4.NOXA_ADDRESSES.deployBlock,
+    async poll(from, to) {
+      const logs = await fetchLogRange(
+        (lo, hi) => ctx.client.public.getLogs({
+          address: import_hoodchain4.NOXA_ADDRESSES.launchFactory,
+          event: import_hoodchain4.noxaTokenLaunchedEvent,
+          fromBlock: lo,
+          toBlock: hi
+        }),
+        from,
+        to,
+        ctx.logOptions ?? {}
+      );
+      const events = [];
+      for (const log of logs) {
+        const token = log.args.token;
+        const deployer = log.args.deployer;
+        if (!token || !deployer) continue;
+        const pool = log.args.pool ?? null;
+        const pairToken = log.args.pairToken ?? null;
+        const initialBuyAmount = log.args.initialBuyAmount ?? 0n;
+        if (pool && pairToken) {
+          await ctx.registry.record({
+            pool: (0, import_viem5.getAddress)(pool),
+            token: (0, import_viem5.getAddress)(token),
+            quoteToken: (0, import_viem5.getAddress)(pairToken),
+            launchpad: "noxa",
+            createdBlock: log.blockNumber
+          });
+        }
+        const meta = await ctx.tokens.get(token);
+        const usdValue = pairToken && initialBuyAmount > 0n ? await valueQuote(ctx, pairToken, initialBuyAmount) : null;
+        events.push({
+          id: eventId("launch", log.transactionHash, log.logIndex),
+          kind: "launch",
+          launchpad: "noxa",
+          token: (0, import_viem5.getAddress)(token),
+          symbol: meta.symbol,
+          name: meta.name,
+          actor: (0, import_viem5.getAddress)(deployer),
+          blockNumber: log.blockNumber,
+          logIndex: log.logIndex,
+          transactionHash: log.transactionHash,
+          timestampMs: null,
+          usdValue,
+          explorer: links(base, token, deployer, log.transactionHash, pool ?? void 0),
+          pool: pool ? (0, import_viem5.getAddress)(pool) : null,
+          pairToken: pairToken ? (0, import_viem5.getAddress)(pairToken) : null,
+          initialBuyAmount,
+          positionId: log.args.positionId ?? null,
+          // NOXA has no bonding curve at all: a launch is already a listing.
+          instantListing: true
+        });
+      }
+      return stampTimes(ctx, events);
+    }
+  };
+}
+function createOdysseyLaunchSource(ctx) {
+  const base = explorerBase(ctx.client.network);
+  return {
+    id: "odyssey:launch",
+    label: "Odyssey launches",
+    startBlock: import_hoodchain4.NOXA_ADDRESSES.deployBlock,
+    async poll(from, to) {
+      const logs = await fetchLogRange(
+        (lo, hi) => ctx.client.public.getLogs({
+          address: ODYSSEY_FACTORIES,
+          event: import_hoodchain4.odysseyTokenCreatedEvent,
+          fromBlock: lo,
+          toBlock: hi
+        }),
+        from,
+        to,
+        ctx.logOptions ?? {}
+      );
+      const events = [];
+      for (const log of logs) {
+        const token = log.args.token;
+        const creator = log.args.creator;
+        if (!token || !creator) continue;
+        const meta = await ctx.tokens.get(token);
+        events.push({
+          id: eventId("launch", log.transactionHash, log.logIndex),
+          kind: "launch",
+          launchpad: "odyssey",
+          token: (0, import_viem5.getAddress)(token),
+          symbol: meta.symbol,
+          name: meta.name,
+          actor: (0, import_viem5.getAddress)(creator),
+          blockNumber: log.blockNumber,
+          logIndex: log.logIndex,
+          transactionHash: log.transactionHash,
+          timestampMs: null,
+          // The curve holds liquidity until graduation, so a new Odyssey token
+          // has no pool and no priceable notional at creation time.
+          usdValue: null,
+          explorer: links(base, token, creator, log.transactionHash),
+          pool: null,
+          pairToken: null,
+          initialBuyAmount: 0n,
+          positionId: null,
+          instantListing: log.address.toLowerCase() === import_hoodchain4.ODYSSEY_ADDRESSES.instantFactory.toLowerCase()
+        });
+      }
+      return stampTimes(ctx, events);
+    }
+  };
+}
+function createOdysseyCurveTradeSource(ctx) {
+  const base = explorerBase(ctx.client.network);
+  return {
+    id: "odyssey:curve_trade",
+    label: "Odyssey curve trades",
+    startBlock: import_hoodchain4.NOXA_ADDRESSES.deployBlock,
+    async poll(from, to) {
+      const logs = await fetchLogRange(
+        (lo, hi) => ctx.client.public.getLogs({
+          address: ODYSSEY_FACTORIES,
+          event: import_hoodchain4.odysseyTradedEvent,
+          fromBlock: lo,
+          toBlock: hi
+        }),
+        from,
+        to,
+        ctx.logOptions ?? {}
+      );
+      const events = [];
+      for (const log of logs) {
+        const token = log.args.token;
+        const trader = log.args.trader;
+        if (!token || !trader) continue;
+        const tokenAmount = log.args.tokenAmount ?? 0n;
+        const quoteAmountWei = log.args.quoteAmount ?? 0n;
+        const meta = await ctx.tokens.get(token);
+        const usdValue = await ctx.oracle.weiToUsd(quoteAmountWei);
+        const priceEth = tokenAmount > 0n ? Number(quoteAmountWei) / Number(tokenAmount) : null;
+        events.push({
+          id: eventId("curve_trade", log.transactionHash, log.logIndex),
+          kind: "curve_trade",
+          launchpad: "odyssey",
+          token: (0, import_viem5.getAddress)(token),
+          symbol: meta.symbol,
+          name: meta.name,
+          actor: (0, import_viem5.getAddress)(trader),
+          blockNumber: log.blockNumber,
+          logIndex: log.logIndex,
+          transactionHash: log.transactionHash,
+          timestampMs: null,
+          usdValue,
+          explorer: links(base, token, trader, log.transactionHash),
+          side: log.args.isBuy ? "buy" : "sell",
+          tokenAmount,
+          quoteAmountWei,
+          feeWei: log.args.fee ?? 0n,
+          virtualQuoteWei: log.args.virtualQuote ?? 0n,
+          virtualTokenAmount: log.args.virtualToken ?? 0n,
+          priceEth
+        });
+      }
+      return stampTimes(ctx, events);
+    }
+  };
+}
+function createOdysseyGraduationSource(ctx) {
+  const base = explorerBase(ctx.client.network);
+  return {
+    id: "odyssey:graduation",
+    label: "Odyssey graduations",
+    startBlock: import_hoodchain4.NOXA_ADDRESSES.deployBlock,
+    async poll(from, to) {
+      const logs = await fetchLogRange(
+        (lo, hi) => ctx.client.public.getLogs({
+          address: ODYSSEY_FACTORIES,
+          event: import_hoodchain4.odysseyPoolMigratedEvent,
+          fromBlock: lo,
+          toBlock: hi
+        }),
+        from,
+        to,
+        ctx.logOptions ?? {}
+      );
+      const events = [];
+      for (const log of logs) {
+        const token = log.args.token;
+        const pool = log.args.pool;
+        if (!token || !pool) continue;
+        const quoteUsed = log.args.usdcUsed ?? 0n;
+        let quoteToken = null;
+        try {
+          const info = await (0, import_hoodkit.loadPoolInfo)(ctx.client, pool);
+          quoteToken = info.token0.toLowerCase() === token.toLowerCase() ? info.token1 : info.token0;
+          await ctx.registry.record({
+            pool: (0, import_viem5.getAddress)(pool),
+            token: (0, import_viem5.getAddress)(token),
+            quoteToken,
+            launchpad: "odyssey",
+            createdBlock: log.blockNumber
+          });
+        } catch {
+          quoteToken = null;
+        }
+        const meta = await ctx.tokens.get(token);
+        const usdValue = quoteToken ? await valueQuote(ctx, quoteToken, quoteUsed) : null;
+        events.push({
+          id: eventId("graduation", log.transactionHash, log.logIndex),
+          kind: "graduation",
+          launchpad: "odyssey",
+          token: (0, import_viem5.getAddress)(token),
+          symbol: meta.symbol,
+          name: meta.name,
+          // A migration is executed by the factory on behalf of the curve, so
+          // the closest thing to an actor is the factory that emitted it.
+          actor: (0, import_viem5.getAddress)(log.address),
+          blockNumber: log.blockNumber,
+          logIndex: log.logIndex,
+          transactionHash: log.transactionHash,
+          timestampMs: null,
+          usdValue,
+          explorer: links(base, token, log.address, log.transactionHash, pool),
+          pool: (0, import_viem5.getAddress)(pool),
+          positionId: log.args.tokenId ?? 0n,
+          liquidity: log.args.liquidity ?? 0n,
+          tokenUsed: log.args.tokenUsed ?? 0n,
+          quoteUsed
+        });
+      }
+      return stampTimes(ctx, events);
+    }
+  };
+}
+function createWhaleTradeSource(ctx) {
+  const base = explorerBase(ctx.client.network);
+  const poolInfoCache = /* @__PURE__ */ new Map();
+  const minUsd = ctx.whaleMinUsd ?? 1e3;
+  async function poolInfo(pool) {
+    const key = pool.toLowerCase();
+    const hit = poolInfoCache.get(key);
+    if (hit) return hit;
+    try {
+      const info = await (0, import_hoodkit.loadPoolInfo)(ctx.client, pool);
+      poolInfoCache.set(key, info);
+      return info;
+    } catch {
+      return null;
+    }
+  }
+  return {
+    id: "uniswap:whale_trade",
+    label: "Whale trades",
+    startBlock: import_hoodchain4.NOXA_ADDRESSES.deployBlock,
+    async poll(from, to) {
+      const pinned = ctx.pinnedTokens ? await ctx.pinnedTokens() : [];
+      const entries = await ctx.registry.active(ctx.whalePoolLimit ?? 400, pinned);
+      if (entries.length === 0) return [];
+      const byPool = new Map(entries.map((entry) => [entry.pool.toLowerCase(), entry]));
+      const batches = batchAddresses(
+        entries.map((entry) => entry.pool),
+        ctx.whalePoolBatchSize ?? 200
+      );
+      const logs = (await Promise.all(
+        batches.map(
+          (batch) => fetchLogRange(
+            (lo, hi) => ctx.client.public.getLogs({
+              address: batch,
+              event: import_hoodkit.uniswapV3SwapEvent,
+              fromBlock: lo,
+              toBlock: hi
+            }),
+            from,
+            to,
+            ctx.logOptions ?? {}
+          )
+        )
+      )).flat();
+      const events = [];
+      for (const log of logs) {
+        const entry = byPool.get(log.address.toLowerCase());
+        if (!entry) continue;
+        const info = await poolInfo(entry.pool);
+        if (!info) continue;
+        const amount0 = log.args.amount0 ?? 0n;
+        const amount1 = log.args.amount1 ?? 0n;
+        const quoteIsToken0 = info.token0.toLowerCase() === entry.quoteToken.toLowerCase();
+        const quoteRaw = quoteIsToken0 ? amount0 : amount1;
+        const tokenRaw = quoteIsToken0 ? amount1 : amount0;
+        if (quoteRaw === 0n || tokenRaw === 0n) continue;
+        const usdValue = await valueQuote(ctx, entry.quoteToken, quoteRaw);
+        if (usdValue === null || usdValue < minUsd) continue;
+        const quoteDecimals = quoteIsToken0 ? info.decimals0 : info.decimals1;
+        const tokenDecimals = quoteIsToken0 ? info.decimals1 : info.decimals0;
+        const quoteAmount = Math.abs(Number(quoteRaw)) / 10 ** quoteDecimals;
+        const tokenAmount = Math.abs(Number(tokenRaw)) / 10 ** tokenDecimals;
+        const [tokenMeta, quoteMeta] = await Promise.all([
+          ctx.tokens.get(entry.token),
+          ctx.tokens.get(entry.quoteToken)
+        ]);
+        const trader = log.args.recipient ?? log.args.sender;
+        events.push({
+          id: eventId("whale_trade", log.transactionHash, log.logIndex),
+          kind: "whale_trade",
+          launchpad: entry.launchpad,
+          token: entry.token,
+          symbol: tokenMeta.symbol,
+          name: tokenMeta.name,
+          actor: (0, import_viem5.getAddress)(trader),
+          blockNumber: log.blockNumber,
+          logIndex: log.logIndex,
+          transactionHash: log.transactionHash,
+          timestampMs: null,
+          usdValue,
+          explorer: links(base, entry.token, trader, log.transactionHash, entry.pool),
+          pool: entry.pool,
+          quoteToken: entry.quoteToken,
+          quoteSymbol: quoteMeta.symbol ?? "quote",
+          // The memecoin left the pool (negative delta) means the trader bought it.
+          side: tokenRaw < 0n ? "buy" : "sell",
+          tokenAmount,
+          quoteAmount,
+          price: tokenAmount > 0 ? quoteAmount / tokenAmount : 0,
+          feeTier: info.fee
+        });
+      }
+      return stampTimes(ctx, events);
+    }
+  };
+}
+var SUPPORTED_LAUNCHPADS = ["noxa", "odyssey"];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EVENT_KIND_LABELS,
+  LAUNCHPAD_EVENT_KINDS,
+  MAINNET_EXPLORER,
+  SUPPORTED_LAUNCHPADS,
+  TESTNET_EXPLORER,
+  addressUrl,
+  batchAddresses,
+  blockUrl,
+  createBlockTimeReader,
+  createEventSources,
+  createLiquidityReader,
+  createMemoryPoolRegistry,
+  createNoxaLaunchSource,
+  createOdysseyCurveTradeSource,
+  createOdysseyGraduationSource,
+  createOdysseyLaunchSource,
+  createPriceOracle,
+  createStaticPriceOracle,
+  createTokenMetaReader,
+  createWhaleTradeSource,
+  eventId,
+  explorerBase,
+  fetchLogRange,
+  isKind,
+  isResultTooLarge,
+  isRetryableRpcError,
+  quoteTokens,
+  tokenUrl,
+  txUrl
+});
+//# sourceMappingURL=index.cjs.map