hood-alerts 0.1.0

package/dist/chunk-CBNZ6AZT.js

@@ -0,0 +1,598 @@
+import {
+  quoteTokens
+} from "./chunk-6JQK5G3Z.js";
+import {
+  batchAddresses,
+  fetchLogRange
+} from "./chunk-3LHCQA4Z.js";
+
+// 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/tokens.ts
+import { getAddress } from "viem";
+import { erc20Abi } from "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: erc20Abi, functionName: "symbol" },
+        { address: token, abi: erc20Abi, functionName: "name" },
+        { address: token, abi: erc20Abi, functionName: "decimals" }
+      ],
+      allowFailure: true
+    });
+    const [symbolResult, nameResult, decimalsResult] = results;
+    const meta = {
+      address: 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: 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/liquidity.ts
+import { formatUnits } from "viem";
+import { USDG_DECIMALS, erc20Abi as erc20Abi2 } from "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: erc20Abi2,
+      functionName: "balanceOf",
+      args: [pool]
+    });
+    if (quote === usdg.toLowerCase()) {
+      return Number(formatUnits(balance, 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/sources.ts
+import { getAddress as getAddress2 } from "viem";
+import {
+  NOXA_ADDRESSES,
+  ODYSSEY_ADDRESSES,
+  noxaTokenLaunchedEvent,
+  odysseyTokenCreatedEvent,
+  odysseyTradedEvent,
+  odysseyPoolMigratedEvent
+} from "hoodchain";
+import { loadPoolInfo, uniswapV3SwapEvent } from "hoodkit";
+var ODYSSEY_FACTORIES = [
+  ODYSSEY_ADDRESSES.bondingCurveFactory,
+  ODYSSEY_ADDRESSES.reflectionFactory,
+  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: NOXA_ADDRESSES.deployBlock,
+    async poll(from, to) {
+      const logs = await fetchLogRange(
+        (lo, hi) => ctx.client.public.getLogs({
+          address: NOXA_ADDRESSES.launchFactory,
+          event: 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: getAddress2(pool),
+            token: getAddress2(token),
+            quoteToken: getAddress2(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: getAddress2(token),
+          symbol: meta.symbol,
+          name: meta.name,
+          actor: getAddress2(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 ? getAddress2(pool) : null,
+          pairToken: pairToken ? getAddress2(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: NOXA_ADDRESSES.deployBlock,
+    async poll(from, to) {
+      const logs = await fetchLogRange(
+        (lo, hi) => ctx.client.public.getLogs({
+          address: ODYSSEY_FACTORIES,
+          event: 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: getAddress2(token),
+          symbol: meta.symbol,
+          name: meta.name,
+          actor: getAddress2(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() === 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: NOXA_ADDRESSES.deployBlock,
+    async poll(from, to) {
+      const logs = await fetchLogRange(
+        (lo, hi) => ctx.client.public.getLogs({
+          address: ODYSSEY_FACTORIES,
+          event: 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: getAddress2(token),
+          symbol: meta.symbol,
+          name: meta.name,
+          actor: getAddress2(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: NOXA_ADDRESSES.deployBlock,
+    async poll(from, to) {
+      const logs = await fetchLogRange(
+        (lo, hi) => ctx.client.public.getLogs({
+          address: ODYSSEY_FACTORIES,
+          event: 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 loadPoolInfo(ctx.client, pool);
+          quoteToken = info.token0.toLowerCase() === token.toLowerCase() ? info.token1 : info.token0;
+          await ctx.registry.record({
+            pool: getAddress2(pool),
+            token: getAddress2(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: getAddress2(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: getAddress2(log.address),
+          blockNumber: log.blockNumber,
+          logIndex: log.logIndex,
+          transactionHash: log.transactionHash,
+          timestampMs: null,
+          usdValue,
+          explorer: links(base, token, log.address, log.transactionHash, pool),
+          pool: getAddress2(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 loadPoolInfo(ctx.client, pool);
+      poolInfoCache.set(key, info);
+      return info;
+    } catch {
+      return null;
+    }
+  }
+  return {
+    id: "uniswap:whale_trade",
+    label: "Whale trades",
+    startBlock: 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: 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: getAddress2(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"];
+
+export {
+  MAINNET_EXPLORER,
+  TESTNET_EXPLORER,
+  explorerBase,
+  txUrl,
+  addressUrl,
+  tokenUrl,
+  blockUrl,
+  createTokenMetaReader,
+  createBlockTimeReader,
+  createLiquidityReader,
+  eventId,
+  createEventSources,
+  createNoxaLaunchSource,
+  createOdysseyLaunchSource,
+  createOdysseyCurveTradeSource,
+  createOdysseyGraduationSource,
+  createWhaleTradeSource,
+  SUPPORTED_LAUNCHPADS
+};
+//# sourceMappingURL=chunk-CBNZ6AZT.js.map