envio 3.7.0 → 3.9.0-resolvers.0

package/src/resolvers/server.js

@@ -0,0 +1,270 @@
+// The HTTP surface of the resolver process: one POST per caller -- Hasura's
+// action contract and envio-serve's -- and the two probes an orchestrator
+// restarts and routes on.
+//
+// Deliberately not a framework. The whole surface is three routes and a JSON
+// body with a size cap, and the one thing that must not drift is the wire
+// contract, which is easier to read as bytes in and bytes out.
+
+import { createServer } from "node:http";
+import { randomUUID, timingSafeEqual } from "node:crypto";
+import { RESOLVER_SECRET_HEADER } from "./hasuraMetadata.js";
+import { createDispatcher } from "./dispatch.js";
+import {
+  actionErrorBody,
+  badActionRequest,
+  toActionResponse,
+  toResolveRequest,
+} from "./hasuraAction.js";
+import { error as logError, warn as logWarn } from "../Logging.res.mjs";
+import { Resolvers as ResolversEnv } from "../Env.res.mjs";
+
+// Serve coerces arguments before dispatching, so a request is small by
+// construction. The cap is here because the socket is reachable by whatever
+// shares its network, not because a legitimate request could approach it.
+const MAX_REQUEST_BYTES = 1024 * 1024;
+
+function readBody(request, limit) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    request.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > limit) {
+        reject(new Error(`Request body exceeds ${limit} bytes`));
+        request.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    request.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    request.on("error", reject);
+  });
+}
+
+function send(response, status, body) {
+  const payload = JSON.stringify(body);
+  response.writeHead(status, {
+    "content-type": "application/json",
+    "content-length": Buffer.byteLength(payload),
+  });
+  response.end(payload);
+}
+
+// Constant time, so a wrong guess cannot be narrowed by how long the compare
+// took. Lengths are compared first because timingSafeEqual throws on a mismatch.
+function presentedSecret(request, expected) {
+  const presented = request.headers[RESOLVER_SECRET_HEADER];
+  if (typeof presented !== "string") return false;
+  const a = Buffer.from(presented);
+  const b = Buffer.from(expected);
+  return a.length === b.length && timingSafeEqual(a, b);
+}
+
+const wireError = (message, code) => ({
+  errors: [{ message, extensions: { code } }],
+});
+
+// What a readiness probe is prepared to wait for, and so what the check has to
+// answer within whether or not the database is the thing that is slow.
+const READYZ_BUDGET_MS = 2_000;
+
+/**
+ * The bound on each pooled operation the probe runs -- its `statement_timeout`
+ * and, because `forResolver` waits `min(poolWait, timeoutMs)` for a slot, its
+ * share of the pool queue too.
+ *
+ * Deliberately well under the wall-clock budget, and the probe runs two of
+ * them. A busy pool and a silent database are different faults: leaving room
+ * here is what lets the pool's own timeout surface first and name itself,
+ * instead of the budget firing and reporting a database that answered fine.
+ */
+export const READYZ_PROBE_MS = 500;
+
+/**
+ * Starts the resolver process's HTTP server.
+ *
+ * Resolves once the socket is listening, with the port it bound — pass
+ * `port: 0` to let the OS choose one.
+ */
+export async function startResolverServer(options) {
+  const { resolvers, pool, exposeErrors = false, checkCompatible, actionSecret } = options;
+  const port = options.port ?? ResolversEnv.port();
+  const host = options.host ?? "0.0.0.0";
+
+  // Otherwise the resolver is simply absent and nothing says why: the
+  // declaration asked for admin-only, and admin-only is unreachable until
+  // something can tell an admin caller from any other.
+  const unreachable = (resolvers ?? []).filter((resolver) => resolver?.admin === true);
+  if (actionSecret === undefined && unreachable.length > 0) {
+    logWarn(
+      `ENVIO_RESOLVERS_ACTION_SECRET is not set, so an 'admin' role in a request is only the caller's own claim and is not believed. ${unreachable
+        .map((resolver) => `'${resolver.name}'`)
+        .join(", ")} declared admin, so nothing can reach ${
+        unreachable.length > 1 ? "them" : "it"
+      } until the secret is set.`
+    );
+  }
+
+  const dispatch = createDispatcher({
+    resolvers,
+    pool,
+    exposeErrors,
+    onError:
+      options.onError ??
+      ((error, context) =>
+        logError(
+          `Resolver '${context.field}' failed (requestId ${context.requestId}): ${
+            error?.stack ?? error
+          }`
+        )),
+  });
+
+  const server = createServer((request, response) => {
+    const path = (request.url ?? "").split("?")[0];
+
+    if (request.method === "GET" && path === "/healthz") {
+      send(response, 200, { status: "ok" });
+      return;
+    }
+
+    if (request.method === "GET" && path === "/readyz") {
+      // Ready means the database answers and is the one this build indexes,
+      // not merely that the process is up: a resolver process that cannot
+      // reach Postgres has nothing to serve, and one pointed at a database
+      // indexed by a different build would answer with plausible wrong
+      // numbers.
+      //
+      // The budget is wall-clock, not just the query's `statement_timeout`.
+      // That only starts once `SET LOCAL` has been sent, so a Postgres that
+      // accepts the socket and never finishes the handshake is bounded by the
+      // pool's `connect_timeout` instead -- sized for the pool wait, and far
+      // past what a probe waits for. An orchestrator that gives up first marks
+      // the pod unready without the reason ever reaching it.
+      let answered = false;
+      let budget = null;
+      const answer = (status, payload) => {
+        if (answered) return;
+        answered = true;
+        clearTimeout(budget);
+        send(response, status, payload);
+      };
+      budget = setTimeout(
+        () =>
+          answer(503, {
+            status: "unavailable",
+            reason: `The database did not answer within ${READYZ_BUDGET_MS}ms.`,
+          }),
+        READYZ_BUDGET_MS
+      );
+      pool
+        .forResolver({ name: "readyz", timeoutMs: READYZ_PROBE_MS })
+        .sql.unsafe("SELECT 1;")
+        .then(async () => (checkCompatible ? await checkCompatible() : null))
+        .then((reason) =>
+          reason == null
+            ? answer(200, { status: "ok" })
+            : answer(503, { status: "incompatible", reason })
+        )
+        .catch((error) => {
+          answer(503, { status: "unavailable", reason: error.message });
+        });
+      return;
+    }
+
+    const isServe = request.method === "POST" && path === "/resolve";
+    const isAction = request.method === "POST" && path === "/hasura-action";
+
+    if (!isServe && !isAction) {
+      send(response, 404, wireError(`No route for ${request.method} ${path}`, "NOT_FOUND"));
+      return;
+    }
+
+    // Both routes take the caller's role from the request body -- `/resolve` as
+    // a field, `/hasura-action` in `session_variables` -- so on an open socket
+    // either is a way to assert `admin`. The gate belongs in front of both, and
+    // ahead of reading the body at all.
+    //
+    // With no secret configured there is no gate, and then an `admin` claim is
+    // self-certified: `admin: true` keeps a resolver off the public schema, so
+    // honouring the claim would leave it reachable by anything that can dial
+    // this process. Unauthenticated callers are therefore public, whatever they
+    // say they are -- the resolver is unreachable rather than unguarded.
+    if (actionSecret !== undefined && !presentedSecret(request, actionSecret)) {
+      const refusal = "This resolver service requires its shared secret on every request.";
+      send(
+        response,
+        403,
+        isAction ? actionErrorBody(refusal, "FORBIDDEN") : wireError(refusal, "FORBIDDEN")
+      );
+      return;
+    }
+
+    const asCaller = (parsed) =>
+      actionSecret !== undefined || parsed === null || typeof parsed !== "object"
+        ? parsed
+        : { ...parsed, role: "public" };
+
+    readBody(request, MAX_REQUEST_BYTES)
+      .then(async (raw) => {
+        let parsed;
+        try {
+          parsed = JSON.parse(raw);
+        } catch {
+          if (isAction) {
+            send(response, 400, actionErrorBody("Request body is not valid JSON", "BAD_REQUEST"));
+          } else {
+            send(response, 400, wireError("Request body is not valid JSON", "BAD_REQUEST"));
+          }
+          return;
+        }
+
+        if (isAction) {
+          const invalid = badActionRequest(parsed);
+          if (invalid !== null) {
+            send(
+              response,
+              400,
+              actionErrorBody(`Malformed action request: ${invalid}`, "BAD_REQUEST")
+            );
+            return;
+          }
+          const answer = await dispatch(asCaller(toResolveRequest(parsed, randomUUID())));
+          const { status, body } = toActionResponse(answer);
+          send(response, status, body);
+          return;
+        }
+
+        const answer = await dispatch(asCaller(parsed));
+        // A malformed request is the caller's error and says so in the status;
+        // everything a resolver itself produces is a 200 with a GraphQL-shaped
+        // body, because the operation as a whole still succeeded.
+        const isBadRequest =
+          answer.errors?.[0]?.extensions?.code === "BAD_REQUEST";
+        send(response, isBadRequest ? 400 : 200, answer);
+      })
+      .catch((error) => {
+        if (isAction) {
+          send(response, 400, actionErrorBody(error.message, "BAD_REQUEST"));
+        } else {
+          send(response, 400, wireError(error.message, "BAD_REQUEST"));
+        }
+      });
+  });
+
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, host, () => {
+      server.removeListener("error", reject);
+      resolve();
+    });
+  });
+
+  return {
+    port: server.address().port,
+    close: () =>
+      new Promise((resolve, reject) =>
+        server.close((error) => (error ? reject(error) : resolve()))
+      ),
+  };
+}

package/src/sources/AddressSet.res

@@ -1,47 +1,25 @@
-// Binding to the Rust `AddressSet` napi class: an immutable, ordered snapshot
-// of some of a chain's indexed addresses, handed to a fetch-state partition
-// instead of a JS address array. Sets are ordered by
-// `(effectiveStartBlock, address)`, so the same addresses always produce the
-// same set however they were registered or restored. Everything a query derives
-// from one (padded topics, the routing owner index, per-contract counts) is
-// built once inside Rust and shared by every query the partition makes.
 type t
 
 type startBlockGroup = {startBlock: int, count: int}
 
 @send external size: t => int = "size"
 
-// Live addresses of one contract, derived once per set inside Rust — so the
-// fetch state can size and split partitions without ever walking the addresses.
 @send external countFor: (t, string) => int = "countFor"
 
-// This set holds the address under the contract and it has already started at
-// the block — the gate a real source's router applies to a server-side
-// address-filtered query. The temporal half still comes from the store: a
-// merged partition's addresses don't all start at the same block.
 @send external containsAt: (t, Address.t, string, int) => bool = "containsAt"
 
 @send external contractNames: t => array<string> = "contractNames"
 
-// Distinct effective start blocks in this set, ascending — how partition
-// creation decides where one partition ends and the next begins.
 @send external startBlockGroups: t => array<startBlockGroup> = "startBlockGroups"
 
 @send external slice: (t, ~offset: int, ~limit: option<int>) => t = "slice"
 
-// Keeps only the named contracts' addresses, in set order.
 @send external filterByContracts: (t, array<string>) => t = "filterByContracts"
 
-// Drops addresses registered after the target block, and any the store has
-// tombstoned since this set was built.
 @send external filterByRegistrationBlock: (t, int) => t = "filterByRegistrationBlock"
 
-// Union with another set of the same store, keeping set order; duplicates
-// collapse.
 @send external merge: (t, t) => t = "merge"
 
-// Canonical address strings in set order. Not on a query path — queries read
-// the set's cached slices inside Rust.
 @send external addresses: t => array<Address.t> = "addresses"
 
 @send external entries: t => array<Internal.indexingContract> = "entries"

package/src/sources/AddressStore.res

@@ -1,62 +1,44 @@
-// Binding to the Rust `AddressStore` napi class: the chain-wide index of every
-// address being indexed, config-declared or dynamically registered. It owns
-// registration bookkeeping (conflict detection, `effectiveStartBlock`
-// derivation, reorg rollback) and hands out `AddressSet` snapshots for the
-// fetch state's partitions. One store lives per chain on `ChainState`, shared
-// with that chain's source clients — which read it to drop items whose emitter
-// (or address-valued param) isn't registered at the item's block.
 type t
 
-// A contract an address may be registered for. Every config contract of every
-// chain, since `context.chain.<Contract>.add` validates against that whole set
-// — a name outside it makes the store throw. `dependsOnAddresses` is whether
-// this chain fetches for the contract by address, which is what makes the store
-// able to answer `fetchable` on a verdict.
 type contract = {name: string, startBlock: option<int>, dependsOnAddresses: bool}
 
 type registration = {
   address: Address.t,
   contractName: string,
-  // -1 for a config address (not dynamically registered).
+  // -1 for a config address.
   registrationBlock: int,
 }
 
 type verdict =
-  // `fetchable` is false when nothing on the chain is fetched by address for the
-  // contract: the address is still stored and persisted, so a config that later
-  // adds events picks it up on restart, but no partition is built from it.
+  // False when nothing on this chain is fetched by address for the contract.
+  // The address is still stored and persisted.
   | Added({effectiveStartBlock: int, fetchable: bool})
-  // Already registered for the same contract.
   | Duplicate({effectiveStartBlock: int, existingEffectiveStartBlock: int})
-  // Already registered for a different contract.
-  | Conflict({existingContractName: string})
-  // Not a well-formed address for the ecosystem.
   | Invalid
 
 type rawVerdict = {
   kind: string,
   fetchable: bool,
   effectiveStartBlock: int,
-  existingContractName: Null.t<string>,
   existingEffectiveStartBlock: Null.t<int>,
 }
 
-// A registration the store handed over for persistence, paired with the
-// checkpoint that owns its row. `checkpointIdx` indexes the block numbers
-// passed to `drainForWrite` — the ids stay on the JS side.
-type drainedAddress = {
+type rejectedRow = {
   address: Address.t,
   contractName: string,
+  effectiveStartBlock: int,
+  existingEffectiveStartBlock: int,
+}
+
+type drainedAddress = {
+  address: NodeJs.Buffer.t,
+  contractId: int,
   registrationBlock: int,
   checkpointIdx: int,
 }
 
 type makeSetOptions = {
-  // Only addresses whose id is at or above this. Ids are handed out in
-  // registration order, so a cursor read before a batch (`nextId`) selects
-  // exactly what that batch added.
   minId?: int,
-  // Inclusive effectiveStartBlock bounds.
   fromStartBlock?: int,
   toStartBlock?: int,
   offset?: int,
@@ -68,9 +50,6 @@ external newEvm: (Core.addressStoreCtor, bool, array<contract>) => t = "newEvm"
 @send external newSvm: (Core.addressStoreCtor, array<contract>) => t = "newSvm"
 @send external newFuel: (Core.addressStoreCtor, array<contract>) => t = "newFuel"
 
-// The store's ecosystem is fixed here, from the chain's config, and decides how
-// address strings are parsed and rendered back. EVM carries the chain's
-// address-checksumming setting so entries render exactly as the sources do.
 let make = (~ecosystem: Ecosystem.name, ~shouldChecksum: bool, ~contracts: array<contract>): t => {
   let ctor = Core.getAddon().addressStore
   switch ecosystem {
@@ -80,34 +59,20 @@ let make = (~ecosystem: Ecosystem.name, ~shouldChecksum: bool, ~contracts: array
   }
 }
 
-// Every contract an address may be registered for, with the earliest block any
-// of this chain's events for it may fire at. `None` means unrestricted, so it
-// wins over any `Some`: one registration without a start block makes the whole
-// contract's address gate open from the chain's start, and the per-registration
-// start block still holds back the registrations that declared one.
-//
-// A contract whose events are all wildcard is fetched without consulting
-// addresses, so registering one changes nothing about what's queried — it
-// carries `dependsOnAddresses: false` just like a contract named only by
-// `configContractNames`. Either way the addresses are stored and persisted,
-// never fetched.
 let contractsOf = (
   ~onEventRegistrations: array<Internal.onEventRegistration>,
-  ~configContractNames: array<string>,
+  ~contractMapping: ContractMapping.t,
 ): array<contract> => {
-  // Only ever holds a declared start block, so a missing key is unambiguous —
-  // storing `None` in a dict would be indistinguishable from "not seen yet".
+  // Only ever holds a declared start block, so a missing key is unambiguous.
+  // Storing None in a dict would be indistinguishable from "not seen yet".
   let startBlocks: dict<int> = Dict.make()
   let unrestricted = Utils.Set.make()
   let addressDependent = Utils.Set.make()
-  let names = []
-  let addName = name =>
-    if !(names->Array.includes(name)) {
-      names->Array.push(name)->ignore
-    }
   onEventRegistrations->Array.forEach(reg => {
     let name = reg.eventConfig.contractName
-    addName(name)
+    contractMapping
+    ->ContractMapping.idOfOrThrow(name, ~context=" has event registrations but")
+    ->ignore
     if reg.dependsOnAddresses {
       addressDependent->Utils.Set.add(name)->ignore
     }
@@ -123,8 +88,9 @@ let contractsOf = (
       )
     }
   })
-  configContractNames->Array.forEach(addName)
-  names->Array.map(name => {
+  contractMapping
+  ->ContractMapping.names
+  ->Array.map(name => {
     name,
     startBlock: unrestricted->Utils.Set.has(name)
       ? None
@@ -135,45 +101,53 @@ let contractsOf = (
 
 @send external nextId: t => int = "nextId"
 
-// A set holding nothing — what an address-free (wildcard) partition carries, so
-// every partition is queried through the same handle.
 @send external emptySet: t => AddressSet.t = "emptySet"
 
-// A set over exactly these addresses, in set order. Every set of a chain must
-// come from that chain's one store — ids are store-scoped, so sets from
-// different stores can't be merged.
-@send external makeSetOf: (t, array<Address.t>) => AddressSet.t = "makeSetOf"
 @send
 external registerBatchRaw: (t, array<registration>) => array<rawVerdict> = "registerBatch"
 @send external seedBatchRaw: (t, array<registration>) => array<rawVerdict> = "seedBatch"
 
-// Drains the registrations awaiting persistence at or below the given block —
-// what the batch being written covers — pairing each with the checkpoint at its
-// registration block. Later registrations stay pending. Throws, with the queue
-// untouched, when a drained registration's block has no checkpoint in the batch.
+@send
+external seedRowsRaw: (
+  t,
+  NodeJs.Buffer.t,
+  array<int>,
+  array<int>,
+  array<int>,
+) => array<rejectedRow> = "seedRows"
+
+let seedRows = (store: t, rows: AddressRows.seedRows) => {
+  let (bytes, lengths) = AddressRows.packBuffers(rows.addresses)
+  store->seedRowsRaw(bytes, lengths, rows.contractIds, rows.registrationBlocks)
+}
+
+// Throws with the queue untouched when a drained registration's block has no
+// checkpoint in the batch.
 @send
 external drainForWrite: (t, int, array<int>) => array<drainedAddress> = "drainForWrite"
 
-// How many registrations await persistence — lets a caller skip the work of
-// assembling what `drainForWrite` needs.
 @send external pendingCount: t => int = "pendingCount"
 
-// The registrations still awaiting persistence. For assertions.
 @send external pendingEntries: t => array<Internal.indexingContract> = "pendingEntries"
 @send external makeSetRaw: (t, string, makeSetOptions) => AddressSet.t = "makeSet"
 @send external contractCount: (t, string) => int = "contractCount"
+
+type contractAddressCount = {contractName: string, count: int}
+
+@send external contractCounts: t => array<contractAddressCount> = "contractCounts"
 @send external size: t => int = "size"
 
-// The chain-wide gate routing applies, exposed for the simulate source — it has
-// no real query boundary to gate at.
 @send external isIndexedAt: (t, Address.t, string, int) => bool = "isIndexedAt"
 
-// Drops every address registered after the target block, returning how many
-// were dropped. Ids are tombstoned rather than reused, so sets built before the
-// rollback still point at the right entries.
-@send external rollback: (t, int) => int = "rollback"
+type rolledBackAddress = {address: NodeJs.Buffer.t, contractId: int}
 
-@send external getRaw: (t, Address.t) => Null.t<Internal.indexingContract> = "get"
+// Ids are tombstoned rather than reused, so sets built before the rollback
+// still point at the right entries.
+@send external rollback: (t, int) => array<rolledBackAddress> = "rollback"
+
+@send external getAll: (t, Address.t) => array<Internal.indexingContract> = "getAll"
+
+@send external dynamicContractNames: t => array<string> = "dynamicContractNames"
 
 @send external contractAddresses: (t, string) => array<Address.t> = "contractAddresses"
 
@@ -185,30 +159,16 @@ let toVerdict = (raw: rawVerdict): verdict =>
       effectiveStartBlock: raw.effectiveStartBlock,
       existingEffectiveStartBlock: raw.existingEffectiveStartBlock->Null.getUnsafe,
     })
-  | "conflict" => Conflict({existingContractName: raw.existingContractName->Null.getUnsafe})
   | "invalid" => Invalid
   | kind => JsError.throwWithMessage(`Unexpected address registration verdict "${kind}"`)
   }
 
-// Registers dynamic registrations, resolving each address against both the
-// store and the batch's own earlier entries — so two contracts claiming one
-// address inside a single batch conflict just as they would across batches.
-// Verdicts come back in the batch's order. What it adds is pending persistence
-// until a batch write drains it.
-//
 // An unknown contract name throws with none of the batch applied.
 let registerBatch = (store: t, registrations: array<registration>): array<verdict> =>
   store->registerBatchRaw(registrations)->Array.map(toVerdict)
 
-// `registerBatch` for addresses the database already holds — config addresses
-// and the dynamic ones a resume restores. Nothing is marked pending, so nothing
-// is ever written back.
 let seedBatch = (store: t, registrations: array<registration>): array<verdict> =>
   store->seedBatchRaw(registrations)->Array.map(toVerdict)
 
 let makeSet = (store: t, ~contractName, ~options={}: makeSetOptions) =>
   store->makeSetRaw(contractName, options)
-
-// The entry an address is registered under, whichever contract holds it —
-// addresses are unique chain-wide. `None` once rolled back.
-let get = (store: t, address) => store->getRaw(address)->Null.toOption

package/src/sources/AddressStore.res.mjs

@@ -1,9 +1,10 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Core from "../Core.res.mjs";
+import * as AddressRows from "../AddressRows.res.mjs";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
-import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as ContractMapping from "../ContractMapping.res.mjs";
 
 function make(ecosystem, shouldChecksum, contracts) {
   let ctor = Core.getAddon().AddressStore;
@@ -17,20 +18,13 @@ function make(ecosystem, shouldChecksum, contracts) {
   }
 }
 
-function contractsOf(onEventRegistrations, configContractNames) {
+function contractsOf(onEventRegistrations, contractMapping) {
   let startBlocks = {};
   let unrestricted = new Set();
   let addressDependent = new Set();
-  let names = [];
-  let addName = name => {
-    if (!names.includes(name)) {
-      names.push(name);
-      return;
-    }
-  };
   onEventRegistrations.forEach(reg => {
     let name = reg.eventConfig.contractName;
-    addName(name);
+    ContractMapping.idOfOrThrow(contractMapping, name, " has event registrations but");
     if (reg.dependsOnAddresses) {
       addressDependent.add(name);
     }
@@ -42,14 +36,18 @@ function contractsOf(onEventRegistrations, configContractNames) {
     }
     unrestricted.add(name);
   });
-  configContractNames.forEach(addName);
-  return names.map(name => ({
+  return ContractMapping.names(contractMapping).map(name => ({
     name: name,
     startBlock: unrestricted.has(name) ? undefined : startBlocks[name],
     dependsOnAddresses: addressDependent.has(name)
   }));
 }
 
+function seedRows(store, rows) {
+  let match = AddressRows.packBuffers(rows.addresses);
+  return store.seedRows(match[0], match[1], rows.contractIds, rows.registrationBlocks);
+}
+
 function toVerdict(raw) {
   let kind = raw.kind;
   switch (kind) {
@@ -59,11 +57,6 @@ function toVerdict(raw) {
         effectiveStartBlock: raw.effectiveStartBlock,
         fetchable: raw.fetchable
       };
-    case "conflict" :
-      return {
-        TAG: "Conflict",
-        existingContractName: raw.existingContractName
-      };
     case "duplicate" :
       return {
         TAG: "Duplicate",
@@ -90,17 +83,13 @@ function makeSet(store, contractName, optionsOpt) {
   return store.makeSet(contractName, options);
 }
 
-function get(store, address) {
-  return Primitive_option.fromNull(store.get(address));
-}
-
 export {
   make,
   contractsOf,
+  seedRows,
   toVerdict,
   registerBatch,
   seedBatch,
   makeSet,
-  get,
 }
 /* Core Not a pure module */

package/src/sources/Evm.res

@@ -77,6 +77,8 @@ let make = (~logger: Pino.t): Ecosystem.t => {
   blockTimestampName: "timestamp",
   blockHashName: "hash",
   onBlockMethodName: "onBlock",
+  contractNoun: "contract",
+  eventNoun: "event",
   // EVM filter shape: `{block: {number: {_gte?, _lte?, _every?}}}`.
   // The inner range chunk is returned as raw `S.unknown` and parsed a
   // second time in `Main.res` by the shared `blockRangeSchema`.

package/src/sources/Evm.res.mjs

@@ -56,6 +56,8 @@ function make(logger) {
     blockTimestampName: "timestamp",
     blockHashName: "hash",
     onBlockMethodName: "onBlock",
+    contractNoun: "contract",
+    eventNoun: "event",
     onBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.object(s2 => s2.f("number", S$RescriptSchema.unknown))))),
     onEventBlockFilterSchema: S$RescriptSchema.object(s => s.f("block", S$RescriptSchema.option(S$RescriptSchema.strict(S$RescriptSchema.object(s2 => s2.f("number", S$RescriptSchema.unknown)))))),
     logger: logger,

package/src/sources/EvmHyperSyncSource.res

@@ -1,7 +1,8 @@
 open Source
 
-// Surfaced by HyperSyncClient.getHeight (Rust) when HyperSync rejects the API
-// token. The corrupted-token test feeds the real server error through this
+// Surfaced by the HyperSync client (Rust) when HyperSync rejects the API
+// token. The corrupted-token test feeds the real server error (from the query
+// endpoint; the edge no longer 401s malformed tokens on /height) through this
 // check so it can't silently drift away from what getHeightOrThrow guards on.
 let isUnauthorizedError = (message: string) => message->String.includes("401 Unauthorized")