envio 3.10.0-subgraph → 3.11.0

package/src/subgraph/blocks.ts

@@ -1,176 +0,0 @@
-/**
- * A block handler's `block.timestamp`.
- *
- * envio hands a block handler only the block number, so the timestamp has to be
- * fetched. Every handler invocation in a batch asks within the same microtask,
- * so the requests are collected and answered by a single HyperSync range query
- * rather than one round trip per block. An RPC endpoint, if one is configured,
- * is the fallback for whatever HyperSync couldn't answer.
- */
-
-import { createPublicClient, fallback, http } from "viem";
-
-const API_TOKEN_ENV_VAR = "ENVIO_API_TOKEN";
-
-const hypersyncUrl = (chainId: number) => `https://${chainId}.hypersync.xyz/query`;
-
-type Waiter = {
-  resolve: (timestamp: bigint) => void;
-  reject: (error: unknown) => void;
-};
-
-/** Blocks asked for since the last flush, by chain then block number. */
-let pending = new Map<number, Map<number, Waiter[]>>();
-let flushScheduled = false;
-
-let rpcUrls: string[] = [];
-let client: ReturnType<typeof createPublicClient> | null = null;
-
-export function configureBlockTimestamps(urls: string[]) {
-  rpcUrls = urls;
-  client = null;
-  pending = new Map();
-  flushScheduled = false;
-}
-
-export function requestBlockTimestamp(chainId: number, blockNumber: number): Promise<bigint> {
-  return new Promise((resolve, reject) => {
-    let blocks = pending.get(chainId);
-    if (!blocks) {
-      blocks = new Map();
-      pending.set(chainId, blocks);
-    }
-    const waiters = blocks.get(blockNumber);
-    if (waiters) {
-      waiters.push({ resolve, reject });
-    } else {
-      blocks.set(blockNumber, [{ resolve, reject }]);
-    }
-
-    if (!flushScheduled) {
-      flushScheduled = true;
-      queueMicrotask(() => {
-        flushScheduled = false;
-        const collected = pending;
-        pending = new Map();
-        for (const [chain, blocksForChain] of collected) {
-          void answer(chain, blocksForChain);
-        }
-      });
-    }
-  });
-}
-
-async function answer(chainId: number, blocks: Map<number, Waiter[]>) {
-  let timestamps = new Map<number, bigint>();
-
-  // A batch can hold thousands of blocks, and one argument per block would
-  // overflow the call stack inside the try, where it would read as a HyperSync
-  // failure and fall back to one round trip per block.
-  let lowest = Infinity;
-  let highest = -Infinity;
-  for (const blockNumber of blocks.keys()) {
-    if (blockNumber < lowest) lowest = blockNumber;
-    if (blockNumber > highest) highest = blockNumber;
-  }
-
-  try {
-    timestamps = await fromHyperSync(chainId, lowest, highest);
-  } catch (error) {
-    if (rpcUrls.length === 0) {
-      const message = error instanceof Error ? error.message : String(error);
-      for (const waiters of blocks.values()) {
-        for (const waiter of waiters) {
-          waiter.reject(
-            new Error(
-              `Envio Subgraph couldn't read a block timestamp from HyperSync: ${message}\n` +
-                `Set ${API_TOKEN_ENV_VAR} in .env or the environment — create one at\n` +
-                `https://envio.dev/app/api-tokens — or set ENVIO_SUBGRAPH_RPC to fall back to RPC.`,
-            ),
-          );
-        }
-      }
-      return;
-    }
-  }
-
-  for (const [blockNumber, waiters] of blocks) {
-    const known = timestamps.get(blockNumber);
-    if (known !== undefined) {
-      for (const waiter of waiters) waiter.resolve(known);
-      continue;
-    }
-    try {
-      const timestamp = await fromRpc(blockNumber);
-      for (const waiter of waiters) waiter.resolve(timestamp);
-    } catch (error) {
-      for (const waiter of waiters) waiter.reject(error);
-    }
-  }
-}
-
-type HyperSyncResponse = {
-  data: { blocks?: { number: number; timestamp: string }[] }[];
-  next_block: number;
-};
-
-async function fromHyperSync(
-  chainId: number,
-  fromBlock: number,
-  toBlock: number,
-): Promise<Map<number, bigint>> {
-  const token = process.env[API_TOKEN_ENV_VAR];
-  const timestamps = new Map<number, bigint>();
-
-  let cursor = fromBlock;
-  // HyperSync answers as much of the range as one response holds and points at
-  // where to resume, so a wide range takes more than one round trip.
-  while (cursor <= toBlock) {
-    const response = await fetch(hypersyncUrl(chainId), {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        ...(token ? { authorization: `Bearer ${token}` } : {}),
-      },
-      body: JSON.stringify({
-        from_block: cursor,
-        to_block: toBlock + 1,
-        include_all_blocks: true,
-        field_selection: { block: ["number", "timestamp"] },
-      }),
-    });
-
-    if (!response.ok) {
-      throw new Error(`HyperSync returned ${response.status} ${await response.text()}`);
-    }
-
-    const body = (await response.json()) as HyperSyncResponse;
-    for (const page of body.data ?? []) {
-      for (const block of page.blocks ?? []) {
-        timestamps.set(block.number, BigInt(block.timestamp));
-      }
-    }
-
-    if (!body.next_block || body.next_block <= cursor) {
-      break;
-    }
-    cursor = body.next_block;
-  }
-
-  return timestamps;
-}
-
-async function fromRpc(blockNumber: number): Promise<bigint> {
-  if (rpcUrls.length === 0) {
-    throw new Error(
-      `Envio Subgraph couldn't read the timestamp of block ${blockNumber}: HyperSync didn't\n` +
-        `return it, and no RPC fallback is configured. Set ENVIO_SUBGRAPH_RPC in .env or the\n` +
-        `environment.`,
-    );
-  }
-  client ??= createPublicClient({
-    transport: fallback(rpcUrls.map((url) => http(url, { retryCount: 0 }))),
-  });
-  const block = await client.getBlock({ blockNumber: BigInt(blockNumber) });
-  return block.timestamp;
-}

package/src/subgraph/calls.ts

@@ -1,217 +0,0 @@
-/**
- * `Contract.bind(x).foo()` -> an envio effect over viem.
- *
- * graph-node evaluates a mapping's contract calls against the block the event
- * came from, so the block number is part of the effect's input — and therefore
- * of its cache key, which is what makes a cached call safe to reuse.
- */
-
-import {
-  createPublicClient,
-  decodeFunctionResult,
-  encodeFunctionData,
-  fallback,
-  http,
-  parseAbiParameters,
-  type Abi,
-} from "viem";
-import * as Sury from "rescript-schema";
-import { createEffect } from "../Envio.res.mjs";
-import { missingRpcMessage } from "./errors.ts";
-
-export type ParsedSignature = {
-  name: string;
-  inputs: string;
-  outputs: string;
-};
-
-/**
- * graph codegen emits `"balanceOf(address):(uint256)"`. Types only, no names —
- * which is all `parseAbiParameters` needs.
- */
-export function parseSignature(signature: string): ParsedSignature {
-  const open = signature.indexOf("(");
-  if (open === -1) {
-    throw new Error(`Unreadable contract call signature "${signature}"`);
-  }
-  const name = signature.slice(0, open);
-
-  let depth = 0;
-  let close = -1;
-  for (let index = open; index < signature.length; index++) {
-    const char = signature[index];
-    if (char === "(") depth++;
-    if (char === ")") {
-      depth--;
-      if (depth === 0) {
-        close = index;
-        break;
-      }
-    }
-  }
-  if (close === -1) {
-    throw new Error(`Unreadable contract call signature "${signature}"`);
-  }
-
-  const inputs = signature.slice(open + 1, close);
-  const rest = signature.slice(close + 1).replace(/^:/, "");
-  const outputs = rest.startsWith("(") ? rest.slice(1, -1) : rest;
-
-  return { name, inputs, outputs };
-}
-
-export function abiItemFor(signature: string): Abi {
-  const { name, inputs, outputs } = parseSignature(signature);
-  return [
-    {
-      type: "function",
-      name,
-      stateMutability: "view",
-      inputs: inputs.trim() === "" ? [] : [...parseAbiParameters(inputs)],
-      outputs: outputs.trim() === "" ? [] : [...parseAbiParameters(outputs)],
-    },
-  ] as Abi;
-}
-
-/**
- * A revert is data: the mapping's `try_` sees `{reverted: true}`. A transport
- * failure is not — it throws as the handler error so envio retries, and a flaky
- * RPC never fabricates reverted data.
- */
-export function isRevert(error: unknown): boolean {
-  const parts: string[] = [];
-  let current: any = error;
-  for (let depth = 0; current && depth < 10; depth++) {
-    parts.push(current.name, current.shortMessage, current.details, current.message);
-    current = current.cause;
-  }
-  const text = parts.filter(Boolean).join(" | ");
-
-  if (/revert|ContractFunctionZeroDataError|invalid opcode|out of gas/i.test(text)) {
-    return true;
-  }
-  return false;
-}
-
-export type CallInput = {
-  chainId: number;
-  address: string;
-  signature: string;
-  args: unknown[];
-  blockNumber: number;
-};
-
-export type CallOutput = {
-  reverted: boolean;
-  values: unknown[] | null;
-};
-
-let clients: Map<string, ReturnType<typeof createPublicClient>> = new Map();
-
-function clientFor(rpcUrls: string[]) {
-  const key = rpcUrls.join("|");
-  let client = clients.get(key);
-  if (!client) {
-    client = createPublicClient({
-      // Retrying is envio's job: a failed call becomes a handler error and
-      // the batch is retried with the effect's dedup still in place.
-      transport: fallback(rpcUrls.map((url) => http(url, { retryCount: 0 }))),
-    });
-    clients.set(key, client);
-  }
-  return client;
-}
-
-/** Reset between test indexers, which each bring their own endpoints. */
-export function resetClients() {
-  clients = new Map();
-}
-
-/**
- * BigInt and Bytes cross the effect boundary through Sury, which needs a
- * serialisable shape — so the call is described in plain JSON and the graph-ts
- * values are converted on both sides by the shim.
- */
-export function makeCallEffect(rpcUrls: string[]) {
-  return createEffect(
-    {
-      name: "envio_subgraph_eth_call",
-      // Both sides travel as JSON text: the cache key is then the exact call
-      // description, and the cached row is readable.
-      input: Sury.string,
-      output: Sury.string,
-      rateLimit: false,
-      cache: true,
-      crossChain: false,
-    },
-    async ({ input: encoded }: { input: string }) => {
-      const input = JSON.parse(encoded) as CallInput;
-      if (rpcUrls.length === 0) {
-        throw new Error(missingRpcMessage(input.signature));
-      }
-      const abi = abiItemFor(input.signature);
-      const { name } = parseSignature(input.signature);
-      const data = encodeFunctionData({
-        abi,
-        functionName: name,
-        args: input.args.map(decodeArg),
-      });
-
-      let result;
-      try {
-        result = await clientFor(rpcUrls).call({
-          to: input.address as `0x${string}`,
-          data,
-          blockNumber: BigInt(input.blockNumber),
-        });
-      } catch (error) {
-        if (isRevert(error)) {
-          return JSON.stringify({ reverted: true, values: null });
-        }
-        throw error;
-      }
-
-      try {
-        const decoded = decodeFunctionResult({
-          abi,
-          functionName: name,
-          data: (result.data ?? "0x") as `0x${string}`,
-        });
-        // graph-ts returns one `ethereum.Value` per ABI output. A single
-        // tuple/struct is therefore `[tuple]`, not the flattened fields —
-        // generated bindings call `result[0].toTuple()`.
-        const outputs = (abi[0] as { outputs?: unknown[] }).outputs ?? [];
-        const values = outputs.length === 1 ? [decoded] : Array.isArray(decoded) ? decoded : [decoded];
-        return JSON.stringify({ reverted: false, values: values.map(encodeArg) });
-      } catch {
-        // Output the declared signature can't decode counts as a failed call,
-        // which is what lets a mapping retry through a different ABI — the
-        // bytes32-vs-string ERC20 name is the case every token subgraph hits.
-        return JSON.stringify({ reverted: true, values: null });
-      }
-    },
-  );
-}
-
-/** Effect inputs/outputs travel as strings, tagged so the type survives. */
-export function encodeArg(value: unknown): string {
-  if (typeof value === "bigint") return `i:${value.toString()}`;
-  if (typeof value === "boolean") return `b:${value ? "1" : "0"}`;
-  if (Array.isArray(value)) return `a:${JSON.stringify(value.map(encodeArg))}`;
-  return `s:${String(value)}`;
-}
-
-export function decodeArg(value: string): unknown {
-  const tag = value.slice(0, 2);
-  const body = value.slice(2);
-  switch (tag) {
-    case "i:":
-      return BigInt(body);
-    case "b:":
-      return body === "1";
-    case "a:":
-      return (JSON.parse(body) as string[]).map(decodeArg);
-    default:
-      return body;
-  }
-}

package/src/subgraph/conformance.ts

@@ -1,102 +0,0 @@
-/**
- * The shim, checked against the types a subgraph developer codes against.
- *
- * A subgraph's mappings are type-checked by `asc` against
- * `@graphprotocol/graph-ts`, and then run by this shim. Nothing else makes
- * those two agree, so a gap shows up as green types and a runtime error — the
- * worst feedback loop there is. This file closes it: every export the shim
- * claims to provide has to be assignable to the real one.
- *
- * The declarations come from the real package (see
- * `scripts/generate-graph-ts-types.mjs`). This file is type-checked, never run.
- *
- * A `@ts-expect-error` below is a known gap, and it cleans itself up: closing
- * the gap makes the directive unused, which is itself an error, so the comment
- * has to go with the fix. Adding a new one is a deliberate act.
- */
-
-import type * as GraphTs from "./graph-ts-types/index.js";
-import * as Shim from "./graph-ts.ts";
-
-// @ts-expect-error graph-ts' BigInt extends Uint8Array and is constructed
-// from a byte length; this one is constructed from the value it holds. No
-// mapping calls `new BigInt(...)` — they go through `BigInt.from*` — and
-// every other member matches. The five below are the same difference,
-// reached through a BigInt in their own signatures.
-const _BigInt: typeof GraphTs.BigInt = Shim.BigInt;
-
-// @ts-expect-error constructor takes a BigInt (see above).
-const _BigDecimal: typeof GraphTs.BigDecimal = Shim.BigDecimal;
-
-const _Bytes: typeof GraphTs.Bytes = Shim.Bytes;
-
-const _ByteArray: typeof GraphTs.ByteArray = Shim.ByteArray;
-
-const _Address: typeof GraphTs.Address = Shim.Address;
-
-const _TypedMap: typeof GraphTs.TypedMap = Shim.TypedMap;
-
-const _TypedMapEntry: typeof GraphTs.TypedMapEntry = Shim.TypedMapEntry;
-
-const _Entity: typeof GraphTs.Entity = Shim.Entity;
-
-const _Value: typeof GraphTs.Value = Shim.Value;
-
-const _ValueKind: typeof GraphTs.ValueKind = Shim.ValueKind;
-
-const _store: typeof GraphTs.store = Shim.store;
-
-// @ts-expect-error `ethereum.Value` carries a BigInt (see above).
-const _ethereum: typeof GraphTs.ethereum = Shim.ethereum;
-
-const _dataSource: typeof GraphTs.dataSource = Shim.dataSource;
-
-const _DataSourceTemplate: typeof GraphTs.DataSourceTemplate = Shim.DataSourceTemplate;
-
-const _DataSourceContext: typeof GraphTs.DataSourceContext = Shim.DataSourceContext;
-
-// @ts-expect-error `log` formats a BigInt (see above).
-const _log: typeof GraphTs.log = Shim.log;
-
-const _crypto: typeof GraphTs.crypto = Shim.crypto;
-
-const _EthereumUtils: typeof GraphTs.EthereumUtils = Shim.EthereumUtils;
-
-// @ts-expect-error `json.toBigInt` returns a BigInt (see above).
-const _json: typeof GraphTs.json = Shim.json;
-
-// @ts-expect-error `JSONValue.toBigInt` returns a BigInt (see above).
-const _JSONValue: typeof GraphTs.JSONValue = Shim.JSONValue;
-
-const _JSONValueKind: typeof GraphTs.JSONValueKind = Shim.JSONValueKind;
-
-const _ipfs: typeof GraphTs.ipfs = Shim.ipfs;
-
-const _ens: typeof GraphTs.ens = Shim.ens;
-
-export type {};
-void [
-  _BigInt,
-  _BigDecimal,
-  _Bytes,
-  _ByteArray,
-  _Address,
-  _TypedMap,
-  _TypedMapEntry,
-  _Entity,
-  _Value,
-  _ValueKind,
-  _store,
-  _ethereum,
-  _dataSource,
-  _DataSourceTemplate,
-  _DataSourceContext,
-  _log,
-  _crypto,
-  _EthereumUtils,
-  _json,
-  _JSONValue,
-  _JSONValueKind,
-  _ipfs,
-  _ens,
-];

package/src/subgraph/division.ts

@@ -1,133 +0,0 @@
-/**
- * AssemblyScript divides two integers as integers. JavaScript doesn't.
- *
- * `let dayID = timestamp / 86400` is an i32 division in a mapping and a float
- * division here, and the difference travels: Uniswap multiplies the bucket back
- * out and writes it to an `Int` column, where `1588712972.0000002` is a type
- * error rather than a wrong number — but an entity id built the same way would
- * simply be wrong. Nothing in the shim can intercept `/` between two plain
- * numbers, so the operator is rewritten as the mapping is loaded.
- *
- * The rewrite is textual, driven by the TypeScript parser every subgraph project
- * already has: each `a / b` becomes `__envio_idiv(a, b)`, which truncates only
- * when both operands really are integers and otherwise divides as before — an
- * `f64` in AssemblyScript divides as a float too.
- */
-
-import { createRequire } from "node:module";
-import path from "node:path";
-
-type Edit = { at: number; length: number; text: string };
-
-let typescript: any | null | undefined;
-
-/**
- * The project's own TypeScript, which `graph-cli` puts there. Resolving from the
- * project rather than from here keeps the shim free of a parser dependency.
- */
-export function loadTypeScript(root: string): any | null {
-  if (typescript !== undefined) return typescript;
-  try {
-    const require = createRequire(path.join(path.resolve(root), "package.json"));
-    typescript = require("typescript");
-  } catch {
-    typescript = null;
-  }
-  return typescript;
-}
-
-export function integerDivision(a: unknown, b: unknown): unknown {
-  const left = typeof a === "object" && a !== null ? (a as any).valueOf() : a;
-  const right = typeof b === "object" && b !== null ? (b as any).valueOf() : b;
-
-  const integral = (v: unknown) => typeof v === "bigint" || (typeof v === "number" && Number.isInteger(v));
-  if (integral(left) && integral(right)) {
-    // Only i64 / i64 stays 64-bit; anything narrower is an i32 in AssemblyScript
-    // and must come back as a number, or the bigint spreads through every
-    // arithmetic that follows.
-    if (typeof left === "bigint" && typeof right === "bigint") {
-      return left / right;
-    }
-    return Math.trunc(Number(left) / Number(right));
-  }
-  return (left as number) / (right as number);
-}
-
-export const DIVIDE_HELPER = "__envio_idiv";
-export const RETAG_HELPER = "__envio_retag";
-
-/** `changetype<Foo>(x)` → `__envio_retag(Foo, x)` when Foo is a class name. */
-export function rewriteChangetype(source: string): string {
-  if (!source.includes("changetype<")) return source;
-  return source.replace(
-    /changetype\s*<\s*([A-Za-z_][A-Za-z0-9_]*)\s*>\s*\(/g,
-    `${RETAG_HELPER}($1, `,
-  );
-}
-
-/** Returns the source unchanged when it divides nothing, or can't be parsed. */
-export function rewriteDivision(source: string): string {
-  if (!source.includes("/")) return source;
-  const ts = typescript;
-  if (!ts) return source;
-
-  let file: any;
-  try {
-    file = ts.createSourceFile("mapping.ts", source, ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
-  } catch {
-    return source;
-  }
-
-  const isSimpleTarget = (node: any): boolean =>
-    node.kind === ts.SyntaxKind.Identifier ||
-    (node.kind === ts.SyntaxKind.PropertyAccessExpression && isSimpleTarget(node.expression)) ||
-    node.kind === ts.SyntaxKind.ThisKeyword;
-
-  const edits: Edit[] = [];
-  const visit = (node: any) => {
-    if (
-      node.kind === ts.SyntaxKind.BinaryExpression &&
-      node.operatorToken?.kind === ts.SyntaxKind.SlashToken
-    ) {
-      const left = ts.skipTrivia(source, node.left.pos);
-      const operator = ts.skipTrivia(source, node.operatorToken.pos);
-      edits.push({ at: left, length: 0, text: `${DIVIDE_HELPER}(` });
-      edits.push({ at: operator, length: node.operatorToken.end - operator, text: "," });
-      edits.push({ at: node.right.end, length: 0, text: ")" });
-    }
-    // `x /= y` divides too. Rewriting it needs the target twice, so it is only
-    // safe when reading the target has no effect of its own — an identifier or
-    // a dotted path. `a[i++] /= y` is left alone rather than evaluated twice.
-    if (
-      node.kind === ts.SyntaxKind.BinaryExpression &&
-      node.operatorToken?.kind === ts.SyntaxKind.SlashEqualsToken &&
-      isSimpleTarget(node.left)
-    ) {
-      const left = ts.skipTrivia(source, node.left.pos);
-      const target = source.slice(left, node.left.end);
-      const operator = ts.skipTrivia(source, node.operatorToken.pos);
-      edits.push({
-        at: operator,
-        length: node.operatorToken.end - operator,
-        text: `= ${DIVIDE_HELPER}(${target},`,
-      });
-      edits.push({ at: node.right.end, length: 0, text: ")" });
-    }
-    ts.forEachChild(node, visit);
-  };
-  try {
-    ts.forEachChild(file, visit);
-  } catch {
-    return source;
-  }
-  if (edits.length === 0) return source;
-
-  // Applied back to front so an outer division's insertion points stay valid
-  // while an inner one is rewritten.
-  edits.sort((a, b) => b.at - a.at || b.length - a.length);
-  let out = source;
-  for (const edit of edits) {
-    out = out.slice(0, edit.at) + edit.text + out.slice(edit.at + edit.length);
-  }
-  return out;
-}