envio 3.0.0 → 3.0.2-svm-alpha.0

package/evm.schema.json

@@ -4,6 +4,10 @@
   "description": "Schema for a YAML config for an envio indexer",
   "type": "object",
   "properties": {
+    "name": {
+      "description": "Name of the project",
+      "type": "string"
+    },
     "description": {
       "description": "Description of the project",
       "type": [
@@ -11,10 +15,6 @@
         "null"
       ]
     },
-    "name": {
-      "description": "Name of the project",
-      "type": "string"
-    },
     "schema": {
       "description": "Custom path to schema.graphql file",
       "type": [
@@ -67,7 +67,7 @@
         "null"
       ],
       "items": {
-        "$ref": "#/$defs/GlobalContract_for_ContractConfig"
+        "$ref": "#/$defs/GlobalContract"
       }
     },
     "chains": {
@@ -189,7 +189,7 @@
         "evm"
       ]
     },
-    "GlobalContract_for_ContractConfig": {
+    "GlobalContract": {
       "type": "object",
       "properties": {
         "name": {
@@ -418,7 +418,7 @@
             "null"
           ],
           "items": {
-            "$ref": "#/$defs/ChainContract_for_ContractConfig"
+            "$ref": "#/$defs/ChainContract"
           }
         }
       },
@@ -578,7 +578,7 @@
         "url"
       ]
     },
-    "ChainContract_for_ContractConfig": {
+    "ChainContract": {
       "type": "object",
       "properties": {
         "name": {

package/fuel.schema.json

@@ -4,6 +4,10 @@
   "description": "Schema for a YAML config for an envio indexer",
   "type": "object",
   "properties": {
+    "name": {
+      "description": "Name of the project",
+      "type": "string"
+    },
     "description": {
       "description": "Description of the project",
       "type": [
@@ -11,10 +15,6 @@
         "null"
       ]
     },
-    "name": {
-      "description": "Name of the project",
-      "type": "string"
-    },
     "schema": {
       "description": "Custom path to schema.graphql file",
       "type": [
@@ -60,7 +60,7 @@
         "null"
       ],
       "items": {
-        "$ref": "#/$defs/GlobalContract_for_ContractConfig"
+        "$ref": "#/$defs/GlobalContract"
       }
     },
     "chains": {
@@ -147,7 +147,7 @@
         "fuel"
       ]
     },
-    "GlobalContract_for_ContractConfig": {
+    "GlobalContract": {
       "type": "object",
       "properties": {
         "name": {
@@ -183,6 +183,10 @@
     "EventConfig": {
       "type": "object",
       "properties": {
+        "name": {
+          "description": "Name of the event in the HyperIndex generated code",
+          "type": "string"
+        },
         "type": {
           "description": "Explicitly set the event type you want to index. It's derived from the event name and fallbacks to LogData.",
           "anyOf": [
@@ -194,10 +198,6 @@
             }
           ]
         },
-        "name": {
-          "description": "Name of the event in the HyperIndex generated code",
-          "type": "string"
-        },
         "logId": {
           "description": "An identifier of a logged type from ABI. Used for indexing LogData receipts. The option can be omitted when the event name matches the logged struct/enum name.",
           "type": [
@@ -281,7 +281,7 @@
             "null"
           ],
           "items": {
-            "$ref": "#/$defs/ChainContract_for_ContractConfig"
+            "$ref": "#/$defs/ChainContract"
           }
         }
       },
@@ -304,7 +304,7 @@
         "url"
       ]
     },
-    "ChainContract_for_ContractConfig": {
+    "ChainContract": {
       "type": "object",
       "properties": {
         "name": {

package/index.d.ts

@@ -961,6 +961,125 @@ export type SvmOnSlotOptions<Config extends IndexerConfigTypes = GlobalConfig> =
   readonly where?: (args: SvmOnSlotWhereArgs<Config>) => SvmOnSlotWhereResult;
 };
 
+// ============== SVM onInstruction types ==============
+
+/** Borsh-decoded view of an instruction. Present whenever a `ProgramSchema`
+ * was attached to the program (bundled, Anchor IDL, or hand-written
+ * `accounts`/`args` in YAML). Absent when no schema applies or the
+ * discriminator didn't match any registered instruction. */
+export type SvmDecodedInstruction = {
+  /** Schema-declared instruction name. */
+  readonly name: string;
+  /** Borsh-decoded args object. POC types this as `unknown`; narrow with a
+   * locally-declared type until the typed-args codegen lands. */
+  readonly args: unknown;
+  /** Named accounts in schema order. Keys are exactly the schema-declared
+   * names; values are base58 pubkeys. */
+  readonly accounts: Readonly<Record<string, string>>;
+  /** Accounts beyond the schema's named list (Anchor `remaining_accounts`,
+   * IDL drift). Empty when counts match the schema. */
+  readonly extraAccounts: readonly string[];
+};
+
+/** A single Solana instruction matched by the indexer.
+ *
+ * `data` and discriminator prefixes are `0x`-prefixed hex strings; accounts
+ * are base58 strings. When a Borsh schema is configured (bundled, Anchor
+ * IDL, or hand-written YAML), `decoded` carries the named-accounts +
+ * decoded-args view. */
+export type SvmInstruction = {
+  readonly programId: string;
+  readonly data: string;
+  readonly accounts: readonly string[];
+  readonly instructionAddress: readonly number[];
+  readonly isInner: boolean;
+  readonly d1?: string;
+  readonly d2?: string;
+  readonly d4?: string;
+  readonly d8?: string;
+  readonly decoded?: SvmDecodedInstruction;
+};
+
+/** Parent transaction surfaced when an instruction's
+ * `include_transaction` flag is `true`. */
+export type SvmTransaction = {
+  readonly signatures: readonly string[];
+  readonly feePayer?: string;
+  readonly success?: boolean;
+  readonly err?: string;
+  /** Lamports. */
+  readonly fee?: bigint;
+  readonly computeUnitsConsumed?: bigint;
+  readonly accountKeys: readonly string[];
+  readonly recentBlockhash?: string;
+  readonly version?: string;
+};
+
+export type SvmLog = {
+  readonly kind: string;
+  readonly message: string;
+};
+
+/** A single Solana instruction event delivered to a handler. Parameterised
+ * over `Decoded` so the per-(program, instruction) overload of
+ * `onInstruction` can narrow `event.instruction.decoded` to the
+ * codegen-generated `{ args, accounts }` shape. */
+export type SvmInstructionEvent<
+  Decoded extends SvmDecodedInstruction = SvmDecodedInstruction,
+> = {
+  readonly contractName: string;
+  readonly eventName: string;
+  readonly instruction: Omit<SvmInstruction, "decoded"> & {
+    readonly decoded?: Decoded;
+  };
+  /** Present when the instruction's `include_transaction` is `true`. */
+  readonly transaction?: SvmTransaction;
+  /** Present when the instruction's `include_logs` is `true`; only logs
+   * scoped to this exact instruction (matching `instruction_address`). */
+  readonly logs?: readonly SvmLog[];
+  readonly slot: number;
+  readonly blockTime?: number;
+};
+
+/** Arguments passed to handlers registered via `indexer.onInstruction`. */
+export type SvmOnInstructionHandlerArgs<
+  Config extends IndexerConfigTypes = GlobalConfig,
+  Event extends SvmInstructionEvent = SvmInstructionEvent,
+> = {
+  readonly event: Event;
+  readonly context: SvmOnSlotContext<Config>;
+};
+
+/** Shape extracted from `Global.config.svm.programs[P][I]`. The codegen
+ * emits `{ args: ...; accounts: ... }` per (program, instruction); this
+ * helper turns that into a `SvmDecodedInstruction`-compatible record. */
+type SvmDecodedFromProgramTable<TInstr> = TInstr extends {
+  args: infer A;
+  accounts: infer Acc extends Readonly<Record<string, string>>;
+}
+  ? {
+      readonly name: string;
+      readonly args: A;
+      readonly accounts: Acc;
+      readonly extraAccounts: readonly string[];
+    }
+  : SvmDecodedInstruction;
+
+/** Options for an SVM `indexer.onInstruction` registration. */
+export type SvmOnInstructionOptions<P extends string = string, I extends string = string> = {
+  /** Program name as declared under `chains[].programs[].name` in
+   * `config.yaml`. */
+  readonly program: P;
+  /** Instruction name as declared under
+   * `chains[].programs[].instructions[].name` in `config.yaml`. */
+  readonly instruction: I;
+};
+
+/** Handler function for an SVM `indexer.onInstruction` registration. */
+export type SvmOnInstructionHandler<
+  Config extends IndexerConfigTypes = GlobalConfig,
+> = (args: SvmOnInstructionHandlerArgs<Config>) => Promise<void>;
+
 // ============== Indexer Types ==============
 
 // Helper: Check if an ecosystem is configured. Single-ecosystem indexers only
@@ -1138,7 +1257,7 @@ type FuelEcosystem<Config extends IndexerConfigTypes = GlobalConfig> =
       : never
     : never;
 
-// SVM ecosystem type — chains plus onSlot handler method. SVM has no onEvent yet.
+// SVM ecosystem type — chains plus instruction + slot handler methods.
 type SvmEcosystem<Config extends IndexerConfigTypes = GlobalConfig> =
   "svm" extends keyof Config
     ? Config["svm"] extends { chains: infer Chains }
@@ -1162,7 +1281,41 @@ type SvmEcosystem<Config extends IndexerConfigTypes = GlobalConfig> =
               options: SvmOnSlotOptions<Config>,
               handler: SvmOnSlotHandler<Config>,
             ) => void;
+          } & (Config["svm"] extends {
+            programs: infer Programs extends Record<string, Record<string, any>>;
           }
+            ? {
+                /**
+                 * Register an instruction handler. Dispatch matches on
+                 * `(programId, discriminator)` from the YAML config.
+                 * `event.instruction.decoded.args` and
+                 * `event.instruction.decoded.accounts` are typed from the
+                 * program's Borsh schema (Anchor IDL, bundled, or
+                 * hand-written `accounts`/`args` in YAML). `decoded` stays
+                 * optional at runtime because schema-matching can fail on
+                 * IDL drift or unknown discriminators.
+                 */
+                readonly onInstruction: <
+                  P extends keyof Programs & string,
+                  I extends keyof Programs[P] & string,
+                >(
+                  options: SvmOnInstructionOptions<P, I>,
+                  handler: (
+                    args: SvmOnInstructionHandlerArgs<
+                      Config,
+                      SvmInstructionEvent<SvmDecodedFromProgramTable<Programs[P][I]>>
+                    >,
+                  ) => Promise<void>,
+                ) => void;
+              }
+            : {
+                /** Untyped fallback for indexers with no `programs` in
+                 * config. `decoded` stays the generic shape. */
+                readonly onInstruction: (
+                  options: SvmOnInstructionOptions,
+                  handler: SvmOnInstructionHandler<Config>,
+                ) => void;
+              })
         : never
       : never
     : never;
@@ -1178,6 +1331,7 @@ type CodegenRequiredHint =
   "Run 'envio codegen' to generate handler types from config.yaml. Without codegen, the indexer has no contracts, chains, or events to register handlers for.";
 type CodegenRequiredFallback = {
   readonly onEvent: (...hint: CodegenRequiredHint[]) => void;
+  readonly onInstruction: (...hint: CodegenRequiredHint[]) => void;
   readonly onBlock: (...hint: CodegenRequiredHint[]) => void;
   readonly onSlot: (...hint: CodegenRequiredHint[]) => void;
   readonly contractRegister: (...hint: CodegenRequiredHint[]) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "envio",
-  "version": "3.0.0",
+  "version": "3.0.2-svm-alpha.0",
   "type": "module",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.mjs",
@@ -43,7 +43,6 @@
     "@clickhouse/client": "1.17.0",
     "@elastic/ecs-pino-format": "1.4.0",
     "@envio-dev/hyperfuel-client": "1.2.2",
-    "@envio-dev/hypersync-client": "1.3.0",
     "@fuel-ts/crypto": "0.96.1",
     "@fuel-ts/errors": "0.96.1",
     "@fuel-ts/hasher": "0.96.1",
@@ -71,10 +70,10 @@
     "tsx": "4.21.0"
   },
   "optionalDependencies": {
-    "envio-linux-x64": "3.0.0",
-    "envio-linux-x64-musl": "3.0.0",
-    "envio-linux-arm64": "3.0.0",
-    "envio-darwin-x64": "3.0.0",
-    "envio-darwin-arm64": "3.0.0"
+    "envio-linux-x64": "3.0.2-svm-alpha.0",
+    "envio-linux-x64-musl": "3.0.2-svm-alpha.0",
+    "envio-linux-arm64": "3.0.2-svm-alpha.0",
+    "envio-darwin-x64": "3.0.2-svm-alpha.0",
+    "envio-darwin-arm64": "3.0.2-svm-alpha.0"
   }
 }

package/src/ChainFetcher.res

@@ -233,7 +233,31 @@ let make = (
       ~lowercaseAddresses,
     )
   | Config.FuelSourceConfig({hypersync}) => [HyperFuelSource.make({chain, endpointUrl: hypersync})]
-  | Config.SvmSourceConfig({rpc}) => [Svm.makeRPCSource(~chain, ~rpc)]
+  | Config.SvmSourceConfig({hypersync, rpc}) =>
+    switch hypersync {
+    | None => [Svm.makeRPCSource(~chain, ~rpc)]
+    | Some(hypersyncUrl) =>
+      // HyperSync drives instruction sync; RPC remains the height oracle
+      // (Svm.makeRPCSource's `getFinalizedSlot` route) and the fallback.
+      let svmEventConfigs =
+        chainConfig.contracts
+        ->Array.flatMap(contract => contract.events)
+        ->(
+          Utils.magic: array<Internal.eventConfig> => array<Internal.svmInstructionEventConfig>
+        )
+      let apiToken = Env.envioApiToken
+      [
+        HyperSyncSolanaSource.make({
+          chain,
+          endpointUrl: hypersyncUrl,
+          apiToken,
+          eventConfigs: svmEventConfigs,
+          clientMaxRetries: Env.hyperSyncClientMaxRetries,
+          clientTimeoutMillis: Env.hyperSyncClientTimeoutMillis,
+        }),
+        Svm.makeRPCSource(~chain, ~rpc, ~sourceFor=Fallback),
+      ]
+    }
   // For tests: use ready-to-use sources directly
   | Config.CustomSources(sources) => sources
   }

package/src/ChainFetcher.res.mjs

@@ -21,6 +21,7 @@ import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as HyperFuelSource from "./sources/HyperFuelSource.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as HyperSyncSolanaSource from "./sources/HyperSyncSolanaSource.res.mjs";
 import * as SafeCheckpointTracking from "./SafeCheckpointTracking.res.mjs";
 
 function configAddresses(chainConfig) {
@@ -133,7 +134,24 @@ function make(chainConfig, indexingAddresses, startBlock, endBlock, firstEventBl
         })];
       break;
     case "SvmSourceConfig" :
-      sources$1 = [Svm.makeRPCSource(chain, sources.rpc)];
+      let rpc = sources.rpc;
+      let hypersync = sources.hypersync;
+      if (hypersync !== undefined) {
+        let svmEventConfigs = chainConfig.contracts.flatMap(contract => contract.events);
+        sources$1 = [
+          HyperSyncSolanaSource.make({
+            chain: chain,
+            endpointUrl: hypersync,
+            apiToken: Env.envioApiToken,
+            eventConfigs: svmEventConfigs,
+            clientMaxRetries: Env.hyperSyncClientMaxRetries,
+            clientTimeoutMillis: Env.hyperSyncClientTimeoutMillis
+          }),
+          Svm.makeRPCSource(chain, rpc, "Fallback")
+        ];
+      } else {
+        sources$1 = [Svm.makeRPCSource(chain, rpc, undefined)];
+      }
       break;
     case "CustomSources" :
       sources$1 = sources._0;

package/src/Config.res

@@ -30,7 +30,7 @@ type evmRpcConfig = {
 type sourceConfig =
   | EvmSourceConfig({hypersync: option<string>, rpcs: array<evmRpcConfig>})
   | FuelSourceConfig({hypersync: string})
-  | SvmSourceConfig({rpc: string})
+  | SvmSourceConfig({hypersync: option<string>, rpc: string})
   // For tests: pass custom sources directly
   | CustomSources(array<Source.t>)
 
@@ -201,6 +201,38 @@ let publicConfigChainSchema = S.schema(s =>
   }
 )
 
+let svmEventDescriptorSchema = S.schema(s =>
+  {
+    "discriminator": s.matches(S.option(S.string)),
+    "discriminatorByteLen": s.matches(S.int),
+    "includeTransaction": s.matches(S.bool),
+    "includeLogs": s.matches(S.bool),
+    "accountFilters": s.matches(
+      S.option(
+        S.array(
+          S.schema(
+            s => {
+              "position": s.matches(S.int),
+              "values": s.matches(S.array(S.string)),
+            },
+          ),
+        ),
+      ),
+    ),
+    "isInner": s.matches(S.option(S.bool)),
+    "accounts": s.matches(S.option(S.array(S.string))),
+    "args": s.matches(S.option(S.json(~validate=false))),
+  }
+)
+
+let svmAbiSchema = S.schema(s =>
+  {
+    "programId": s.matches(S.string),
+    "definedTypes": s.matches(S.json(~validate=false)),
+    "source": s.matches(S.string),
+  }
+)
+
 let contractEventItemSchema = S.schema(s =>
   {
     "event": s.matches(S.string),
@@ -210,6 +242,7 @@ let contractEventItemSchema = S.schema(s =>
     "kind": s.matches(S.option(S.string)),
     "blockFields": s.matches(S.option(S.array(Internal.evmBlockFieldSchema))),
     "transactionFields": s.matches(S.option(S.array(Internal.evmTransactionFieldSchema))),
+    "svm": s.matches(S.option(svmEventDescriptorSchema)),
   }
 )
 
@@ -219,6 +252,8 @@ let contractConfigSchema = S.schema(s =>
     "handler": s.matches(S.option(S.string)),
     // EVM-specific: event signatures for HyperSync queries
     "events": s.matches(S.option(S.array(contractEventItemSchema))),
+    // SVM-only: program-level Borsh schema (defined-types registry, source).
+    "svmAbi": s.matches(S.option(svmAbiSchema)),
   }
 )
 
@@ -226,6 +261,10 @@ let publicConfigEcosystemSchema = S.schema(s =>
   {
     "chains": s.matches(S.dict(publicConfigChainSchema)),
     "contracts": s.matches(S.option(S.dict(contractConfigSchema))),
+    // SVM-only alias: programs are the SVM analog of EVM/Fuel contracts.
+    // Parsed via the same `contractConfigSchema` and read in `fromPublic`'s
+    // `publicContractsConfig` switch.
+    "programs": s.matches(S.option(S.dict(contractConfigSchema))),
   }
 )
 
@@ -523,10 +562,19 @@ let fromPublic = (publicConfigJson: JSON.t) => {
   | None => false
   }
 
-  // Parse contract configs (ABIs, events, handlers)
-  let publicContractsConfig = switch (ecosystemName, publicConfig["evm"], publicConfig["fuel"]) {
-  | (Ecosystem.Evm, Some(evm), _) => evm["contracts"]
-  | (Ecosystem.Fuel, _, Some(fuel)) => fuel["contracts"]
+  // Parse contract configs (ABIs, events, handlers).
+  // SVM stores them under `svm.programs` in the public JSON — the per-program
+  // events drive `indexer.onInstruction` registration the same way EVM/Fuel
+  // contracts drive `onEvent`.
+  let publicContractsConfig = switch (
+    ecosystemName,
+    publicConfig["evm"],
+    publicConfig["fuel"],
+    publicConfig["svm"],
+  ) {
+  | (Ecosystem.Evm, Some(evm), _, _) => evm["contracts"]
+  | (Ecosystem.Fuel, _, Some(fuel), _) => fuel["contracts"]
+  | (Ecosystem.Svm, _, _, Some(svm)) => svm["programs"]
   | _ => None
   }
 
@@ -549,6 +597,7 @@ let fromPublic = (publicConfigJson: JSON.t) => {
     "abi": EvmTypes.Abi.t,
     "eventSignatures": array<string>,
     "events": option<array<_>>,
+    "svmAbi": option<{"programId": string, "definedTypes": JSON.t, "source": string}>,
   }> = Dict.make()
   switch publicContractsConfig {
   | Some(contractsDict) =>
@@ -561,21 +610,40 @@ let fromPublic = (publicConfigJson: JSON.t) => {
       | Some(events) => events->Array.map(eventItem => eventItem["event"])
       | None => []
       }
+      let widened =
+        contractConfig->(
+          Utils.magic: _ => {
+            "svmAbi": option<{"programId": string, "definedTypes": JSON.t, "source": string}>,
+          }
+        )
       contractDataByName->Dict.set(
         capitalizedName,
-        {"abi": abi, "eventSignatures": eventSignatures, "events": contractConfig["events"]},
+        {
+          "abi": abi,
+          "eventSignatures": eventSignatures,
+          "events": contractConfig["events"],
+          "svmAbi": widened["svmAbi"],
+        },
       )
     })
   | None => ()
   }
 
-  // Build event configs for a contract from JSON event items
+  // Build event configs for a contract from JSON event items.
+  //
+  // `~addresses` is the chain-side address list. For SVM programs it's the
+  // single base58 program_id — wired onto each instruction's event config so
+  // the source can build `(programId, discriminator)`-keyed InstructionSelections.
+  // EVM and Fuel ignore it (the address lives in `ChainContract.addresses` and
+  // is looked up at dispatch time, not stamped on the event).
   let buildContractEvents = (
     ~contractName,
     ~events: option<array<_>>,
     ~abi,
     ~chainId: int,
     ~startBlock: option<int>,
+    ~addresses: array<string>,
+    ~svmDefinedTypes: JSON.t=JSON.Null,
   ) => {
     switch events {
     | None => []
@@ -606,6 +674,65 @@ let fromPublic = (publicConfigJson: JSON.t) => {
               `Fuel event ${contractName}.${eventName} is missing "kind" in internal config`,
             )
           }
+        | Ecosystem.Svm =>
+          let programId = switch addresses {
+          | [pid] => pid->SvmTypes.Pubkey.fromStringUnsafe
+          | [] =>
+            JsError.throwWithMessage(
+              `SVM program ${contractName} on chain ${chainId->Int.toString} is missing a program_id`,
+            )
+          | _ =>
+            JsError.throwWithMessage(
+              `SVM program ${contractName} on chain ${chainId->Int.toString} has multiple addresses; a program is uniquely identified by a single program_id`,
+            )
+          }
+          let widenedEventItem =
+            eventItem->(
+              Utils.magic: _ => {
+                "svm": option<{
+                  "discriminator": option<string>,
+                  "discriminatorByteLen": int,
+                  "includeTransaction": bool,
+                  "includeLogs": bool,
+                  "accountFilters": option<
+                    array<{"position": int, "values": array<string>}>,
+                  >,
+                  "isInner": option<bool>,
+                  "accounts": option<array<string>>,
+                  "args": option<JSON.t>,
+                }>,
+              }
+            )
+          let svm = switch widenedEventItem["svm"] {
+          | Some(s) => s
+          | None =>
+            JsError.throwWithMessage(
+              `SVM instruction ${contractName}.${eventName} is missing the "svm" descriptor in internal config`,
+            )
+          }
+          let accountFilters =
+            (svm["accountFilters"]->Option.getOr([]))->Array.map(af => {
+              Internal.position: af["position"],
+              values: af["values"]->SvmTypes.Pubkey.fromStringsUnsafe,
+            })
+          (EventConfigBuilder.buildSvmInstructionEventConfig(
+            ~contractName,
+            ~instructionName=eventName,
+            ~programId,
+            ~discriminator=svm["discriminator"],
+            ~discriminatorByteLen=svm["discriminatorByteLen"],
+            ~includeTransaction=svm["includeTransaction"],
+            ~includeLogs=svm["includeLogs"],
+            ~accountFilters,
+            ~isInner=svm["isInner"],
+            ~isWildcard=false,
+            ~handler=None,
+            ~contractRegister=None,
+            ~accounts=svm["accounts"]->Option.getOr([]),
+            ~args=svm["args"]->Option.getOr(JSON.Null),
+            ~definedTypes=svmDefinedTypes,
+            ~startBlock?,
+          ) :> Internal.eventConfig)
         | _ =>
           (EventConfigBuilder.buildEvmEventConfig(
             ~contractName,
@@ -665,11 +792,11 @@ let fromPublic = (publicConfigJson: JSON.t) => {
         ->Dict.toArray
         ->Array.map(((capitalizedName, contractData)) => {
           let chainContract = chainContracts->Dict.get(capitalizedName)
-          let addresses =
+          let rawAddresses =
             chainContract
             ->Option.flatMap(cc => cc["addresses"])
             ->Option.getOr([])
-            ->Array.map(parseAddress)
+          let addresses = rawAddresses->Array.map(parseAddress)
           let startBlock = chainContract->Option.flatMap(cc => cc["startBlock"])
 
           // Build event configs from JSON (field selections resolved inline)
@@ -683,6 +810,10 @@ let fromPublic = (publicConfigJson: JSON.t) => {
             ~abi=contractData["abi"],
             ~chainId,
             ~startBlock,
+            ~addresses=rawAddresses,
+            ~svmDefinedTypes=contractData["svmAbi"]
+            ->Option.map(a => a["definedTypes"])
+            ->Option.getOr(JSON.Null),
           )
 
           {
@@ -748,7 +879,11 @@ let fromPublic = (publicConfigJson: JSON.t) => {
         }
       | Ecosystem.Svm =>
         switch publicChainConfig["rpc"] {
-        | Some(rpc) => SvmSourceConfig({rpc: rpc})
+        | Some(rpc) =>
+          SvmSourceConfig({
+            hypersync: publicChainConfig["hypersync"],
+            rpc,
+          })
         | None => JsError.throwWithMessage(`Chain ${chainName} is missing rpc endpoint in config`)
         }
       }