envio 3.3.0-alpha.1 → 3.3.0-alpha.11

package/src/IndexerState.resi

@@ -44,7 +44,7 @@ let makeFromDbState: (
   ~config: Config.t,
   ~persistence: Persistence.t,
   ~initialState: Persistence.initialState,
-  ~registrations: HandlerRegister.registrations,
+  ~registrationsByChainId: HandlerRegister.registrationsByChainId,
   ~isDevelopmentMode: bool=?,
   ~shouldUseTui: bool=?,
   ~exitAfterFirstEventBlock: bool=?,
@@ -107,6 +107,7 @@ let exitAfterFirstEventBlock: t => bool
 let isStopped: t => bool
 let epoch: t => int
 let pruneStaleEntityHistoryThrottler: t => Throttler.t
+let simulateDeadInputTracker: t => option<SimulateDeadInputTracker.t>
 
 // Store domain operations.
 let queueProcessedBatch: (t, ~batch: Batch.t) => unit

package/src/IndexingAddresses.res

@@ -0,0 +1,108 @@
+type indexingAddress = Internal.indexingContract
+
+type contractConfig = {startBlock: option<int>}
+
+type t = dict<indexingAddress>
+
+let deriveEffectiveStartBlock = (~registrationBlock: int, ~contractStartBlock: option<int>) => {
+  Pervasives.max(Pervasives.max(registrationBlock, 0), contractStartBlock->Option.getOr(0))
+}
+
+let makeContractConfigs = (~onEventRegistrations: array<Internal.onEventRegistration>): dict<
+  contractConfig,
+> => {
+  let contractConfigs: dict<contractConfig> = Dict.make()
+  onEventRegistrations->Array.forEach(reg => {
+    let contractName = reg.eventConfig.contractName
+    switch contractConfigs->Utils.Dict.dangerouslyGetNonOption(contractName) {
+    | Some({startBlock}) =>
+      contractConfigs->Dict.set(
+        contractName,
+        {
+          startBlock: switch (startBlock, reg.startBlock) {
+          | (Some(a), Some(b)) => Some(Pervasives.min(a, b))
+          | (Some(_) as s, None) | (None, Some(_) as s) => s
+          | (None, None) => None
+          },
+        },
+      )
+    | None =>
+      contractConfigs->Dict.set(
+        contractName,
+        {
+          startBlock: reg.startBlock,
+        },
+      )
+    }
+  })
+  contractConfigs
+}
+
+let makeIndexingAddress = (
+  ~contract: Internal.indexingAddress,
+  ~contractConfigs: dict<contractConfig>,
+): indexingAddress => {
+  let contractStartBlock = switch contractConfigs->Utils.Dict.dangerouslyGetNonOption(
+    contract.contractName,
+  ) {
+  | Some({startBlock}) => startBlock
+  | None => None
+  }
+  {
+    address: contract.address,
+    contractName: contract.contractName,
+    registrationBlock: contract.registrationBlock,
+    effectiveStartBlock: deriveEffectiveStartBlock(
+      ~registrationBlock=contract.registrationBlock,
+      ~contractStartBlock,
+    ),
+  }
+}
+
+let make = (
+  ~contractConfigs: dict<contractConfig>,
+  ~addresses: array<Internal.indexingAddress>,
+): t => {
+  let indexingAddresses = Dict.make()
+  addresses->Array.forEach(contract => {
+    indexingAddresses->Dict.set(
+      contract.address->Address.toString,
+      makeIndexingAddress(~contract, ~contractConfigs),
+    )
+  })
+  indexingAddresses
+}
+
+let get = (indexingAddresses: t, address) =>
+  indexingAddresses->Utils.Dict.dangerouslyGetNonOption(address)
+
+let size = (indexingAddresses: t) => indexingAddresses->Utils.Dict.size
+
+let getContractAddresses = (indexingAddresses: t, ~contractName): array<Address.t> => {
+  let addresses = []
+  indexingAddresses->Utils.Dict.forEach(ia => {
+    if ia.contractName === contractName {
+      addresses->Array.push(ia.address)
+    }
+  })
+  addresses
+}
+
+// Underlying dict for the precompiled `clientAddressFilter` only — it does raw
+// `indexingAddresses[srcAddress]` access in generated JS and can't take the opaque
+// type. Don't reach for this elsewhere; use the domain accessors above.
+let rawForFilter = (indexingAddresses: t): dict<indexingAddress> => indexingAddresses
+
+let register = (indexingAddresses: t, additions: dict<indexingAddress>) => {
+  let _ = Utils.Dict.mergeInPlace(indexingAddresses, additions)
+}
+
+let rollbackInPlace = (indexingAddresses: t, ~targetBlockNumber: int): unit => {
+  // forEachWithKey is a `for..in`, so deleting the key currently being visited is
+  // safe — it doesn't affect enumeration of the remaining keys.
+  indexingAddresses->Utils.Dict.forEachWithKey((indexingContract, address) => {
+    if indexingContract.registrationBlock > targetBlockNumber {
+      indexingAddresses->Utils.Dict.deleteInPlace(address)
+    }
+  })
+}

package/src/IndexingAddresses.res.mjs

@@ -0,0 +1,101 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Utils from "./Utils.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";
+
+function deriveEffectiveStartBlock(registrationBlock, contractStartBlock) {
+  return Primitive_int.max(Primitive_int.max(registrationBlock, 0), Stdlib_Option.getOr(contractStartBlock, 0));
+}
+
+function makeContractConfigs(onEventRegistrations) {
+  let contractConfigs = {};
+  onEventRegistrations.forEach(reg => {
+    let contractName = reg.eventConfig.contractName;
+    let match = contractConfigs[contractName];
+    if (match !== undefined) {
+      let startBlock = match.startBlock;
+      let match$1 = reg.startBlock;
+      contractConfigs[contractName] = {
+        startBlock: startBlock !== undefined ? (
+            match$1 !== undefined ? Primitive_int.min(startBlock, match$1) : startBlock
+          ) : (
+            match$1 !== undefined ? match$1 : undefined
+          )
+      };
+      return;
+    }
+    contractConfigs[contractName] = {
+      startBlock: reg.startBlock
+    };
+  });
+  return contractConfigs;
+}
+
+function makeIndexingAddress(contract, contractConfigs) {
+  let match = contractConfigs[contract.contractName];
+  let contractStartBlock = match !== undefined ? match.startBlock : undefined;
+  return {
+    address: contract.address,
+    contractName: contract.contractName,
+    registrationBlock: contract.registrationBlock,
+    effectiveStartBlock: deriveEffectiveStartBlock(contract.registrationBlock, contractStartBlock)
+  };
+}
+
+function make(contractConfigs, addresses) {
+  let indexingAddresses = {};
+  addresses.forEach(contract => {
+    indexingAddresses[contract.address] = makeIndexingAddress(contract, contractConfigs);
+  });
+  return indexingAddresses;
+}
+
+function get(indexingAddresses, address) {
+  return indexingAddresses[address];
+}
+
+function size(indexingAddresses) {
+  return Utils.Dict.size(indexingAddresses);
+}
+
+function getContractAddresses(indexingAddresses, contractName) {
+  let addresses = [];
+  Utils.Dict.forEach(indexingAddresses, ia => {
+    if (ia.contractName === contractName) {
+      addresses.push(ia.address);
+      return;
+    }
+  });
+  return addresses;
+}
+
+function rawForFilter(indexingAddresses) {
+  return indexingAddresses;
+}
+
+function register(indexingAddresses, additions) {
+  Object.assign(indexingAddresses, additions);
+}
+
+function rollbackInPlace(indexingAddresses, targetBlockNumber) {
+  Utils.Dict.forEachWithKey(indexingAddresses, (indexingContract, address) => {
+    if (indexingContract.registrationBlock > targetBlockNumber) {
+      return Utils.Dict.deleteInPlace(indexingAddresses, address);
+    }
+  });
+}
+
+export {
+  deriveEffectiveStartBlock,
+  makeContractConfigs,
+  makeIndexingAddress,
+  make,
+  get,
+  size,
+  getContractAddresses,
+  rawForFilter,
+  register,
+  rollbackInPlace,
+}
+/* Utils Not a pure module */

package/src/IndexingAddresses.resi

@@ -0,0 +1,34 @@
+type indexingAddress = Internal.indexingContract
+
+type contractConfig = {startBlock: option<int>}
+
+type t
+
+let deriveEffectiveStartBlock: (~registrationBlock: int, ~contractStartBlock: option<int>) => int
+
+let makeContractConfigs: (
+  ~onEventRegistrations: array<Internal.onEventRegistration>,
+) => dict<contractConfig>
+
+let makeIndexingAddress: (
+  ~contract: Internal.indexingAddress,
+  ~contractConfigs: dict<contractConfig>,
+) => indexingAddress
+
+let make: (~contractConfigs: dict<contractConfig>, ~addresses: array<Internal.indexingAddress>) => t
+
+let get: (t, string) => option<indexingAddress>
+
+let size: t => int
+
+let getContractAddresses: (t, ~contractName: string) => array<Address.t>
+
+// Underlying dict for the precompiled `clientAddressFilter` only, which does raw
+// `indexingAddresses[srcAddress]` access in generated JS. Don't use elsewhere —
+// prefer the domain accessors so the opaque type stays enforced.
+let rawForFilter: t => dict<indexingAddress>
+
+let register: (t, dict<indexingAddress>) => unit
+
+// Deletes addresses registered after `targetBlockNumber` from the index in place.
+let rollbackInPlace: (t, ~targetBlockNumber: int) => unit

package/src/Internal.res

@@ -58,7 +58,6 @@ type evmTransactionField =
   | @as("root") Root
   | @as("status") Status
   | @as("yParity") YParity
-  | @as("accessList") AccessList
   | @as("maxFeePerBlobGas") MaxFeePerBlobGas
   | @as("blobVersionedHashes") BlobVersionedHashes
   | @as("type") Type
@@ -67,6 +66,7 @@ type evmTransactionField =
   | @as("l1GasUsed") L1GasUsed
   | @as("l1FeeScalar") L1FeeScalar
   | @as("gasUsedForL1") GasUsedForL1
+  | @as("accessList") AccessList
   | @as("authorizationList") AuthorizationList
 
 let allEvmBlockFields: array<evmBlockField> = [
@@ -123,7 +123,6 @@ let allEvmTransactionFields: array<evmTransactionField> = [
   Root,
   Status,
   YParity,
-  AccessList,
   MaxFeePerBlobGas,
   BlobVersionedHashes,
   Type,
@@ -132,10 +131,54 @@ let allEvmTransactionFields: array<evmTransactionField> = [
   L1GasUsed,
   L1FeeScalar,
   GasUsedForL1,
+  AccessList,
   AuthorizationList,
 ]
 let evmTransactionFieldSchema = S.enum(allEvmTransactionFields)
 
+// SVM transaction fields. Order mirrors the Rust `SvmTxField` ordinals (the bit
+// position in the selection mask) and `Svm.res` `transactionFields`.
+type svmTransactionField =
+  | @as("transactionIndex") TransactionIndex
+  | @as("signatures") Signatures
+  | @as("feePayer") FeePayer
+  | @as("success") Success
+  | @as("err") Err
+  | @as("fee") Fee
+  | @as("computeUnitsConsumed") ComputeUnitsConsumed
+  | @as("accountKeys") AccountKeys
+  | @as("recentBlockhash") RecentBlockhash
+  | @as("version") Version
+  | @as("tokenBalances") TokenBalances
+
+let allSvmTransactionFields: array<svmTransactionField> = [
+  TransactionIndex,
+  Signatures,
+  FeePayer,
+  Success,
+  Err,
+  Fee,
+  ComputeUnitsConsumed,
+  AccountKeys,
+  RecentBlockhash,
+  Version,
+  TokenBalances,
+]
+let svmTransactionFieldSchema = S.enum(allSvmTransactionFields)
+
+// All SVM block fields. `slot`/`time`/`hash` are always included; the rest are
+// selectable via `field_selection.block_fields` (see `allSvmBlockFields`).
+type svmBlockField =
+  | @as("slot") Slot
+  | @as("time") Time
+  | @as("hash") Hash
+  | @as("height") Height
+  | @as("parentSlot") ParentSlot
+  | @as("parentHash") ParentHash
+
+let allSvmBlockFields: array<svmBlockField> = [Height, ParentSlot, ParentHash]
+let svmBlockFieldSchema = S.enum(allSvmBlockFields)
+
 // Static sets of nullable field names — used by RpcSource and HyperSyncSource to wrap schemas with S.nullable
 let evmNullableBlockFields = Utils.Set.fromArray(
   (
@@ -265,8 +308,8 @@ type genericEvent<'params, 'block, 'transaction> = {
   block: 'block,
 }
 
-// Opaque internally — block-level values needed by the runtime
-// (blockNumber, timestamp, blockHash) live on the item instead.
+// Opaque internally — the block number needed by the runtime lives on the
+// item instead.
 type event
 
 // Opaque payload an item carries. A source builds an ecosystem-specific
@@ -277,7 +320,18 @@ type event
 // modules, not here, and are distinct per ecosystem.
 type eventPayload
 
-external payloadToEvent: eventPayload => event = "%identity"
+// Generic access to the payload's `transaction`, written at batch prep for
+// store-backed ecosystems (HyperSync) and present inline otherwise.
+@get external getPayloadTransaction: eventPayload => Nullable.t<eventTransaction> = "transaction"
+@set external setPayloadTransaction: (eventPayload, eventTransaction) => unit = "transaction"
+
+// Generic access to the payload's `block`: written/enriched at batch prep for
+// store-backed ecosystems (EVM/SVM HyperSync) and present inline otherwise.
+@get external getPayloadBlock: eventPayload => Nullable.t<eventBlock> = "block"
+@set external setPayloadBlock: (eventPayload, eventBlock) => unit = "block"
+
+// The log's emitting address (EVM/Fuel; the program id carries it for SVM).
+@get external getPayloadSrcAddress: eventPayload => Address.t = "srcAddress"
 
 type genericLoaderArgs<'event, 'context> = {
   event: 'event,
@@ -357,31 +411,33 @@ type indexingContract = {
   effectiveStartBlock: int,
 }
 
-// This is private so it's not manually constructed internally
-// The idea is that it can only be coerced from fuel/evmEventConfig
-// and it can include their fields. We prevent manual creation,
-// so the fields are not overwritten and we can safely cast the type back to fuel/evmEventConfig
+// Definition of an event/instruction we know how to decode: identity + decode
+// schemas + chain-independent field selection. A pure function of the ABI +
+// config, shared across chains. `private` so it can only be coerced from an
+// ecosystem variant (fields never overwritten), which lets sources cast the
+// base back down to evm/fuel/svm safely.
 type eventConfig = private {
   id: string,
   name: string,
   contractName: string,
-  isWildcard: bool,
-  // Whether the event has an event filter which uses addresses
-  filterByAddresses: bool,
-  // Usually always false for wildcard events
-  // But might be true for wildcard event with dynamic event filter by addresses
-  dependsOnAddresses: bool,
-  // Precompiled predicate (EVM only) for events that filter an indexed address
-  // param by registered addresses. Given the decoded event and the log's block
-  // number, drops an event whose param-address isn't registered at/before that
-  // block — the param-level analogue of EventRouter's srcAddress
-  // `effectiveStartBlock` check. Absent otherwise.
-  clientAddressFilter?: (eventPayload, int, dict<indexingContract>) => bool,
-  handler: option<handler>,
-  contractRegister: option<contractRegister>,
   paramsRawEventSchema: S.schema<eventParams>,
   simulateParamsSchema: S.schema<eventParams>,
-  startBlock: option<int>,
+  // Field names selected for the chain's transaction-store materialisation
+  // (camelCase, matching the ecosystem's `transactionFields`). Stored as a
+  // string set so the shared mask logic is ecosystem-agnostic; sources recover
+  // the typed view where they need it.
+  selectedTransactionFields: Utils.Set.t<string>,
+  // `selectedTransactionFields` precompiled to the transaction-store selection
+  // bitmask (bit per ecosystem field code). Materialisation reads this per item
+  // so each transaction decodes only the fields its event selected. `0.` when
+  // nothing is selected or the ecosystem carries the transaction inline (Fuel).
+  transactionFieldMask: float,
+  // Selected block fields precompiled to the block-store selection bitmask (bit
+  // per ecosystem field code). `0.` for ecosystems that carry the block fully
+  // inline (RPC/Fuel). The EVM selection always includes number/timestamp/hash,
+  // so an EVM mask always has their bits set; SVM stamps slot/time/hash inline
+  // from the response and its mask is the user's selection alone.
+  blockFieldMask: float,
 }
 
 type fuelEventKind =
@@ -406,30 +462,46 @@ type topicSelection = {
   topic3: array<EvmTypes.Hex.t>,
 }
 
+// A single topic position of a resolved `where`: either static pre-encoded
+// values, or a marker for "the currently registered addresses of this
+// contract", expanded to topic values when a source query is built.
+type topicFilter =
+  | Values(array<EvmTypes.Hex.t>)
+  | ContractAddresses({contractName: string})
+
+type resolvedTopicSelection = {
+  topic0: array<EvmTypes.Hex.t>,
+  topic1: topicFilter,
+  topic2: topicFilter,
+  topic3: topicFilter,
+}
+
+// The registered `where` fully resolved at registration time for one chain.
+// `topicSelections` is in disjunctive normal form (outer array is OR);
+// an empty array means the `where` returned `false` for this chain.
+type resolvedWhere = {
+  topicSelections: array<resolvedTopicSelection>,
+  startBlock: option<int>,
+}
+
 // Per-event, per-invocation arguments passed to a `where` callback. The
 // concrete `chain` shape (which contract key it exposes) is generated per
 // event in user-project codegen — here it's an open record so codegen'd
 // types subtype-coerce into it cleanly.
 type onEventWhereArgs<'chain> = {chain: 'chain}
 
-type eventFilters =
-  Static(array<topicSelection>) | Dynamic(array<Address.t> => array<topicSelection>)
-
 type evmEventConfig = {
   ...eventConfig,
-  getEventFiltersOrThrow: ChainMap.Chain.t => eventFilters,
   selectedBlockFields: Utils.Set.t<evmBlockField>,
-  selectedTransactionFields: Utils.Set.t<evmTransactionField>,
   sighash: string,
   topicCount: int,
   paramsMetadata: array<paramMeta>,
 }
 
-// Shared formula for `eventConfig.dependsOnAddresses`. Kept here so
-// `EventConfigBuilder.build{Evm,Fuel}EventConfig` and
-// `HandlerLoader.applyRegistrations` stay in sync when handler state flips
-// the value. Fuel events always have `filterByAddresses=false`, so callers
-// there simply pass it through as `false`.
+// Shared formula for a registration's `dependsOnAddresses`. Kept here so the
+// `EventConfigBuilder.build*OnEventRegistration` builders stay in sync. Fuel
+// and SVM events always have `filterByAddresses=false`, so callers there pass
+// it through as `false`.
 let dependsOnAddresses = (~isWildcard, ~filterByAddresses) => !isWildcard || filterByAddresses
 
 type evmContractConfig = {
@@ -448,6 +520,10 @@ type svmAccountFilterGroup = array<svmAccountFilter>
 
 type svmInstructionEventConfig = {
   ...eventConfig,
+  /** Block fields selected via `field_selection.block_fields` (`slot` is always
+   included and excluded from this set). Drives the block query columns;
+   precompiled to `blockFieldMask` for store materialisation. */
+  selectedBlockFields: Utils.Set.t<svmBlockField>,
   /** Base58 Solana program id this instruction belongs to. */
   programId: SvmTypes.Pubkey.t,
   /** Hex-encoded discriminator. `None` matches every instruction in the program. */
@@ -456,9 +532,7 @@ type svmInstructionEventConfig = {
    `dN` selector at query time and the dispatch-key precomputation in the
    router. */
   discriminatorByteLen: int,
-  includeTransaction: bool,
   includeLogs: bool,
-  includeTokenBalances: bool,
   /** Disjunctive normal form: outer array is OR of AND-groups, inner array is
    AND across positions. Empty outer array means "no account filter". */
   accountFilters: array<svmAccountFilterGroup>,
@@ -476,6 +550,49 @@ type svmInstructionEventConfig = {
   definedTypes: JSON.t,
 }
 
+// Per-(event, chain) registration produced when user handler code registers an
+// event (`onEvent`) or a dynamic contract registers. References its definition
+// by value as `.eventConfig` and adds the handler binding plus the
+// registration/`where`-derived fetch state. Not `private`: Fuel/SVM
+// registrations add no ecosystem-specific fields (so they're bare aliases that
+// must stay directly constructable), and the evm→base cast in sources is sound
+// by ecosystem homogeneity — an EVM chain only ever holds `evmOnEventRegistration`s.
+type onEventRegistration = {
+  // Chain-scoped sequential index — the registration's position in the
+  // chain's onEventRegistrations array, assigned when registration finishes
+  // (-1 until then). Native-routed items reference their registration by this
+  // index across the napi boundary; sources resolve it before creating an item.
+  index: int,
+  eventConfig: eventConfig,
+  handler: option<handler>,
+  contractRegister: option<contractRegister>,
+  isWildcard: bool,
+  // Whether the event has an event filter which uses addresses.
+  filterByAddresses: bool,
+  // Usually always false for wildcard events, but might be true for a wildcard
+  // event with a dynamic event filter by addresses.
+  dependsOnAddresses: bool,
+  // Precompiled predicate for events that filter an indexed address param by
+  // registered addresses (see `EventConfigBuilder.buildAddressFilter`); drops a
+  // decoded event whose param-address isn't registered at/before the log's
+  // block. Absent otherwise.
+  clientAddressFilter?: (eventPayload, int, dict<indexingContract>) => bool,
+  // Final start block: the contract/chain config value, overridden by a
+  // `where.block.number._gte` when the registered `where` supplies one.
+  startBlock: option<int>,
+}
+
+type evmOnEventRegistration = {
+  ...onEventRegistration,
+  resolvedWhere: resolvedWhere,
+}
+
+// Fuel and SVM registrations add no ecosystem-specific fetch state (their
+// filters are config-derived and live on the definition), so they're bare
+// aliases of the base registration.
+type fuelOnEventRegistration = onEventRegistration
+type svmOnEventRegistration = onEventRegistration
+
 type svmProgramConfig = {
   name: string,
   programId: SvmTypes.Pubkey.t,
@@ -492,16 +609,18 @@ type indexingAddress = {
 
 type dcs = array<indexingAddress>
 
-// Duplicate the type from item
-// to make item properly unboxed
+// Duplicate the type from item to keep item properly unboxed. Runtime event
+// items carry the registration their source already resolved from the
+// ChainState-owned registration array.
 type eventItem = private {
   kind: [#0],
-  eventConfig: eventConfig,
-  timestamp: int,
+  onEventRegistration: onEventRegistration,
   chain: ChainMap.Chain.t,
   blockNumber: int,
-  blockHash: string,
   logIndex: int,
+  // Within-block transaction index — the key into the per-chain transaction
+  // store. Unused (0) for ecosystems that carry the transaction inline (Fuel).
+  transactionIndex: int,
   payload: eventPayload,
 }
 
@@ -532,7 +651,7 @@ type onBlockArgs = {
   context: handlerContext,
 }
 
-type onBlockConfig = {
+type onBlockRegistration = {
   // When there are multiple onBlock handlers per chain,
   // we want to use the order they are defined for sorting
   index: int,
@@ -548,15 +667,14 @@ type onBlockConfig = {
 type item =
   | @as(0)
   Event({
-      eventConfig: eventConfig,
-      timestamp: int,
+      onEventRegistration: onEventRegistration,
       chain: ChainMap.Chain.t,
       blockNumber: int,
-      blockHash: string,
       logIndex: int,
+      transactionIndex: int,
       payload: eventPayload,
     })
-  | @as(1) Block({onBlockConfig: onBlockConfig, blockNumber: int, logIndex: int})
+  | @as(1) Block({onBlockRegistration: onBlockRegistration, blockNumber: int, logIndex: int})
 
 external castUnsafeEventItem: item => eventItem = "%identity"
 
@@ -568,7 +686,7 @@ external getItemLogIndex: item => int = "logIndex"
 let getItemChainId = item =>
   switch item {
   | Event({chain}) => chain->ChainMap.Chain.toChainId
-  | Block({onBlockConfig: {chainId}}) => chainId
+  | Block({onBlockRegistration: {chainId}}) => chainId
   }
 
 @get
@@ -653,7 +771,7 @@ type effect = {
   input: S.t<effectInput>,
   // The number of functions that are currently running.
   mutable activeCallsCount: int,
-  mutable prevCallStartTimerRef: Hrtime.timeRef,
+  mutable prevCallStartTimerRef: Performance.timeRef,
   rateLimit: option<rateLimitState>,
 }
 let cacheTablePrefix = "envio_effect_"

package/src/Internal.res.mjs

@@ -60,7 +60,6 @@ let allEvmTransactionFields = [
   "root",
   "status",
   "yParity",
-  "accessList",
   "maxFeePerBlobGas",
   "blobVersionedHashes",
   "type",
@@ -69,11 +68,36 @@ let allEvmTransactionFields = [
   "l1GasUsed",
   "l1FeeScalar",
   "gasUsedForL1",
+  "accessList",
   "authorizationList"
 ];
 
 let evmTransactionFieldSchema = S$RescriptSchema.$$enum(allEvmTransactionFields);
 
+let allSvmTransactionFields = [
+  "transactionIndex",
+  "signatures",
+  "feePayer",
+  "success",
+  "err",
+  "fee",
+  "computeUnitsConsumed",
+  "accountKeys",
+  "recentBlockhash",
+  "version",
+  "tokenBalances"
+];
+
+let svmTransactionFieldSchema = S$RescriptSchema.$$enum(allSvmTransactionFields);
+
+let allSvmBlockFields = [
+  "height",
+  "parentSlot",
+  "parentHash"
+];
+
+let svmBlockFieldSchema = S$RescriptSchema.$$enum(allSvmBlockFields);
+
 let evmNullableBlockFields = new Set([
   "nonce",
   "difficulty",
@@ -125,7 +149,7 @@ function getItemChainId(item) {
   if (item.kind === 0) {
     return item.chain;
   } else {
-    return item.onBlockConfig.chainId;
+    return item.onBlockRegistration.chainId;
   }
 }
 
@@ -160,6 +184,10 @@ export {
   evmBlockFieldSchema,
   allEvmTransactionFields,
   evmTransactionFieldSchema,
+  allSvmTransactionFields,
+  svmTransactionFieldSchema,
+  allSvmBlockFields,
+  svmBlockFieldSchema,
   evmNullableBlockFields,
   evmNullableTransactionFields,
   dependsOnAddresses,