envio 3.0.0 → 3.0.2-svm-alpha.0

package/src/Config.res.mjs

@@ -113,6 +113,26 @@ let publicConfigChainSchema = S$RescriptSchema.schema(s => ({
   contracts: s.m(S$RescriptSchema.option(S$RescriptSchema.dict(chainContractSchema)))
 }));
 
+let svmEventDescriptorSchema = S$RescriptSchema.schema(s => ({
+  discriminator: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
+  discriminatorByteLen: s.m(S$RescriptSchema.int),
+  includeTransaction: s.m(S$RescriptSchema.bool),
+  includeLogs: s.m(S$RescriptSchema.bool),
+  accountFilters: s.m(S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.schema(s => ({
+    position: s.m(S$RescriptSchema.int),
+    values: s.m(S$RescriptSchema.array(S$RescriptSchema.string))
+  }))))),
+  isInner: s.m(S$RescriptSchema.option(S$RescriptSchema.bool)),
+  accounts: s.m(S$RescriptSchema.option(S$RescriptSchema.array(S$RescriptSchema.string))),
+  args: s.m(S$RescriptSchema.option(S$RescriptSchema.json(false)))
+}));
+
+let svmAbiSchema = S$RescriptSchema.schema(s => ({
+  programId: s.m(S$RescriptSchema.string),
+  definedTypes: s.m(S$RescriptSchema.json(false)),
+  source: s.m(S$RescriptSchema.string)
+}));
+
 let contractEventItemSchema = S$RescriptSchema.schema(s => ({
   event: s.m(S$RescriptSchema.string),
   name: s.m(S$RescriptSchema.string),
@@ -120,18 +140,21 @@ let contractEventItemSchema = S$RescriptSchema.schema(s => ({
   params: s.m(S$RescriptSchema.option(S$RescriptSchema.array(EventConfigBuilder.eventParamSchema))),
   kind: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
   blockFields: s.m(S$RescriptSchema.option(S$RescriptSchema.array(Internal.evmBlockFieldSchema))),
-  transactionFields: s.m(S$RescriptSchema.option(S$RescriptSchema.array(Internal.evmTransactionFieldSchema)))
+  transactionFields: s.m(S$RescriptSchema.option(S$RescriptSchema.array(Internal.evmTransactionFieldSchema))),
+  svm: s.m(S$RescriptSchema.option(svmEventDescriptorSchema))
 }));
 
 let contractConfigSchema = S$RescriptSchema.schema(s => ({
   abi: s.m(S$RescriptSchema.json(false)),
   handler: s.m(S$RescriptSchema.option(S$RescriptSchema.string)),
-  events: s.m(S$RescriptSchema.option(S$RescriptSchema.array(contractEventItemSchema)))
+  events: s.m(S$RescriptSchema.option(S$RescriptSchema.array(contractEventItemSchema))),
+  svmAbi: s.m(S$RescriptSchema.option(svmAbiSchema))
 }));
 
 let publicConfigEcosystemSchema = S$RescriptSchema.schema(s => ({
   chains: s.m(S$RescriptSchema.dict(publicConfigChainSchema)),
-  contracts: s.m(S$RescriptSchema.option(S$RescriptSchema.dict(contractConfigSchema)))
+  contracts: s.m(S$RescriptSchema.option(S$RescriptSchema.dict(contractConfigSchema))),
+  programs: s.m(S$RescriptSchema.option(S$RescriptSchema.dict(contractConfigSchema)))
 }));
 
 let publicConfigEvmSchema = S$RescriptSchema.schema(s => ({
@@ -419,6 +442,7 @@ function fromPublic(publicConfigJson) {
   let lowercaseAddresses = evm !== undefined ? Stdlib_Option.getOr(Primitive_option.valFromOption(evm).addressFormat, "checksum") === "lowercase" : false;
   let match$4 = publicConfig.evm;
   let match$5 = publicConfig.fuel;
+  let match$6 = publicConfig.svm;
   let publicContractsConfig;
   switch (ecosystemName) {
     case "evm" :
@@ -428,25 +452,25 @@ function fromPublic(publicConfigJson) {
       publicContractsConfig = match$5 !== undefined ? Primitive_option.valFromOption(match$5).contracts : undefined;
       break;
     case "svm" :
-      publicContractsConfig = undefined;
+      publicContractsConfig = match$6 !== undefined ? Primitive_option.valFromOption(match$6).programs : undefined;
       break;
   }
   let evm$1 = publicConfig.evm;
-  let match$6;
+  let match$7;
   if (evm$1 !== undefined) {
     let evm$2 = Primitive_option.valFromOption(evm$1);
-    match$6 = [
+    match$7 = [
       new Set(EventConfigBuilder.alwaysIncludedBlockFields.concat(Stdlib_Option.getOr(evm$2.globalBlockFields, []))),
       new Set(Stdlib_Option.getOr(evm$2.globalTransactionFields, []))
     ];
   } else {
-    match$6 = [
+    match$7 = [
       new Set(EventConfigBuilder.alwaysIncludedBlockFields),
       new Set()
     ];
   }
-  let globalTransactionFieldsSet = match$6[1];
-  let globalBlockFieldsSet = match$6[0];
+  let globalTransactionFieldsSet = match$7[1];
+  let globalBlockFieldsSet = match$7[0];
   let contractDataByName = {};
   if (publicContractsConfig !== undefined) {
     Object.entries(publicContractsConfig).forEach(param => {
@@ -458,11 +482,13 @@ function fromPublic(publicConfigJson) {
       contractDataByName[capitalizedName] = {
         abi: abi,
         eventSignatures: eventSignatures,
-        events: contractConfig.events
+        events: contractConfig.events,
+        svmAbi: contractConfig.svmAbi
       };
     });
   }
-  let buildContractEvents = (contractName, events, abi, chainId, startBlock) => {
+  let buildContractEvents = (contractName, events, abi, chainId, startBlock, addresses, svmDefinedTypesOpt) => {
+    let svmDefinedTypes = svmDefinedTypesOpt !== undefined ? svmDefinedTypesOpt : null;
     if (events !== undefined) {
       return events.map(eventItem => {
         let eventName = eventItem.name;
@@ -470,17 +496,27 @@ function fromPublic(publicConfigJson) {
         let params = Stdlib_Option.getOr(eventItem.params, []);
         let kind = eventItem.kind;
         switch (ecosystemName) {
+          case "evm" :
+            return EventConfigBuilder.buildEvmEventConfig(contractName, eventName, sighash, params, false, undefined, undefined, undefined, chainId, ecosystem.onEventBlockFilterSchema, eventItem.blockFields, eventItem.transactionFields, startBlock, Primitive_option.some(globalBlockFieldsSet), Primitive_option.some(globalTransactionFieldsSet));
           case "fuel" :
             if (kind !== undefined) {
               return EventConfigBuilder.buildFuelEventConfig(contractName, eventName, kind, sighash, abi, false, undefined, undefined, startBlock);
             } else {
               return Stdlib_JsError.throwWithMessage(`Fuel event ` + contractName + `.` + eventName + ` is missing "kind" in internal config`);
             }
-          case "evm" :
           case "svm" :
-            break;
+            let len = addresses.length;
+            let programId = len !== 1 ? (
+                len !== 0 ? Stdlib_JsError.throwWithMessage(`SVM program ` + contractName + ` on chain ` + chainId.toString() + ` has multiple addresses; a program is uniquely identified by a single program_id`) : Stdlib_JsError.throwWithMessage(`SVM program ` + contractName + ` on chain ` + chainId.toString() + ` is missing a program_id`)
+              ) : addresses[0];
+            let s = eventItem.svm;
+            let svm = s !== undefined ? Primitive_option.valFromOption(s) : Stdlib_JsError.throwWithMessage(`SVM instruction ` + contractName + `.` + eventName + ` is missing the "svm" descriptor in internal config`);
+            let accountFilters = Stdlib_Option.getOr(svm.accountFilters, []).map(af => ({
+              position: af.position,
+              values: af.values
+            }));
+            return EventConfigBuilder.buildSvmInstructionEventConfig(contractName, eventName, programId, svm.discriminator, svm.discriminatorByteLen, svm.includeTransaction, svm.includeLogs, accountFilters, svm.isInner, false, undefined, undefined, Stdlib_Option.getOr(svm.accounts, []), Stdlib_Option.getOr(svm.args, null), svmDefinedTypes, startBlock);
         }
-        return EventConfigBuilder.buildEvmEventConfig(contractName, eventName, sighash, params, false, undefined, undefined, undefined, chainId, ecosystem.onEventBlockFilterSchema, eventItem.blockFields, eventItem.transactionFields, startBlock, Primitive_option.some(globalBlockFieldsSet), Primitive_option.some(globalTransactionFieldsSet));
       });
     } else {
       return [];
@@ -517,9 +553,10 @@ function fromPublic(publicConfigJson) {
       let contractData = param[1];
       let capitalizedName = param[0];
       let chainContract = chainContracts[capitalizedName];
-      let addresses = Stdlib_Option.getOr(Stdlib_Option.flatMap(chainContract, cc => cc.addresses), []).map(parseAddress);
+      let rawAddresses = Stdlib_Option.getOr(Stdlib_Option.flatMap(chainContract, cc => cc.addresses), []);
+      let addresses = rawAddresses.map(parseAddress);
       let startBlock = Stdlib_Option.flatMap(chainContract, cc => cc.startBlock);
-      let events = buildContractEvents(capitalizedName, contractData.events, contractData.abi, chainId, startBlock);
+      let events = buildContractEvents(capitalizedName, contractData.events, contractData.abi, chainId, startBlock, rawAddresses, Stdlib_Option.getOr(Stdlib_Option.map(contractData.svmAbi, a => a.definedTypes), null));
       return {
         name: capitalizedName,
         abi: contractData.abi,
@@ -576,6 +613,7 @@ function fromPublic(publicConfigJson) {
         let rpc = publicChainConfig.rpc;
         sourceConfig = rpc !== undefined ? ({
             TAG: "SvmSourceConfig",
+            hypersync: publicChainConfig.hypersync,
             rpc: rpc
           }) : Stdlib_JsError.throwWithMessage(`Chain ` + chainName + ` is missing rpc endpoint in config`);
         break;
@@ -862,6 +900,8 @@ export {
   rpcConfigSchema,
   chainContractSchema,
   publicConfigChainSchema,
+  svmEventDescriptorSchema,
+  svmAbiSchema,
   contractEventItemSchema,
   contractConfigSchema,
   publicConfigEcosystemSchema,

package/src/Core.res

@@ -4,9 +4,41 @@
 
 // NAPI encodes Rust `Option<T>` as `null | T` (never `undefined`), so the
 // tighter `Null.t` captures the exact boundary shape.
+//
+// Opaque carriers for the NAPI class constructors. Static factories
+// (`newWithAgent`, `fromConfig`, `fromSignatures`) hang off these via `@send`
+// in `HyperSyncClient.res` / `HyperSyncSolanaClient.res`.
+type hypersyncClientCtor
+type hypersyncSolanaClientCtor
+type decoderCtor
+
+/// JS shape of one decoded instruction. Mirrors `DecodedInstructionJson` in
+/// `packages/cli/src/hypersync_source_svm/decoder.rs`. The `argsJson` /
+/// `accountsJson` fields are stringified to side-step napi-rs's lack of
+/// native `serde_json::Value` passthrough; callers `JSON.parse` once.
+type svmDecodedInstruction = {
+  name: string,
+  argsJson: string,
+  accountsJson: string,
+  extraAccounts: array<string>,
+}
+
 type addon = {
   getConfigJson: (~configPath: Null.t<string>, ~directory: Null.t<string>) => string,
   runCli: (~args: array<string>, ~envioPackageDir: Null.t<string>) => promise<Null.t<string>>,
+  @as("HypersyncClient")
+  hypersyncClient: hypersyncClientCtor,
+  @as("HypersyncSolanaClient")
+  hypersyncSolanaClient: hypersyncSolanaClientCtor,
+  @as("Decoder")
+  decoder: decoderCtor,
+  setLogLevel: string => unit,
+  registerProgramSchema: (~descriptorJson: string) => int,
+  decodeInstruction: (
+    ~schemaHandle: int,
+    ~dataHex: string,
+    ~accounts: array<string>,
+  ) => Null.t<svmDecodedInstruction>,
 }
 
 @module("node:module") external createRequire: string => {..} = "createRequire"

package/src/Env.res.mjs

@@ -7,7 +7,6 @@ import * as Belt_Option from "@rescript/runtime/lib/es6/Belt_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as HyperSyncClient from "./sources/HyperSyncClient.res.mjs";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
-import * as HypersyncClient from "@envio-dev/hypersync-client";
 
 import 'dotenv/config'
 ;
@@ -62,7 +61,7 @@ let hypersyncClientEnableQueryCaching = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_CL
 
 let hypersyncLogLevel = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_LOG_LEVEL", HyperSyncClient.logLevelSchema, undefined, "info", undefined, undefined);
 
-HypersyncClient.setLogLevel(hypersyncLogLevel);
+HyperSyncClient.setLogLevel(hypersyncLogLevel);
 
 let logStrategy = EnvSafe.get(envSafe, "LOG_STRATEGY", S$RescriptSchema.$$enum([
   "ecs-file",

package/src/Envio.res

@@ -20,6 +20,100 @@ type svmOnSlotArgs<'context> = {
   context: 'context,
 }
 
+/** Borsh-decoded instruction view. Present whenever a `ProgramSchema` was
+ attached to the program (bundled schema, Anchor IDL, or hand-written YAML
+ `accounts`/`args`). Absent (`None`) when no schema applied or the
+ discriminator didn't match any registered instruction. */
+type svmDecodedInstruction = {
+  /** Schema-declared instruction name (matches the codegen module suffix). */
+  name: string,
+  /** Borsh-decoded args. `JSON.Object({})` for no-arg instructions
+   (e.g. `VerifyCollection`). POC types this as raw `JSON.t`; cast at the
+   handler with `(json :> MyArgsType)` until typed codegen lands. */
+  args: JSON.t,
+  /** Named accounts in schema order. Keys are exactly the schema-declared
+   names; values are base58 pubkey strings. */
+  accounts: dict<string>,
+  /** Accounts beyond the schema's named list (Anchor `remaining_accounts`,
+   IDL drift). `[]` when counts match. */
+  extraAccounts: array<string>,
+}
+
+type svmInstruction = {
+  programId: SvmTypes.Pubkey.t,
+  /** Raw instruction bytes as `0x`-prefixed hex. */
+  data: string,
+  accounts: array<SvmTypes.Pubkey.t>,
+  /** Path through the call tree: `[outerIndex]` for top-level instructions,
+   appended child indices for inner CPI calls. */
+  instructionAddress: array<int>,
+  isInner: bool,
+  /** Discriminator prefixes pre-extracted by HyperSync. Each is `Some` only
+   when the underlying instruction is at least that long. */
+  d1?: string,
+  d2?: string,
+  d4?: string,
+  d8?: string,
+  /** Borsh-decoded view. See [[svmDecodedInstruction]]. */
+  decoded?: svmDecodedInstruction,
+}
+
+type svmTransaction = {
+  signatures: array<string>,
+  feePayer?: SvmTypes.Pubkey.t,
+  success?: bool,
+  err?: string,
+  fee?: bigint,
+  computeUnitsConsumed?: bigint,
+  accountKeys: array<SvmTypes.Pubkey.t>,
+  recentBlockhash?: string,
+  version?: string,
+}
+
+type svmLog = {
+  kind: string,
+  message: string,
+}
+
+/** Inner block record on `svmInstructionEvent`. Field names follow EVM/Fuel
+ (`height`, `time`, `hash`) so the shared `Ecosystem.t` getters in
+ `Svm.res` work uniformly across ecosystems — `height` carries the slot. */
+type svmInstructionEventBlock = {
+  /** Slot number. Named `height` so the shared ecosystem getter reads it. */
+  height: int,
+  /** Unix block time (seconds). `0` when HyperSync didn't return a block
+   for this instruction's slot. */
+  time: int,
+  /** Block hash. Currently always empty — populated by the future
+   reorg-guard `queryBlockHash(slot)` route. */
+  hash: string,
+}
+
+/** The per-instruction payload handlers receive on `.event`. Mirrors the
+ EVM `type event` shape inside generated per-event modules. */
+type svmInstructionEvent = {
+  contractName: string,
+  eventName: string,
+  instruction: svmInstruction,
+  /** Parent transaction. `None` when the per-instruction
+   `include_transaction` flag is `false`. */
+  transaction: option<svmTransaction>,
+  /** Program log entries scoped to this instruction. `None` when the
+   per-instruction `include_logs` flag is `false`. */
+  logs: option<array<svmLog>>,
+  /** Convenience alias for `block.height`. */
+  slot: int,
+  /** Convenience alias for `block.time`. */
+  blockTime: option<int>,
+  block: svmInstructionEventBlock,
+}
+
+/** Arguments passed to handlers registered via `indexer.onInstruction`. */
+type svmOnInstructionArgs<'context> = {
+  event: svmInstructionEvent,
+  context: 'context,
+}
+
 // Internal-only type for the `indexer.onBlock` (and SVM `onSlot`) `where`
 // callback argument. The canonical TypeScript shape lives in
 // `packages/envio/index.d.ts`; the ReScript declaration here is free to

package/src/EventConfigBuilder.res

@@ -484,6 +484,56 @@ let buildEvmEventConfig = (
 
 // ============== Build Fuel event config ==============
 
+let buildSvmInstructionEventConfig = (
+  ~contractName: string,
+  ~instructionName: string,
+  ~programId: SvmTypes.Pubkey.t,
+  ~discriminator: option<string>,
+  ~discriminatorByteLen: int,
+  ~includeTransaction: bool,
+  ~includeLogs: bool,
+  ~accountFilters: array<Internal.svmAccountFilter>,
+  ~isInner: option<bool>,
+  ~isWildcard: bool,
+  ~handler: option<Internal.handler>,
+  ~contractRegister: option<Internal.contractRegister>,
+  ~accounts: array<string>=[],
+  ~args: JSON.t=JSON.Null,
+  ~definedTypes: JSON.t=JSON.Null,
+  ~startBlock: option<int>=?,
+): Internal.svmInstructionEventConfig => {
+  let paramsSchema =
+    S.json(~validate=false)
+    ->Utils.Schema.coerceToJsonPgType
+    ->(Utils.magic: S.t<JSON.t> => S.t<Internal.eventParams>)
+  {
+    id: switch discriminator {
+    | Some(d) => d
+    | None => "none"
+    },
+    name: instructionName,
+    contractName,
+    isWildcard,
+    handler,
+    contractRegister,
+    paramsRawEventSchema: paramsSchema,
+    simulateParamsSchema: paramsSchema,
+    filterByAddresses: false,
+    dependsOnAddresses: !isWildcard,
+    startBlock,
+    programId,
+    discriminator,
+    discriminatorByteLen,
+    includeTransaction,
+    includeLogs,
+    accountFilters,
+    isInner,
+    accounts,
+    args,
+    definedTypes,
+  }
+}
+
 let buildFuelEventConfig = (
   ~contractName: string,
   ~eventName: string,

package/src/EventConfigBuilder.res.mjs

@@ -350,6 +350,36 @@ function buildEvmEventConfig(contractName, eventName, sighash, params, isWildcar
   };
 }
 
+function buildSvmInstructionEventConfig(contractName, instructionName, programId, discriminator, discriminatorByteLen, includeTransaction, includeLogs, accountFilters, isInner, isWildcard, handler, contractRegister, accountsOpt, argsOpt, definedTypesOpt, startBlock) {
+  let accounts = accountsOpt !== undefined ? accountsOpt : [];
+  let args = argsOpt !== undefined ? argsOpt : null;
+  let definedTypes = definedTypesOpt !== undefined ? definedTypesOpt : null;
+  let paramsSchema = Utils.Schema.coerceToJsonPgType(S$RescriptSchema.json(false));
+  return {
+    id: discriminator !== undefined ? discriminator : "none",
+    name: instructionName,
+    contractName: contractName,
+    isWildcard: isWildcard,
+    filterByAddresses: false,
+    dependsOnAddresses: !isWildcard,
+    handler: handler,
+    contractRegister: contractRegister,
+    paramsRawEventSchema: paramsSchema,
+    simulateParamsSchema: paramsSchema,
+    startBlock: startBlock,
+    programId: programId,
+    discriminator: discriminator,
+    discriminatorByteLen: discriminatorByteLen,
+    includeTransaction: includeTransaction,
+    includeLogs: includeLogs,
+    accountFilters: accountFilters,
+    isInner: isInner,
+    accounts: accounts,
+    args: args,
+    definedTypes: definedTypes
+  };
+}
+
 function buildFuelEventConfig(contractName, eventName, kind, sighash, rawAbi, isWildcard, handler, contractRegister, startBlock) {
   let fuelKind;
   switch (kind) {
@@ -428,6 +458,7 @@ export {
   alwaysIncludedBlockFields,
   resolveFieldSelection,
   buildEvmEventConfig,
+  buildSvmInstructionEventConfig,
   buildFuelEventConfig,
 }
 /* eventParamComponentSchema Not a pure module */

package/src/HandlerLoader.res

@@ -142,7 +142,18 @@ let applyRegistrations = (~config: Config.t): Config.t => {
               dependsOnAddresses: Internal.dependsOnAddresses(~isWildcard, ~filterByAddresses),
             } :> Internal.eventConfig)
           | Svm =>
-            JsError.throwWithMessage(`SVM does not support indexer.onEvent or indexer.contractRegister. Use indexer.onSlot for per-slot handlers.`)
+            let svmEv =
+              ev->(Utils.magic: Internal.eventConfig => Internal.svmInstructionEventConfig)
+            ({
+              ...svmEv,
+              isWildcard,
+              handler,
+              contractRegister,
+              dependsOnAddresses: Internal.dependsOnAddresses(
+                ~isWildcard,
+                ~filterByAddresses=false,
+              ),
+            } :> Internal.eventConfig)
           }
         },
       )

package/src/HandlerLoader.res.mjs

@@ -109,7 +109,12 @@ function applyRegistrations(config) {
               kind: ev.kind
             };
           case "svm" :
-            return Stdlib_JsError.throwWithMessage(`SVM does not support indexer.onEvent or indexer.contractRegister. Use indexer.onSlot for per-slot handlers.`);
+            let newrecord = {...ev};
+            newrecord.contractRegister = contractRegister;
+            newrecord.handler = handler;
+            newrecord.dependsOnAddresses = Internal.dependsOnAddresses(isWildcard, false);
+            newrecord.isWildcard = isWildcard;
+            return newrecord;
         }
       });
       return {

package/src/InMemoryTable.res

@@ -71,7 +71,6 @@ module Entity = {
     fieldNameIndices: make(~hash=TableIndices.Index.getFieldName),
   }
 
-  exception UndefinedKey(string)
   let updateIndices = (
     self: t<'entity>,
     ~entity: 'entity,
@@ -83,8 +82,7 @@ module Entity = {
       let fieldValue =
         entity
         ->(Utils.magic: 'entity => dict<TableIndices.FieldValue.t>)
-        ->Dict.get(fieldName)
-        ->Option.getUnsafe
+        ->Dict.getUnsafe(fieldName)
       if !(index->TableIndices.Index.evaluate(~fieldName, ~fieldValue)) {
         entityIndices->Utils.Set.delete(index)->ignore
       }
@@ -93,27 +91,25 @@ module Entity = {
     self.fieldNameIndices.dict
     ->Dict.keysToArray
     ->Array.forEach(fieldName => {
-      switch (
-        entity->(Utils.magic: 'entity => dict<TableIndices.FieldValue.t>)->Dict.get(fieldName),
-        self.fieldNameIndices.dict->Dict.get(fieldName),
-      ) {
-      | (Some(fieldValue), Some(indices)) =>
-        indices
-        ->values
-        ->Array.forEach(((index, relatedEntityIds)) => {
-          if index->TableIndices.Index.evaluate(~fieldName, ~fieldValue) {
-            //Add entity id to indices and add index to entity indicies
-            relatedEntityIds->Utils.Set.add(getEntityIdUnsafe(entity))->ignore
-            entityIndices->Utils.Set.add(index)->ignore
-          } else {
-            relatedEntityIds->Utils.Set.delete(getEntityIdUnsafe(entity))->ignore
-          }
-        })
-      | _ =>
-        UndefinedKey(fieldName)->ErrorHandling.mkLogAndRaise(
-          ~msg="Expected field name to exist on the referenced index and the provided entity",
-        )
-      }
+      let indices = self.fieldNameIndices.dict->Dict.getUnsafe(fieldName)
+      // A missing key reads as `undefined`, which matches the `None` arm of
+      // `FieldValue.t` (`option<...>`). Mirror `addEmptyIndex` so nullable
+      // FK columns that were omitted on the set entity don't crash.
+      let fieldValue =
+        entity
+        ->(Utils.magic: 'entity => dict<TableIndices.FieldValue.t>)
+        ->Dict.getUnsafe(fieldName)
+      indices
+      ->values
+      ->Array.forEach(((index, relatedEntityIds)) => {
+        if index->TableIndices.Index.evaluate(~fieldName, ~fieldValue) {
+          //Add entity id to indices and add index to entity indicies
+          relatedEntityIds->Utils.Set.add(getEntityIdUnsafe(entity))->ignore
+          entityIndices->Utils.Set.add(index)->ignore
+        } else {
+          relatedEntityIds->Utils.Set.delete(getEntityIdUnsafe(entity))->ignore
+        }
+      })
     })
   }
 

package/src/InMemoryTable.res.mjs

@@ -90,8 +90,6 @@ function make$1() {
   };
 }
 
-let UndefinedKey = /* @__PURE__ */Primitive_exceptions.create("InMemoryTable.Entity.UndefinedKey");
-
 function updateIndices(self, entity, entityIndices) {
   entityIndices.forEach(index => {
     let fieldName = TableIndices.Index.getFieldName(index);
@@ -102,22 +100,9 @@ function updateIndices(self, entity, entityIndices) {
     }
   });
   Object.keys(self.fieldNameIndices.dict).forEach(fieldName => {
-    let match = entity[fieldName];
-    let match$1 = self.fieldNameIndices.dict[fieldName];
-    if (match === undefined) {
-      return ErrorHandling.mkLogAndRaise(undefined, "Expected field name to exist on the referenced index and the provided entity", {
-        RE_EXN_ID: UndefinedKey,
-        _1: fieldName
-      });
-    }
-    if (match$1 === undefined) {
-      return ErrorHandling.mkLogAndRaise(undefined, "Expected field name to exist on the referenced index and the provided entity", {
-        RE_EXN_ID: UndefinedKey,
-        _1: fieldName
-      });
-    }
-    let fieldValue = Primitive_option.valFromOption(match);
-    Object.values(match$1.dict).forEach(param => {
+    let indices = self.fieldNameIndices.dict[fieldName];
+    let fieldValue = entity[fieldName];
+    Object.values(indices.dict).forEach(param => {
       let relatedEntityIds = param[1];
       let index = param[0];
       if (TableIndices.Index.evaluate(index, fieldName, fieldValue)) {
@@ -333,7 +318,6 @@ let Entity = {
   getEntityIdUnsafe: getEntityIdUnsafe,
   makeIndicesSerializedToValue: makeIndicesSerializedToValue,
   make: make$1,
-  UndefinedKey: UndefinedKey,
   updateIndices: updateIndices,
   deleteEntityFromIndices: deleteEntityFromIndices,
   initValue: initValue,

package/src/Internal.res

@@ -422,6 +422,44 @@ type evmContractConfig = {
   events: array<evmEventConfig>,
 }
 
+type svmAccountFilter = {
+  position: int,
+  values: array<SvmTypes.Pubkey.t>,
+}
+
+type svmInstructionEventConfig = {
+  ...eventConfig,
+  /** Base58 Solana program id this instruction belongs to. */
+  programId: SvmTypes.Pubkey.t,
+  /** Hex-encoded discriminator. `None` matches every instruction in the program. */
+  discriminator: option<string>,
+  /** Length of the discriminator in bytes (0 / 1 / 2 / 4 / 8). Drives the
+   `dN` selector at query time and the dispatch-key precomputation in the
+   router. */
+  discriminatorByteLen: int,
+  includeTransaction: bool,
+  includeLogs: bool,
+  accountFilters: array<svmAccountFilter>,
+  /** `None` matches both outer and inner (CPI-invoked) instructions. */
+  isInner: option<bool>,
+  /** Positional account names from the Borsh schema, in declared order.
+   `[]` means no schema is attached for this instruction. */
+  accounts: array<string>,
+  /** Borsh args layout as `Vec<ArgDef>` JSON (see `human_config::svm::ArgDef`
+   on the Rust side). `JSON.Null` means no schema is attached. */
+  args: JSON.t,
+  /** Program-level nominal-type registry (`BTreeMap<String, ArgType>` JSON).
+   Duplicated on every event of the same program — the runtime dedups by
+   `programId` when registering. `JSON.Null` when empty. */
+  definedTypes: JSON.t,
+}
+
+type svmProgramConfig = {
+  name: string,
+  programId: SvmTypes.Pubkey.t,
+  instructions: array<svmInstructionEventConfig>,
+}
+
 type indexingAddress = {
   address: Address.t,
   contractName: string,