envio 3.5.0-alpha.1 → 3.5.0-alpha.2

package/src/bindings/Vitest.res

@@ -34,7 +34,6 @@ type rec expectation<'a> = {
   toHavePropertyValue: 'b. (string, 'b) => unit,
   // Exception matchers
   toThrow: unit => unit,
-  toThrowError: string => unit,
   // Snapshot matchers
   toMatchSnapshot: unit => unit,
   // Negation
@@ -151,3 +150,25 @@ module Async = {
 
 @module("vitest")
 external expect: ('a, ~message: string=?) => expectation<'a> = "expect"
+
+// Runs `fn` and returns the thrown error's message — mirroring JS's
+// `e instanceof Error ? e.message : String(e)` — or `None` when nothing threw.
+let messageOfThrown: (unit => 'a) => option<string> = %raw(`function (fn) {
+  try {
+    fn();
+    return undefined;
+  } catch (e) {
+    return e instanceof Error ? e.message : String(e);
+  }
+}`)
+
+// Strict counterpart to the built-in `toThrow`, which only checks that the
+// thrown message *contains* the expected string. `toThrowErrorEqual` requires
+// the whole message to match, so a test can pin the complete error text.
+// A plain ReScript function (not a custom `expect.extend` matcher), so it needs
+// no per-package vitest setup.
+// Compared as options rather than through a "didn't throw" placeholder string,
+// so a function that throws nothing can never match — not even when `expected`
+// happens to equal the placeholder.
+let toThrowErrorEqual = (t: testContext, fn: unit => 'a, ~message=?, expected: string) =>
+  t.expect(fn->messageOfThrown, ~message?).toEqual(Some(expected))

package/src/bindings/Vitest.res.mjs

@@ -13,7 +13,22 @@ let Async = {
   itSkipInClaudeCloud: itSkipInClaudeCloud
 };
 
+let messageOfThrown = (function (fn) {
+  try {
+    fn();
+    return undefined;
+  } catch (e) {
+    return e instanceof Error ? e.message : String(e);
+  }
+});
+
+function toThrowErrorEqual(t, fn, message, expected) {
+  t.expect(messageOfThrown(fn), message).toEqual(expected);
+}
+
 export {
   Async,
+  messageOfThrown,
+  toThrowErrorEqual,
 }
 /* isClaudeCloud Not a pure module */

package/src/db/EntityHistory.res

@@ -30,12 +30,14 @@ let unsafeCheckpointIdSchema =
     serializer: bigint => bigint->BigInt.toString,
   })
 
-let makeSetUpdateSchema: S.t<'entity> => S.t<Change.t<'entity>> = entitySchema => {
+let makeSetUpdateSchema = (~idSchema: S.t<EntityId.t>, entitySchema: S.t<'entity>): S.t<
+  Change.t<'entity>,
+> => {
   S.object(s => {
     s.tag(changeFieldName, RowAction.SET)
     Change.Set({
       checkpointId: s.field(checkpointIdFieldName, unsafeCheckpointIdSchema),
-      entityId: s.field(Table.idFieldName, S.string),
+      entityId: s.field(Table.idFieldName, idSchema),
       entity: s.flatten(entitySchema),
     })
   })
@@ -118,10 +120,10 @@ let pruneStaleEntityHistory = (
 
 // If an entity doesn't have a history before the update
 // we create it automatically with envio_checkpoint_id 0
-let makeBackfillHistoryQuery = (~pgSchema, ~entityName, ~entityIndex) => {
+let makeBackfillHistoryQuery = (~pgSchema, ~entityName, ~entityIndex, ~idPgType) => {
   let historyTableRef = `"${pgSchema}"."${historyTableName(~entityName, ~entityIndex)}"`
   `WITH target_ids AS (
-  SELECT UNNEST($1::${(Text: Postgres.columnType :> string)}[]) AS id
+  SELECT UNNEST($1::${idPgType}[]) AS id
 ),
 missing_history AS (
   SELECT e.*
@@ -135,11 +137,18 @@ SELECT *, 0 AS ${checkpointIdFieldName}, '${(RowAction.SET :> string)}' as ${cha
 FROM missing_history;`
 }
 
-let backfillHistory = (sql, ~pgSchema, ~entityName, ~entityIndex, ~ids: array<string>) => {
+let backfillHistory = (
+  sql,
+  ~pgSchema,
+  ~table: Table.table,
+  ~entityIndex,
+  ~ids: array<EntityId.t>,
+) => {
+  let idPgType = table->Table.getIdPgFieldType(~pgSchema)
   sql
   ->Postgres.preparedUnsafe(
-    makeBackfillHistoryQuery(~entityName, ~entityIndex, ~pgSchema),
-    [ids]->Obj.magic,
+    makeBackfillHistoryQuery(~entityName=table.tableName, ~entityIndex, ~pgSchema, ~idPgType),
+    [table->Table.encodeIdsToJson(ids)]->(Utils.magic: array<JSON.t> => unknown),
   )
   ->Utils.Promise.ignoreValue
 }

package/src/db/EntityHistory.res.mjs

@@ -48,12 +48,12 @@ let unsafeCheckpointIdSchema = S$RescriptSchema.transform(S$RescriptSchema.setNa
   s: bigint => bigint.toString()
 }));
 
-function makeSetUpdateSchema(entitySchema) {
+function makeSetUpdateSchema(idSchema, entitySchema) {
   return S$RescriptSchema.object(s => {
     s.tag(changeFieldName, "SET");
     return {
       type: "SET",
-      entityId: s.f(Table.idFieldName, S$RescriptSchema.string),
+      entityId: s.f(Table.idFieldName, idSchema),
       entity: s.flatten(entitySchema),
       checkpointId: s.f(checkpointIdFieldName, unsafeCheckpointIdSchema)
     };
@@ -97,10 +97,10 @@ function pruneStaleEntityHistory(sql, entityName, entityIndex, pgSchema, safeChe
   return sql.unsafe(makePruneStaleEntityHistoryQuery(entityName, entityIndex, pgSchema), [safeCheckpointId.toString()], {prepare: true});
 }
 
-function makeBackfillHistoryQuery(pgSchema, entityName, entityIndex) {
+function makeBackfillHistoryQuery(pgSchema, entityName, entityIndex, idPgType) {
   let historyTableRef = `"` + pgSchema + `"."` + historyTableName(entityName, entityIndex) + `"`;
   return `WITH target_ids AS (
-  SELECT UNNEST($1::` + "TEXT" + `[]) AS id
+  SELECT UNNEST($1::` + idPgType + `[]) AS id
 ),
 missing_history AS (
   SELECT e.*
@@ -114,8 +114,9 @@ SELECT *, 0 AS ` + checkpointIdFieldName + `, '` + "SET" + `' as ` + changeField
 FROM missing_history;`;
 }
 
-function backfillHistory(sql, pgSchema, entityName, entityIndex, ids) {
-  return sql.unsafe(makeBackfillHistoryQuery(pgSchema, entityName, entityIndex), [ids], {prepare: true});
+function backfillHistory(sql, pgSchema, table, entityIndex, ids) {
+  let idPgType = Table.getIdPgFieldType(table, pgSchema);
+  return sql.unsafe(makeBackfillHistoryQuery(pgSchema, table.tableName, entityIndex, idPgType), [Table.encodeIdsToJson(table, ids)], {prepare: true});
 }
 
 function rollback(sql, pgSchema, entityName, entityIndex, rollbackTargetCheckpointId) {

package/src/db/Table.res

@@ -31,7 +31,6 @@ type fieldType =
   | Json
   | Date
   | Enum({config: enumConfig<enum>})
-  | Entity({name: string})
 
 type field = {
   fieldName: string,
@@ -168,7 +167,6 @@ let getPgFieldType = (
   | Date =>
     (isNullable ? Postgres.TimestampWithTimezoneNull : Postgres.TimestampWithTimezone :> string)
   | Enum({config}) => `"${pgSchema}".${config.name}`
-  | Entity(_) => (Postgres.Text :> string) // FIXME: Will it work correctly if id is not a text column?
   }
 
   // Workaround for Hasura bug https://github.com/enviodev/hyperindex/issues/788
@@ -248,6 +246,40 @@ let getDerivedFromFields = table =>
 let getFieldByName = (table, fieldName) =>
   table.fields->Array.find(field => field->getUserDefinedFieldName === fieldName)
 
+exception NoIdField(string)
+
+// The `id` primary-key field. Its type drives both the id column and every
+// foreign key that references the entity, so id-typed SQL (delete-by-id,
+// history backfill) reads the column type and value schema from here.
+let getIdFieldOrThrow = (table): field =>
+  switch table->getFieldByName(idFieldName) {
+  | Some(Field(field)) => field
+  | _ => throw(NoIdField(table.tableName))
+  }
+
+let getIdPgFieldType = (table, ~pgSchema) =>
+  getPgFieldType(
+    ~fieldType=(table->getIdFieldOrThrow).fieldType,
+    ~pgSchema,
+    ~isArray=false,
+    ~isNumericArrayAsText=false,
+    ~isNullable=false,
+  )
+
+// Schema for a single id value, typed opaquely so id-generic code can serialize
+// ids regardless of the underlying scalar.
+let getIdSchema = (table): S.t<EntityId.t> =>
+  (table->getIdFieldOrThrow).fieldSchema->(Utils.magic: S.t<unknown> => S.t<EntityId.t>)
+
+// Serializes an array of ids to the JSON form the SQL layer binds. The array
+// schema is memoized per table so its serializer compiles once, not on every
+// (high-frequency) delete/history write.
+let idsArraySchema: table => S.t<array<EntityId.t>> = Utils.WeakMap.memoize(table =>
+  S.array(table->getIdSchema)
+)
+let encodeIdsToJson = (table, ids: array<EntityId.t>): JSON.t =>
+  ids->S.reverseConvertToJsonOrThrow(table->idsArraySchema)
+
 // TODO: Test whether it should be passed via args and match the column type
 
 let getFieldByApiName = (table, apiFieldName) =>
@@ -297,13 +329,12 @@ let makeRowsSchema = (table, ~rowFieldName) =>
   S.array(
     S.object(s => {
       let dict = Dict.make()
-      table.fields->Array.forEach(
-        field =>
-          switch field {
-          | Field(field) =>
-            dict->Dict.set(field->getApiFieldName, s.field(field->rowFieldName, field.fieldSchema))
-          | DerivedFrom(_) => ()
-          },
+      table.fields->Array.forEach(field =>
+        switch field {
+        | Field(field) =>
+          dict->Dict.set(field->getApiFieldName, s.field(field->rowFieldName, field.fieldSchema))
+        | DerivedFrom(_) => ()
+        }
       )
       dict
     })->(Utils.magic: S.t<dict<unknown>> => S.t<unknown>),

package/src/db/Table.res.mjs

@@ -94,6 +94,8 @@ function getPgFieldName(fieldOrDerived) {
   }
 }
 
+let idFieldName = "id";
+
 function getPgFieldType(fieldType, pgSchema, isArray, isNumericArrayAsText, isNullable) {
   let columnType;
   if (typeof fieldType !== "object") {
@@ -142,9 +144,6 @@ function getPgFieldType(fieldType, pgSchema, isArray, isNumericArrayAsText, isNu
       case "Enum" :
         columnType = `"` + pgSchema + `".` + fieldType.config.name;
         break;
-      case "Entity" :
-        columnType = "TEXT";
-        break;
     }
   }
   let isNumericAsText = isArray && isNumericArrayAsText;
@@ -226,6 +225,41 @@ function getFieldByName(table, fieldName) {
   return table.fields.find(field => getUserDefinedFieldName(field) === fieldName);
 }
 
+let NoIdField = /* @__PURE__ */Primitive_exceptions.create("Table.NoIdField");
+
+function getIdFieldOrThrow(table) {
+  let match = getFieldByName(table, idFieldName);
+  if (match !== undefined) {
+    if (match.TAG === "Field") {
+      return match._0;
+    }
+    throw {
+      RE_EXN_ID: NoIdField,
+      _1: table.tableName,
+      Error: new Error()
+    };
+  }
+  throw {
+    RE_EXN_ID: NoIdField,
+    _1: table.tableName,
+    Error: new Error()
+  };
+}
+
+function getIdPgFieldType(table, pgSchema) {
+  return getPgFieldType(getIdFieldOrThrow(table).fieldType, pgSchema, false, false, false);
+}
+
+function getIdSchema(table) {
+  return getIdFieldOrThrow(table).fieldSchema;
+}
+
+let idsArraySchema = Utils.$$WeakMap.memoize(table => S$RescriptSchema.array(getIdFieldOrThrow(table).fieldSchema));
+
+function encodeIdsToJson(table, ids) {
+  return S$RescriptSchema.reverseConvertToJsonOrThrow(ids, idsArraySchema(table));
+}
+
 function getFieldByApiName(table, apiFieldName) {
   return table.fields.find(field => {
     let tmp;
@@ -408,8 +442,6 @@ function getCompositeIndices(table) {
   return getUnfilteredCompositeIndicesUnsafe(table).filter(ind => ind.length > 1);
 }
 
-let idFieldName = "id";
-
 export {
   makeEnumConfig,
   mkField,
@@ -429,6 +461,12 @@ export {
   getLinkedEntityFields,
   getDerivedFromFields,
   getFieldByName,
+  NoIdField,
+  getIdFieldOrThrow,
+  getIdPgFieldType,
+  getIdSchema,
+  idsArraySchema,
+  encodeIdsToJson,
   getFieldByApiName,
   queryFields,
   makeRowsSchema,
@@ -440,4 +478,4 @@ export {
   getSingleIndices,
   getCompositeIndices,
 }
-/* queryFields Not a pure module */
+/* idsArraySchema Not a pure module */

package/src/sources/AddressSet.res

@@ -0,0 +1,48 @@
+// 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"
+
+// The chain-wide address gate, reachable through any set of the store. Not set
+// membership: the simulate source has no native query boundary, so it applies
+// the same gate every real source applies while routing.
+@send external has: (t, Address.t, string, int) => bool = "has"
+
+@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"
+
+let isEmpty = (set: t) => set->size === 0

package/src/sources/AddressSet.res.mjs

@@ -0,0 +1,11 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function isEmpty(set) {
+  return set.size() === 0;
+}
+
+export {
+  isEmpty,
+}
+/* No side effect */

package/src/sources/AddressStore.res

@@ -0,0 +1,152 @@
+// 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 the chain has events for. An address registered for anything else
+// gets the `NoEvents` verdict: persisted so a future config that adds events
+// picks it up, but never fetched.
+type contract = {name: string, startBlock: option<int>}
+
+type registration = {
+  address: Address.t,
+  contractName: string,
+  // -1 for a config address (not dynamically registered).
+  registrationBlock: int,
+}
+
+type verdict =
+  | Added({effectiveStartBlock: int})
+  // Contract has no events; tracked and persisted, never fetched.
+  | NoEvents({effectiveStartBlock: int})
+  // 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,
+  effectiveStartBlock: int,
+  existingContractName: Null.t<string>,
+  existingEffectiveStartBlock: Null.t<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,
+  limit?: int,
+}
+
+@send
+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 {
+  | Evm => ctor->newEvm(shouldChecksum, contracts)
+  | Svm => ctor->newSvm(contracts)
+  | Fuel => ctor->newFuel(contracts)
+  }
+}
+
+// The contracts of a chain that have events, with the earliest block any of
+// their events may fire at.
+let contractsOf = (~onEventRegistrations: array<Internal.onEventRegistration>): array<contract> => {
+  let startBlocks = Dict.make()
+  let names = []
+  onEventRegistrations->Array.forEach(reg => {
+    let name = reg.eventConfig.contractName
+    switch startBlocks->Utils.Dict.dangerouslyGetNonOption(name) {
+    | None =>
+      names->Array.push(name)->ignore
+      startBlocks->Dict.set(name, reg.startBlock)
+    | Some(existing) =>
+      startBlocks->Dict.set(
+        name,
+        switch (existing, reg.startBlock) {
+        | (Some(a), Some(b)) => Some(Pervasives.min(a, b))
+        | (Some(_) as s, None) | (None, Some(_) as s) => s
+        | (None, None) => None
+        },
+      )
+    }
+  })
+  names->Array.map(name => {name, startBlock: startBlocks->Dict.getUnsafe(name)})
+}
+
+@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 makeSetRaw: (t, string, makeSetOptions) => AddressSet.t = "makeSet"
+@send
+external startBlockGroups: (t, string) => array<AddressSet.startBlockGroup> = "startBlockGroups"
+@send external contractCount: (t, string) => int = "contractCount"
+@send external size: t => int = "size"
+
+// The gate routing applies, exposed for the simulate source — it has no real
+// query boundary to gate at.
+@send external has: (t, Address.t, string, int) => bool = "has"
+
+// 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"
+
+@send external getRaw: (t, Address.t) => Null.t<Internal.indexingContract> = "get"
+
+@send external contractAddresses: (t, string) => array<Address.t> = "contractAddresses"
+
+@send external entries: t => array<Internal.indexingContract> = "entries"
+
+let toVerdict = (raw: rawVerdict): verdict =>
+  switch raw.kind {
+  | "added" => Added({effectiveStartBlock: raw.effectiveStartBlock})
+  | "noEvents" => NoEvents({effectiveStartBlock: raw.effectiveStartBlock})
+  | "duplicate" =>
+    Duplicate({
+      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 a batch, 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.
+let registerBatch = (store: t, registrations: array<registration>): array<verdict> =>
+  store->registerBatchRaw(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

@@ -0,0 +1,97 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Core from "../Core.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";
+
+function make(ecosystem, shouldChecksum, contracts) {
+  let ctor = Core.getAddon().AddressStore;
+  switch (ecosystem) {
+    case "evm" :
+      return ctor.newEvm(shouldChecksum, contracts);
+    case "fuel" :
+      return ctor.newFuel(contracts);
+    case "svm" :
+      return ctor.newSvm(contracts);
+  }
+}
+
+function contractsOf(onEventRegistrations) {
+  let startBlocks = {};
+  let names = [];
+  onEventRegistrations.forEach(reg => {
+    let name = reg.eventConfig.contractName;
+    let existing = startBlocks[name];
+    if (existing !== undefined) {
+      let existing$1 = Primitive_option.valFromOption(existing);
+      let match = reg.startBlock;
+      startBlocks[name] = existing$1 !== undefined ? (
+          match !== undefined ? Primitive_int.min(existing$1, match) : existing$1
+        ) : (
+          match !== undefined ? match : undefined
+        );
+      return;
+    }
+    names.push(name);
+    startBlocks[name] = reg.startBlock;
+  });
+  return names.map(name => ({
+    name: name,
+    startBlock: startBlocks[name]
+  }));
+}
+
+function toVerdict(raw) {
+  let kind = raw.kind;
+  switch (kind) {
+    case "added" :
+      return {
+        TAG: "Added",
+        effectiveStartBlock: raw.effectiveStartBlock
+      };
+    case "conflict" :
+      return {
+        TAG: "Conflict",
+        existingContractName: raw.existingContractName
+      };
+    case "duplicate" :
+      return {
+        TAG: "Duplicate",
+        effectiveStartBlock: raw.effectiveStartBlock,
+        existingEffectiveStartBlock: raw.existingEffectiveStartBlock
+      };
+    case "invalid" :
+      return "Invalid";
+    case "noEvents" :
+      return {
+        TAG: "NoEvents",
+        effectiveStartBlock: raw.effectiveStartBlock
+      };
+    default:
+      return Stdlib_JsError.throwWithMessage(`Unexpected address registration verdict "` + kind + `"`);
+  }
+}
+
+function registerBatch(store, registrations) {
+  return store.registerBatch(registrations).map(toVerdict);
+}
+
+function makeSet(store, contractName, optionsOpt) {
+  let options = optionsOpt !== undefined ? optionsOpt : ({});
+  return store.makeSet(contractName, options);
+}
+
+function get(store, address) {
+  return Primitive_option.fromNull(store.get(address));
+}
+
+export {
+  make,
+  contractsOf,
+  toVerdict,
+  registerBatch,
+  makeSet,
+  get,
+}
+/* Core Not a pure module */

package/src/sources/EvmChain.res

@@ -45,6 +45,7 @@ let makeSources = (
   ~hyperSync,
   ~rpcs: array<rpc>,
   ~lowercaseAddresses,
+  ~addressStore,
 ) => {
   let sources = switch hyperSync {
   | Some(endpointUrl) => [
@@ -58,6 +59,7 @@ let makeSources = (
         serializationFormat: Env.hypersyncClientSerializationFormat,
         enableQueryCaching: Env.hypersyncClientEnableQueryCaching,
         logLevel: Env.hypersyncLogLevel,
+        addressStore,
       }),
     ]
   | _ => []
@@ -70,6 +72,7 @@ let makeSources = (
       url,
       onEventRegistrations,
       lowercaseAddresses,
+      addressStore,
       ?ws,
       ?headers,
     })

package/src/sources/EvmChain.res.mjs

@@ -19,7 +19,7 @@ function getSyncConfig(param) {
   };
 }
 
-function makeSources(chain, onEventRegistrations, hyperSync, rpcs, lowercaseAddresses) {
+function makeSources(chain, onEventRegistrations, hyperSync, rpcs, lowercaseAddresses, addressStore) {
   let sources = hyperSync !== undefined ? [EvmHyperSyncSource.make({
         chain: chain,
         endpointUrl: hyperSync,
@@ -29,7 +29,8 @@ function makeSources(chain, onEventRegistrations, hyperSync, rpcs, lowercaseAddr
         lowercaseAddresses: lowercaseAddresses,
         serializationFormat: Env.hypersyncClientSerializationFormat,
         enableQueryCaching: Env.hypersyncClientEnableQueryCaching,
-        logLevel: Env.hypersyncLogLevel
+        logLevel: Env.hypersyncLogLevel,
+        addressStore: addressStore
       })] : [];
   rpcs.forEach(param => {
     let source = RpcSource.make({
@@ -39,6 +40,7 @@ function makeSources(chain, onEventRegistrations, hyperSync, rpcs, lowercaseAddr
       chain: chain,
       onEventRegistrations: onEventRegistrations,
       lowercaseAddresses: lowercaseAddresses,
+      addressStore: addressStore,
       ws: param.ws,
       headers: param.headers
     });