envio 3.14.0-subgraph → 3.14.1

package/src/subgraph/assemblyscript.ts

@@ -1,85 +0,0 @@
-/**
- * The runtime half of `packages/cli/src/subgraph/assemblyscript.rs`, which
- * rewrites every arithmetic and comparison operator in a mapping into a call
- * on `OPERATORS_HELPER`, every `changetype<Foo>(x)` into one to `RETAG_HELPER`,
- * and exports each handler's event class as `EVENT_CLASSES_EXPORT`. The names
- * are shared with that file.
- */
-
-export const OPERATORS_HELPER = "__envio_op";
-export const RETAG_HELPER = "__envio_retag";
-export const EVENT_CLASSES_EXPORT = "__envio_event_classes";
-
-/**
- * AssemblyScript divides two integers as integers; this truncates only when
- * both operands really are integers and otherwise divides as before — an `f64`
- * divides as a float in AssemblyScript too.
- */
-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);
-}
-
-/** The graph-ts operator overload `value` declares under `method`, if any. */
-function overload(value: unknown, method: string): Function | undefined {
-  if (!isObject(value)) return undefined;
-  const fn = (value as Record<string, unknown>)[method];
-  return typeof fn === "function" ? fn : undefined;
-}
-
-function isObject(value: unknown): boolean {
-  return value !== null && typeof value === "object";
-}
-
-// Both operands are objects wherever AssemblyScript picks the overload — it
-// doesn't compile `BigInt < i32` — so a primitive on either side is left to
-// JavaScript, which reads the object through `valueOf`.
-const binary =
-  (method: string, fallback: (a: any, b: any) => unknown) =>
-  (a: unknown, b: unknown): unknown => {
-    const declared = isObject(b) ? overload(a, method) : undefined;
-    return declared ? declared.call(a, b) : fallback(a, b);
-  };
-
-// Against null AssemblyScript compares the reference, overload or not.
-const equals = (a: unknown, b: unknown): boolean => {
-  const declared = isObject(b) ? overload(a, "equals") : undefined;
-  return declared ? (declared.call(a, b) as boolean) : a == b;
-};
-
-/**
- * graph-ts overloads the arithmetic and comparison operators on `BigInt`,
- * `BigDecimal` and `ByteArray`, and AssemblyScript calls the overload: a
- * JavaScript operator would coerce them, or compare their identity — so
- * `address == ZERO_ADDRESS` would always be false.
- */
-export const operators = {
-  add: binary("plus", (a, b) => a + b),
-  sub: binary("minus", (a, b) => a - b),
-  mul: binary("times", (a, b) => a * b),
-  div: binary("div", integerDivision),
-  rem: binary("mod", (a, b) => a % b),
-  eq: equals,
-  ne: (a: unknown, b: unknown) => !equals(a, b),
-  lt: binary("lt", (a, b) => a < b),
-  le: binary("le", (a, b) => a <= b),
-  gt: binary("gt", (a, b) => a > b),
-  ge: binary("ge", (a, b) => a >= b),
-  neg: (a: unknown) => {
-    const declared = overload(a, "neg");
-    return declared ? declared.call(a) : -(a as number);
-  },
-};

package/src/subgraph/blocks.ts

@@ -1,183 +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 HyperSync range query per
- * cluster of nearby blocks rather than one round trip per block. An RPC endpoint, if one is configured,
- * is the fallback for whatever HyperSync couldn't answer.
- */
-
-import { rpcClient } from "./rpc.ts";
-
-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[] = [];
-
-export function configureBlockTimestamps(urls: string[]) {
-  rpcUrls = urls;
-  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);
-        }
-      });
-    }
-  });
-}
-
-/**
- * Gaps narrower than one response's worth of headers are fetched through
- * rather than split: a polling handler every few blocks is one query, one
- * every 100,000 is one tiny query per block.
- */
-const CLUSTER_GAP = 10_000;
-
-/** The requested blocks as `[from, to]` ranges, in order. */
-function clusters(blockNumbers: number[]): [number, number][] {
-  const sorted = [...blockNumbers].sort((a, b) => a - b);
-  const ranges: [number, number][] = [];
-  for (const blockNumber of sorted) {
-    const last = ranges[ranges.length - 1];
-    if (last && blockNumber - last[1] <= CLUSTER_GAP) last[1] = blockNumber;
-    else ranges.push([blockNumber, blockNumber]);
-  }
-  return ranges;
-}
-
-async function answer(chainId: number, blocks: Map<number, Waiter[]>) {
-  let timestamps = new Map<number, bigint>();
-
-  try {
-    const fetched = await Promise.all(
-      clusters([...blocks.keys()]).map(([from, to]) => fromHyperSync(chainId, from, to)),
-    );
-    timestamps = new Map(fetched.flatMap((cluster) => [...cluster]));
-  } 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.`,
-    );
-  }
-  const block = await rpcClient(rpcUrls).getBlock({ blockNumber: BigInt(blockNumber) });
-  return block.timestamp;
-}

package/src/subgraph/calls.ts

@@ -1,149 +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 { decodeFunctionResult, encodeFunctionData, parseAbiParameters, type Abi } from "viem";
-import * as Sury from "rescript-schema";
-import { createEffect } from "../Envio.res.mjs";
-import { missingRpcMessage } from "./errors.ts";
-import { rpcClient } from "./rpc.ts";
-import { parseSignature } from "./abi-types.ts";
-
-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;
-};
-
-/**
- * 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 rpcClient(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,83 +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 the
- * two agree, so a gap shows up as green types and a runtime error — the worst
- * feedback loop there is. This file closes it.
- *
- * The declarations come from the real package (see
- * `scripts/generate-graph-ts-types.mjs`). Every export is walked, and within
- * each class and namespace every static and every instance member, so a gap is
- * named down to the member — `ethereum.Value.fromAddress` — rather than hidden
- * behind a suppression covering a whole namespace. This file is type-checked,
- * never run.
- */
-
-import type * as GraphTs from "./graph-ts-types/index.js";
-import type * as Shim from "./graph-ts.ts";
-
-/** A class's statics: a mapped type drops the construct signature. */
-type Statics<T> = { [K in keyof T as K extends "prototype" ? never : K]: T[K] };
-
-type Agrees<Real, Ours, Path extends string> = [Ours] extends [Real] ? never : Path;
-
-/**
- * Deep enough to reach `ethereum.Value.fromAddress`, and no deeper: a member
- * past that is compared whole, which still catches any disagreement inside it.
- */
-type Member<Real, Ours, Path extends string, Depth extends unknown[]> = Depth["length"] extends 2
-  ? Agrees<Real, Ours, Path>
-  : // `any` would take every branch below at once.
-    0 extends 1 & Real
-    ? Agrees<Real, Ours, Path>
-    : // Bracketed so a union — an enum, `boolean` — is compared whole.
-      [Real] extends [(...args: any) => any]
-    ? Agrees<Real, Ours, Path>
-    : // A class, even one whose constructor is protected.
-      [Real] extends [{ prototype: infer RealInstance }]
-      ? [Ours] extends [{ prototype: infer OursInstance }]
-        ?
-            | Gaps<Statics<Real>, Statics<Ours>, `${Path}.`, [...Depth, unknown]>
-            | Gaps<RealInstance, OursInstance, `${Path}#`, [...Depth, unknown]>
-        : Path
-      : [Real] extends [object]
-        ? Gaps<Real, Ours, `${Path}.`, [...Depth, unknown]>
-        : Agrees<Real, Ours, Path>;
-
-/** Where `Ours` lacks or disagrees with `Real`, by path. */
-type Gaps<Real, Ours, Path extends string, Depth extends unknown[] = []> = {
-  [K in keyof Real & string]-?: K extends keyof Ours
-    ? Member<Real[K], Ours[K], `${Path}${K}`, Depth>
-    : `${Path}${K}`;
-}[keyof Real & string];
-
-type Found = Gaps<typeof GraphTs, typeof Shim, "">;
-
-/** Every gap the shim knows it has, and why. */
-type KnownGap =
-  // Chains envio doesn't index in subgraph mode.
-  | "cosmos"
-  | "near"
-  | "starknet"
-  | "Felt"
-  | "arweave.Block"
-  | "arweave.ProofOfAccess"
-  | "arweave.Tag"
-  | "arweave.Transaction"
-  | "arweave.TransactionWithBlockPtr"
-  // Refused at runtime: a YAML parser isn't shipped with the shim.
-  | `yaml.${string}`
-  | `YAMLValue${string}`
-  | `YAMLTaggedValue${string}`
-  // graph-ts declares `CallResult._value` private, which no other declaration
-  // can match; the shim's is structurally the same.
-  | "ethereum.CallResult.fromValue"
-  | "ethereum.SmartContract#tryCall";
-
-/** A known gap no longer found, whose entry should go. */
-type Closed<Gap> = Gap extends unknown ? ([Extract<Found, Gap>] extends [never] ? Gap : never) : never;
-
-// Keyed so a failure lists each path as a missing property.
-export const unlisted: Record<Exclude<Found, KnownGap>, "a gap KnownGap doesn't list"> = {};
-export const closed: Record<Closed<KnownGap>, "a KnownGap entry that no longer applies"> = {};

package/src/subgraph/errors.ts

@@ -1,96 +0,0 @@
-const ISSUES_URL = "https://github.com/enviodev/hyperindex/issues";
-
-/**
- * Subgraph mode ships under its own npm dist-tag (see `publish.yml`), so
- * `envio@latest` would move a project off it.
- */
-const UPGRADE_COMMAND = "pnpm add -D envio@subgraph";
-
-/** A feature we recognise and deliberately don't implement. */
-export function unsupported(feature: string, location: string): Error {
-  return new Error(
-    `Envio Subgraph doesn't support ${feature} yet.\n` +
-      `  Found in ${location}.\n` +
-      `First, make sure you're on the newest Envio Subgraph release — support may have landed:\n` +
-      `  ${UPGRADE_COMMAND}\n` +
-      `If you're up to date and need this feature, please open an issue (existing\n` +
-      `issues welcome a 👍 — demand drives prioritization):\n  ${ISSUES_URL}`,
-  );
-}
-
-/** Something we don't recognise at all: newer than us, or a typo. */
-export function unknown(thing: string, location: string): Error {
-  return new Error(
-    `Envio Subgraph doesn't know ${thing}.\n` +
-      `  Found in ${location}.\n` +
-      `This may be a feature newer than this envio version understands, or a typo.\n` +
-      `First, make sure you're on the newest Envio Subgraph release:\n` +
-      `  ${UPGRADE_COMMAND}\n` +
-      `If you're up to date and this is a real subgraph feature, please open an\n` +
-      `issue so we can add it: ${ISSUES_URL}`,
-  );
-}
-
-const RPC_ENV_VAR = "ENVIO_SUBGRAPH_RPC";
-
-/** §6b: contract calls need an endpoint HyperSync and HyperRPC don't serve. */
-export function missingRpcMessage(callSite: string): string {
-  return (
-    `This subgraph performs contract calls (${callSite}), which need an\n` +
-    `RPC endpoint — HyperSync and HyperRPC serve logs and blocks, not eth_call.\n` +
-    `Set one in .env or the environment:\n` +
-    `  ${RPC_ENV_VAR}=https://...\n` +
-    `Advanced (matches envio's rpc config; single entry or array):\n` +
-    `  ${RPC_ENV_VAR}={"url":"https://...","for":"fallback","headers":{...}}`
-  );
-}
-
-/**
- * Names a trap must answer for rather than refuse. AS-compiled mappings never
- * feature-detect, so nothing legitimate reaches these — but `console.log`,
- * `await` and `JSON.stringify` do, and they must not explode.
- */
-const PASSTHROUGH = new Set([
-  "then",
-  "toJSON",
-  "constructor",
-  "valueOf",
-  "toString",
-  "inspect",
-  "nodeType",
-  "$$typeof",
-  "@@__IMMUTABLE_ITERABLE__@@",
-]);
-
-function isPassthrough(prop: PropertyKey): boolean {
-  return typeof prop === "symbol" || PASSTHROUGH.has(prop as string);
-}
-
-export const PROTOTYPE_PASSTHROUGH = PASSTHROUGH;
-
-/**
- * Full Proxy for a graph-ts namespace object. Future graph-ts APIs are
- * unenumerable, so only a `get` trap can catch them; these are cold paths, so
- * the trap cost doesn't matter.
- */
-export function strictNamespace<T extends object>(name: string, target: T): T {
-  return new Proxy(target, {
-    get(target, prop, receiver) {
-      if (prop in target || isPassthrough(prop)) {
-        return Reflect.get(target, prop, receiver);
-      }
-      throw unknown(`the graph-ts API ${name}.${String(prop)}`, `a mapping handler`);
-    },
-  });
-}
-
-/** A known-but-refused field: enumerable, so a plain throwing getter is enough. */
-export function refusedGetter(object: object, prop: string, feature: string, location: string) {
-  Object.defineProperty(object, prop, {
-    enumerable: true,
-    configurable: true,
-    get() {
-      throw unsupported(feature, location);
-    },
-  });
-}

package/src/subgraph/graph-cli-worker.mjs

@@ -1,26 +0,0 @@
-// Runs one graph-cli command, as its own bin would, on the thread
-// `graph-cli.ts` sized for it. Plain JavaScript: the TypeScript loader envio
-// registers doesn't reach worker threads.
-import { parentPort, workerData } from "node:worker_threads";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-
-const { packageDir, command, argv } = workerData;
-
-let ok = true;
-try {
-  const { default: Command } = await import(
-    pathToFileURL(path.join(packageDir, "dist", "commands", `${command}.js`)).href
-  );
-  await Command.run(argv, packageDir);
-  // A generation failure is reported through the exit code, not a throw.
-  ok = process.exitCode === undefined || process.exitCode === 0;
-} catch (error) {
-  // oclif ends a successful command early by throwing an exit of 0.
-  if (error?.oclif?.exit !== 0) {
-    console.error(error?.message ?? error);
-    ok = false;
-  }
-}
-process.exitCode = 0;
-parentPort.postMessage(ok);