envio 3.0.2-svm-alpha.2 → 3.1.0-rc.0

package/index.d.ts

@@ -959,137 +959,6 @@ 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;
-};
-
-export type SvmTokenBalance = {
-  readonly account?: string;
-  readonly mint?: string;
-  readonly owner?: string;
-  /** u64 decimal string. Cast with BigInt(...) for arithmetic. */
-  readonly preAmount?: string;
-  readonly postAmount?: string;
-};
-
-/** 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;
-  /** SPL Token / Token-2022 balance snapshots for this transaction.
-   * Present when `include_token_balances` is `true`. */
-  readonly tokenBalances?: readonly SvmTokenBalance[];
-};
-
-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
@@ -1267,7 +1136,7 @@ type FuelEcosystem<Config extends IndexerConfigTypes = GlobalConfig> =
       : never
     : never;
 
-// SVM ecosystem type — chains plus instruction + slot handler methods.
+// SVM ecosystem type — chains plus onSlot handler method. SVM has no onEvent yet.
 type SvmEcosystem<Config extends IndexerConfigTypes = GlobalConfig> =
   "svm" extends keyof Config
     ? Config["svm"] extends { chains: infer Chains }
@@ -1291,41 +1160,7 @@ 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;
@@ -1341,7 +1176,6 @@ 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.2-svm-alpha.2",
+  "version": "3.1.0-rc.0",
   "type": "module",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.mjs",
@@ -70,10 +70,10 @@
     "tsx": "4.21.0"
   },
   "optionalDependencies": {
-    "envio-linux-x64": "3.0.2-svm-alpha.2",
-    "envio-linux-x64-musl": "3.0.2-svm-alpha.2",
-    "envio-linux-arm64": "3.0.2-svm-alpha.2",
-    "envio-darwin-x64": "3.0.2-svm-alpha.2",
-    "envio-darwin-arm64": "3.0.2-svm-alpha.2"
+    "envio-linux-x64": "3.1.0-rc.0",
+    "envio-linux-x64-musl": "3.1.0-rc.0",
+    "envio-linux-arm64": "3.1.0-rc.0",
+    "envio-darwin-x64": "3.1.0-rc.0",
+    "envio-darwin-arm64": "3.1.0-rc.0"
   }
 }

package/rescript.json

@@ -18,6 +18,6 @@
   "dependencies": ["rescript-schema", "@rescript/react"],
   "compiler-flags": ["-open RescriptSchema"],
   "warnings": {
-    "error": "+3"
+    "error": "+a"
   }
 }

package/src/ChainFetcher.res

@@ -229,31 +229,7 @@ let make = (
       ~lowercaseAddresses,
     )
   | Config.FuelSourceConfig({hypersync}) => [HyperFuelSource.make({chain, endpointUrl: hypersync})]
-  | 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),
-      ]
-    }
+  | Config.SvmSourceConfig({rpc}) => [Svm.makeRPCSource(~chain, ~rpc)]
   // For tests: use ready-to-use sources directly
   | Config.CustomSources(sources) => sources
   }

package/src/ChainFetcher.res.mjs

@@ -21,7 +21,6 @@ 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,24 +132,7 @@ function make(chainConfig, indexingAddresses, startBlock, endBlock, firstEventBl
         })];
       break;
     case "SvmSourceConfig" :
-      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)];
-      }
+      sources$1 = [Svm.makeRPCSource(chain, sources.rpc)];
       break;
     case "CustomSources" :
       sources$1 = sources._0;

package/src/ChainManager.res

@@ -1,5 +1,4 @@
 type t = {
-  committedCheckpointId: bigint,
   chainFetchers: ChainMap.t<ChainFetcher.t>,
   isInReorgThreshold: bool,
   // True once every chain has caught up to head/endBlock. Monotonic during a run.
@@ -106,7 +105,6 @@ let makeFromDbState = (
   }
 
   {
-    committedCheckpointId: initialState.checkpointId,
     chainFetchers,
     isInReorgThreshold,
     isRealtime,
@@ -135,9 +133,14 @@ let nextItemIsNone = (chainManager: t): bool => {
   )
 }
 
-let createBatch = (chainManager: t, ~batchSizeTarget: int, ~isRollback: bool): Batch.t => {
+let createBatch = (
+  chainManager: t,
+  ~committedCheckpointId,
+  ~batchSizeTarget: int,
+  ~isRollback: bool,
+): Batch.t => {
   Batch.make(
-    ~checkpointIdBeforeBatch=chainManager.committedCheckpointId->BigInt.add(
+    ~checkpointIdBeforeBatch=committedCheckpointId->BigInt.add(
       // Since for rollback we have a diff checkpoint id.
       // This is needed to currectly overwrite old state
       // in an append-only ClickHouse insert.

package/src/ChainManager.res.mjs

@@ -77,7 +77,6 @@ function makeFromDbState(initialState, config, registrations, reducedPollingInte
     Prometheus.ProgressReady.setAllReady();
   }
   return {
-    committedCheckpointId: initialState.checkpointId,
     chainFetchers: chainFetchers,
     isInReorgThreshold: isInReorgThreshold,
     isRealtime: isRealtime
@@ -90,7 +89,6 @@ function getChainFetcher(chainManager, chain) {
 
 function setChainFetcher(chainManager, chainFetcher) {
   return {
-    committedCheckpointId: chainManager.committedCheckpointId,
     chainFetchers: ChainMap.set(chainManager.chainFetchers, ChainMap.Chain.makeUnsafe(chainFetcher.chainConfig.id), chainFetcher),
     isInReorgThreshold: chainManager.isInReorgThreshold,
     isRealtime: chainManager.isRealtime
@@ -101,8 +99,8 @@ function nextItemIsNone(chainManager) {
   return !Batch.hasReadyItem(ChainMap.map(chainManager.chainFetchers, cf => cf.fetchState));
 }
 
-function createBatch(chainManager, batchSizeTarget, isRollback) {
-  return Batch.make(chainManager.committedCheckpointId + (
+function createBatch(chainManager, committedCheckpointId, batchSizeTarget, isRollback) {
+  return Batch.make(committedCheckpointId + (
     isRollback ? 1n : 0n
   ), ChainMap.map(chainManager.chainFetchers, cf => ({
     fetchState: cf.fetchState,

package/src/Config.res

@@ -28,7 +28,7 @@ type evmRpcConfig = {
 type sourceConfig =
   | EvmSourceConfig({hypersync: option<string>, rpcs: array<evmRpcConfig>})
   | FuelSourceConfig({hypersync: string})
-  | SvmSourceConfig({hypersync: option<string>, rpc: string})
+  | SvmSourceConfig({rpc: string})
   // For tests: pass custom sources directly
   | CustomSources(array<Source.t>)
 
@@ -194,39 +194,6 @@ 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),
-    "includeTokenBalances": 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 =>
   {
     "name": s.matches(S.string),
@@ -235,7 +202,6 @@ 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)),
   }
 )
 
@@ -245,8 +211,6 @@ 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)),
   }
 )
 
@@ -254,10 +218,6 @@ 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))),
   }
 )
 
@@ -558,19 +518,10 @@ let fromPublic = (publicConfigJson: JSON.t) => {
   | None => false
   }
 
-  // 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"]
+  // 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"]
   | _ => None
   }
 
@@ -588,12 +539,7 @@ let fromPublic = (publicConfigJson: JSON.t) => {
   | None => (Utils.Set.fromArray(EventConfigBuilder.alwaysIncludedBlockFields), Utils.Set.make())
   }
 
-  let contractDataByName: dict<{
-    "abi": EvmTypes.Abi.t,
-    "eventSignatures": array<string>,
-    "events": option<array<_>>,
-    "svmAbi": option<{"programId": string, "definedTypes": JSON.t, "source": string}>,
-  }> = Dict.make()
+  let contractDataByName: dict<{"abi": EvmTypes.Abi.t, "events": option<array<_>>}> = Dict.make()
   switch publicContractsConfig {
   | Some(contractsDict) =>
     contractsDict
@@ -601,44 +547,21 @@ let fromPublic = (publicConfigJson: JSON.t) => {
     ->Array.forEach(((contractName, contractConfig)) => {
       let capitalizedName = contractName->Utils.String.capitalize
       let abi = contractConfig["abi"]->(Utils.magic: JSON.t => EvmTypes.Abi.t)
-      let eventSignatures = switch contractConfig["events"] {
-      | Some(events) => events->Array.map(eventItem => eventItem["sighash"])
-      | 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"],
-          "svmAbi": widened["svmAbi"],
-        },
+        {"abi": abi, "events": contractConfig["events"]},
       )
     })
   | None => ()
   }
 
-  // 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).
+  // Build event configs for a contract from JSON event items
   let buildContractEvents = (
     ~contractName,
     ~events: option<array<_>>,
     ~abi,
     ~chainId: int,
     ~startBlock: option<int>,
-    ~addresses: array<string>,
-    ~svmDefinedTypes: JSON.t=JSON.Null,
   ) => {
     switch events {
     | None => []
@@ -669,69 +592,6 @@ 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,
-                  "includeTokenBalances": bool,
-                  "accountFilters": option<
-                    array<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(group =>
-              group->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"],
-            ~includeTokenBalances=svm["includeTokenBalances"],
-            ~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,
@@ -791,11 +651,11 @@ let fromPublic = (publicConfigJson: JSON.t) => {
         ->Dict.toArray
         ->Array.map(((capitalizedName, contractData)) => {
           let chainContract = chainContracts->Dict.get(capitalizedName)
-          let rawAddresses =
+          let addresses =
             chainContract
             ->Option.flatMap(cc => cc["addresses"])
             ->Option.getOr([])
-          let addresses = rawAddresses->Array.map(parseAddress)
+            ->Array.map(parseAddress)
           let startBlock = chainContract->Option.flatMap(cc => cc["startBlock"])
 
           // Build event configs from JSON (field selections resolved inline)
@@ -809,10 +669,6 @@ let fromPublic = (publicConfigJson: JSON.t) => {
             ~abi=contractData["abi"],
             ~chainId,
             ~startBlock,
-            ~addresses=rawAddresses,
-            ~svmDefinedTypes=contractData["svmAbi"]
-            ->Option.map(a => a["definedTypes"])
-            ->Option.getOr(JSON.Null),
           )
 
           {
@@ -877,11 +733,7 @@ let fromPublic = (publicConfigJson: JSON.t) => {
         }
       | Ecosystem.Svm =>
         switch publicChainConfig["rpc"] {
-        | Some(rpc) =>
-          SvmSourceConfig({
-            hypersync: publicChainConfig["hypersync"],
-            rpc,
-          })
+        | Some(rpc) => SvmSourceConfig({rpc: rpc})
         | None => JsError.throwWithMessage(`Chain ${chainName} is missing rpc endpoint in config`)
         }
       }