envio 3.7.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/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")
 

package/src/sources/SimulateSource.res

@@ -4,6 +4,8 @@ let make = (
   ~chainId: ChainId.t,
   ~addressStore: AddressStore.t,
   ~ecosystem: Ecosystem.name=Evm,
+  ~transactionStore: option<TransactionStore.t>=None,
+  ~blockStore: option<BlockStore.t>=None,
 ): Source.t => {
   let reportedHeight = max(endBlock, 1)
 
@@ -106,10 +108,12 @@ let make = (
       Promise.resolve({
         Source.knownHeight: reportedHeight,
         parsedQueueItems,
-        // Simulate keeps the transaction and block inline on the payload; no
-        // transaction page and an empty block page (nothing to reorg-check).
-        transactionStore: None,
-        blockStore: BlockStore.fromJs([], ~ecosystem, ~shouldChecksum=false),
+        // EVM/Fuel keep transaction and block inline. SVM simulate returns a
+        // store page so materialize + activity attach run the same path as HyperSync.
+        transactionStore,
+        blockStore: blockStore->Option.getOr(
+          BlockStore.fromJs([], ~ecosystem, ~shouldChecksum=false),
+        ),
         fromBlockQueried: fromBlock,
         latestFetchedBlockNumber: toBlockQueried,
         stats: {

package/src/sources/SimulateSource.res.mjs

@@ -2,9 +2,13 @@
 
 import * as BlockStore from "./BlockStore.res.mjs";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.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";
 
-function make(items, endBlock, chainId, addressStore, ecosystemOpt) {
+function make(items, endBlock, chainId, addressStore, ecosystemOpt, transactionStoreOpt, blockStoreOpt) {
   let ecosystem = ecosystemOpt !== undefined ? ecosystemOpt : "evm";
+  let transactionStore = transactionStoreOpt !== undefined ? Primitive_option.valFromOption(transactionStoreOpt) : undefined;
+  let blockStore = blockStoreOpt !== undefined ? Primitive_option.valFromOption(blockStoreOpt) : undefined;
   let reportedHeight = Primitive_int.max(endBlock, 1);
   return {
     name: "SimulateSource",
@@ -75,8 +79,8 @@ function make(items, endBlock, chainId, addressStore, ecosystemOpt) {
       return Promise.resolve({
         knownHeight: reportedHeight,
         parsedQueueItems: parsedQueueItems,
-        transactionStore: undefined,
-        blockStore: BlockStore.fromJs([], ecosystem, false),
+        transactionStore: transactionStore,
+        blockStore: Stdlib_Option.getOr(blockStore, BlockStore.fromJs([], ecosystem, false)),
         fromBlockQueried: fromBlock,
         latestFetchedBlockNumber: toBlockQueried,
         stats: {

package/src/sources/Svm.res

@@ -14,13 +14,38 @@ let eventTransactionFieldMask = TransactionStore.makeMaskFn(transactionFields)
 // Rust store (`SvmBlockField`) — keep this order in sync.
 let blockFields = ["slot", "time", "hash", "height", "parentSlot", "parentHash"]
 
-// `slot`/`time`/`hash` are always included; every other block field is opt-in
-// via `field_selection.block_fields`. All are materialised from the store.
+// `slot` is always included (the item's key); every other block field is
+// opt-in via handler `fields.block`. All are materialised from the store.
 //
 // One instruction's selected block fields → store selection bitmask. Computed per
 // event at config build and cached on the event config.
 let eventBlockFieldMask = BlockStore.makeMaskFn(blockFields)
 
+let attachAccountActivities = (payload: Internal.eventPayload, tx: Internal.eventTransaction) => {
+  let instruction = payload->(Utils.magic: Internal.eventPayload => dict<unknown>)
+  let transaction = tx->(Utils.magic: Internal.eventTransaction => dict<unknown>)
+  switch (instruction->Dict.get("accounts"), transaction->Dict.get("accountActivities")) {
+  | (Some(accounts), Some(activities)) if !(accounts->Array.isArray) =>
+    let byAddress = Dict.make()
+    (activities->(Utils.magic: unknown => array<Envio.svmAccountActivity>))->Array.forEach(
+      activity => byAddress->Dict.set(activity.address->SvmTypes.Pubkey.toString, activity),
+    )
+    (accounts->(Utils.magic: unknown => dict<Envio.svmInstructionAccount>))
+    ->Dict.valuesToArray
+    ->Array.forEach(account =>
+      switch byAddress->Dict.get(account.address->SvmTypes.Pubkey.toString) {
+      | Some(activity) =>
+        (account->(Utils.magic: Envio.svmInstructionAccount => dict<unknown>))->Dict.set(
+          "activity",
+          activity->(Utils.magic: Envio.svmAccountActivity => unknown),
+        )
+      | None => ()
+      }
+    )
+  | _ => ()
+  }
+}
+
 let make = (~logger: Pino.t): Ecosystem.t => {
   name: Svm,
   blockNumberName: "height",
@@ -36,16 +61,18 @@ let make = (~logger: Pino.t): Ecosystem.t => {
   logger,
   toEvent: eventItem => eventItem.payload->(Utils.magic: Internal.eventPayload => Internal.event),
   toEventLogger: eventItem => {
-    let instruction =
-      eventItem.payload->(Utils.magic: Internal.eventPayload => Envio.svmInstruction)
+    let eventConfig =
+      eventItem.onEventRegistration.eventConfig->(
+        Utils.magic: Internal.eventConfig => Internal.svmInstructionEventConfig
+      )
     Logging.createChildFrom(
       ~logger,
       ~params={
-        "program": eventItem.onEventRegistration.eventConfig.contractName,
-        "instruction": eventItem.onEventRegistration.eventConfig.name,
+        "program": eventConfig.contractName,
+        "instruction": eventConfig.name,
         "chainId": eventItem.chainId,
         "slot": eventItem.blockNumber,
-        "programId": instruction.programId,
+        "programId": eventConfig.programId,
       },
     )
   },

package/src/sources/Svm.res.mjs

@@ -9,6 +9,7 @@ import * as Internal from "../Internal.res.mjs";
 import * as BlockStore from "./BlockStore.res.mjs";
 import * as Performance from "../bindings/Performance.res.mjs";
 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 S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as TransactionStore from "./TransactionStore.res.mjs";
 
@@ -25,6 +26,32 @@ let blockFields = [
 
 let eventBlockFieldMask = BlockStore.makeMaskFn(blockFields);
 
+function attachAccountActivities(payload, tx) {
+  let match = payload["accounts"];
+  let match$1 = tx["accountActivities"];
+  if (match === undefined) {
+    return;
+  }
+  if (match$1 === undefined) {
+    return;
+  }
+  let accounts = Primitive_option.valFromOption(match);
+  if (Array.isArray(accounts)) {
+    return;
+  }
+  let byAddress = {};
+  Primitive_option.valFromOption(match$1).forEach(activity => {
+    byAddress[activity.address] = activity;
+  });
+  Object.values(accounts).forEach(account => {
+    let activity = byAddress[account.address];
+    if (activity !== undefined) {
+      account["activity"] = activity;
+      return;
+    }
+  });
+}
+
 function make(logger) {
   return {
     name: "svm",
@@ -37,13 +64,13 @@ function make(logger) {
     logger: logger,
     toEvent: eventItem => eventItem.payload,
     toEventLogger: eventItem => {
-      let instruction = eventItem.payload;
+      let eventConfig = eventItem.onEventRegistration.eventConfig;
       return Logging.createChildFrom(logger, {
-        program: eventItem.onEventRegistration.eventConfig.contractName,
-        instruction: eventItem.onEventRegistration.eventConfig.name,
+        program: eventConfig.contractName,
+        instruction: eventConfig.name,
         chainId: eventItem.chainId,
         slot: eventItem.blockNumber,
-        programId: instruction.programId
+        programId: eventConfig.programId
       });
     },
     toRawEvent: param => Stdlib_JsError.throwWithMessage("Raw events are not supported for SVM")
@@ -96,6 +123,7 @@ export {
   eventTransactionFieldMask,
   blockFields,
   eventBlockFieldMask,
+  attachAccountActivities,
   make,
   GetFinalizedSlot,
   makeRPCSource,

package/src/sources/SvmHyperSyncClient.res

@@ -27,14 +27,15 @@ module Registration = {
     // Earliest slot this registration accepts; `None` is unrestricted.
     startBlock: option<int>,
     discriminator?: string,
-    discriminatorByteLen: int,
     isInner?: bool,
-    includeLogs: bool,
     // DNF: outer array is OR of AND-groups.
     accountFilters: array<array<accountFilter>>,
     // camelCase Internal.svmTransactionField / svmBlockField names.
     transactionFields: array<string>,
     blockFields: array<string>,
+    accountActivityFields: array<string>,
+    logFields: array<string>,
+    instructionFields: array<string>,
     // Borsh schema pieces; empty accounts + absent argsJson = no schema.
     accounts: array<string>,
     argsJson?: string,
@@ -55,9 +56,7 @@ module Registration = {
         isWildcard: reg.isWildcard,
         startBlock: reg.startBlock,
         discriminator: ?eventConfig.discriminator,
-        discriminatorByteLen: eventConfig.discriminatorByteLen,
         isInner: ?eventConfig.isInner,
-        includeLogs: eventConfig.includeLogs,
         accountFilters: eventConfig.accountFilters->Array.map(group =>
           group->Array.map(
             (filter): accountFilter => {
@@ -68,6 +67,9 @@ module Registration = {
         ),
         transactionFields: reg.fieldSelection.transactionFields->Utils.Set.toArray,
         blockFields: reg.fieldSelection.blockFields->Utils.Set.toArray,
+        accountActivityFields: reg.fieldSelection.accountActivityFields->Utils.Set.toArray,
+        logFields: reg.fieldSelection.logFields->Utils.Set.toArray,
+        instructionFields: reg.fieldSelection.instructionFields->Utils.Set.toArray,
         accounts: eventConfig.accounts,
         argsJson: ?switch eventConfig.args {
         | JSON.Null => None
@@ -142,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 = {
@@ -162,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 = {
@@ -204,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
@@ -215,18 +210,17 @@ module EventItems = {
     onEventRegistrationIndex: int,
     slot: int,
     transactionIndex: int,
-    instructionAddress: array<int>,
+    path: array<int>,
     programId: string,
     accounts: array<string>,
     data: string,
-    d1?: string,
-    d2?: string,
-    d4?: string,
-    d8?: string,
     isInner: bool,
-    decoded?: ResponseTypes.decodedInstruction,
-    // Present only when the routed registration opted in via `includeLogs`.
-    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/SvmHyperSyncClient.res.mjs

@@ -20,15 +20,16 @@ function fromOnEventRegistrations(onEventRegistrations) {
       isWildcard: reg.isWildcard,
       startBlock: reg.startBlock,
       discriminator: eventConfig.discriminator,
-      discriminatorByteLen: eventConfig.discriminatorByteLen,
       isInner: eventConfig.isInner,
-      includeLogs: eventConfig.includeLogs,
       accountFilters: eventConfig.accountFilters.map(group => group.map(filter => ({
         position: filter.position,
         values: filter.values
       }))),
       transactionFields: Array.from(reg.fieldSelection.transactionFields),
       blockFields: Array.from(reg.fieldSelection.blockFields),
+      accountActivityFields: Array.from(reg.fieldSelection.accountActivityFields),
+      logFields: Array.from(reg.fieldSelection.logFields),
+      instructionFields: Array.from(reg.fieldSelection.instructionFields),
       accounts: eventConfig.accounts,
       argsJson: tmp,
       definedTypesJson: tmp$1