envio 3.8.0 → 3.9.0

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/SvmHyperSyncClient.res

@@ -144,16 +144,7 @@ module ResponseTypes = {
   type block = {
     slot: int,
     blockhash: string,
-    blockTime?: int,
-  }
-
-  /// Borsh-decoded view attached by the Rust client. `argsJson`/`accountsJson`
-  /// are stringified to side-step napi-rs's lack of native JSON passthrough.
-  type decodedInstruction = {
-    name: string,
-    argsJson: string,
-    accountsJson: string,
-    extraAccounts: array<string>,
+    blockTime: Null.t<int>,
   }
 
   type instructionCall = {
@@ -164,16 +155,16 @@ module ResponseTypes = {
     executingAccount: string,
     accountArguments: array<string>,
     data: string,
-    d1?: string,
-    d2?: string,
-    d4?: string,
-    d8?: string,
+    d1: Null.t<string>,
+    d2: Null.t<string>,
+    d4: Null.t<string>,
+    d8: Null.t<string>,
     isInner: bool,
     /** Success of the parent transaction, not of this invocation. */
     txSuccess: bool,
     /** Per-invocation failure reason (e.g. "custom program error: 0x1"). */
-    error?: string,
-    computeUnitsConsumed?: bigint,
+    error: Null.t<string>,
+    computeUnitsConsumed: Null.t<bigint>,
   }
 
   type queryResponseData = {
@@ -206,9 +197,11 @@ module EventItems = {
     clientFilteredContracts: option<array<string>>,
   }
 
+  // NAPI encodes Rust `None` as `null`, never `undefined`, so an unselected
+  // key arrives as an explicit null rather than a missing field.
   type log = {
-    kind?: string,
-    message?: string,
+    kind: Null.t<string>,
+    message: Null.t<string>,
   }
 
   // One routed instruction; `block` and `transaction` are materialised from
@@ -222,9 +215,12 @@ module EventItems = {
     accounts: array<string>,
     data: string,
     isInner: bool,
-    decoded?: ResponseTypes.decodedInstruction,
-    // Present only when the routed registration selected `fields.log`.
-    logs?: array<log>,
+    // Borsh-decoded args as a JSON object literal, `{}` when the routed
+    // registration reads no args. An instruction the schema rejects is dropped
+    // in Rust, so a selected `args` is always decoded.
+    argsJson: string,
+    // Non-null only when the routed registration selected `fields.log`.
+    logs: Null.t<array<log>>,
   }
 
   type response = {

package/src/sources/SvmHyperSyncSource.res

@@ -10,11 +10,6 @@ type options = {
   addressStore: AddressStore.t,
 }
 
-let parseArgs = (d: SvmHyperSyncClient.ResponseTypes.decodedInstruction): JSON.t =>
-  try JSON.parseOrThrow(d.argsJson) catch {
-  | _ => JSON.Object(Dict.make())
-  }
-
 let namedAccounts = (
   ~idlNames: array<string>,
   ~accountArguments: array<string>,
@@ -40,13 +35,13 @@ let namedAccounts = (
 let selectedLog = (log: SvmHyperSyncClient.EventItems.log, ~logFields: Utils.Set.t<string>): Envio.svmLog => {
   let out = Dict.make()
   if logFields->Utils.Set.has("kind") {
-    switch log.kind {
+    switch log.kind->Null.toOption {
     | Some(kind) => out->Dict.set("kind", kind)
     | None => ()
     }
   }
   if logFields->Utils.Set.has("message") {
-    switch log.message {
+    switch log.message->Null.toOption {
     | Some(message) => out->Dict.set("message", message)
     | None => ()
     }
@@ -89,7 +84,7 @@ let toSvmInstruction = (
     out->setField("isInner", item.isInner)
   }
   if hasSelection("args") {
-    out->setField("args", item.decoded->Option.map(parseArgs))
+    out->setField("args", item.argsJson->JSON.parseOrThrow)
   }
   if hasSelection("accounts") {
     out->setField(
@@ -104,7 +99,7 @@ let toSvmInstruction = (
     out->setField(
       "logs",
       item.logs
-      ->Option.getOr([])
+      ->Null.getOr([])
       ->Array.map(log => selectedLog(log, ~logFields=fieldSelection.logFields)),
     )
   }

package/src/sources/SvmHyperSyncSource.res.mjs

@@ -3,19 +3,12 @@
 import * as Source from "./Source.res.mjs";
 import * as HyperSync from "./HyperSync.res.mjs";
 import * as Performance from "../bindings/Performance.res.mjs";
+import * as Stdlib_Null from "@rescript/runtime/lib/es6/Stdlib_Null.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as SvmHyperSyncClient from "./SvmHyperSyncClient.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-function parseArgs(d) {
-  try {
-    return JSON.parse(d.argsJson);
-  } catch (exn) {
-    return {};
-  }
-}
-
 function namedAccounts(idlNames, accountArguments) {
   let out = {};
   idlNames.forEach((name, i) => {
@@ -36,13 +29,13 @@ function selectedLog(log, logFields) {
   let out = {};
   if (logFields.has("kind")) {
     let kind = log.kind;
-    if (kind !== undefined) {
+    if (kind !== null) {
       out["kind"] = kind;
     }
   }
   if (logFields.has("message")) {
     let message = log.message;
-    if (message !== undefined) {
+    if (message !== null) {
       out["message"] = message;
     }
   }
@@ -73,7 +66,7 @@ function toSvmInstruction(item, programName, instructionName, eventConfig, field
     setField(out, "isInner", item.isInner);
   }
   if (fieldSelection.instructionFields.has("args")) {
-    setField(out, "args", Stdlib_Option.map(item.decoded, parseArgs));
+    setField(out, "args", JSON.parse(item.argsJson));
   }
   if (fieldSelection.instructionFields.has("accounts")) {
     setField(out, "accounts", namedAccounts(eventConfig.accounts, item.accounts));
@@ -82,7 +75,7 @@ function toSvmInstruction(item, programName, instructionName, eventConfig, field
     setField(out, "accountArguments", item.accounts);
   }
   if (fieldSelection.logFields.size > 0) {
-    setField(out, "logs", Stdlib_Option.getOr(item.logs, []).map(log => selectedLog(log, fieldSelection.logFields)));
+    setField(out, "logs", Stdlib_Null.getOr(item.logs, []).map(log => selectedLog(log, fieldSelection.logFields)));
   }
   return out;
 }
@@ -189,7 +182,6 @@ function make(param) {
 }
 
 export {
-  parseArgs,
   namedAccounts,
   selectedLog,
   setField,

package/svm.schema.json

@@ -297,8 +297,15 @@
       "type": "object",
       "properties": {
         "hypersync_config": {
-          "description": "HyperSync Config for fetching historical instructions on this chain.",
-          "$ref": "#/$defs/HypersyncConfig"
+          "description": "HyperSync Config for fetching historical instructions on this chain. Optional for the `solana` and `solana-devnet` chain ids, which default to their public HyperSync endpoints; required for any other chain id.",
+          "anyOf": [
+            {
+              "$ref": "#/$defs/HypersyncConfig"
+            },
+            {
+              "type": "null"
+            }
+          ]
         },
         "programs": {
           "description": "Solana programs to index on this chain.",
@@ -310,7 +317,6 @@
       },
       "additionalProperties": false,
       "required": [
-        "hypersync_config",
         "programs"
       ]
     },
@@ -318,7 +324,7 @@
       "type": "object",
       "properties": {
         "url": {
-          "description": "URL of the HyperSync endpoint (default: the public Solana HyperSync endpoint at https://solana.hypersync.xyz)",
+          "description": "URL of the HyperSync endpoint (defaults to the public endpoint of the chain id: https://solana.hypersync.xyz for `solana`, https://solana-devnet.hypersync.xyz for `solana-devnet`)",
           "type": "string"
         }
       },