envio 3.1.2 → 3.2.0

package/src/Config.res

@@ -28,7 +28,7 @@ type evmRpcConfig = {
 type sourceConfig =
   | EvmSourceConfig({hypersync: option<string>, rpcs: array<evmRpcConfig>})
   | FuelSourceConfig({hypersync: string})
-  | SvmSourceConfig({rpc: string})
+  | SvmSourceConfig({hypersync: option<string>, rpc: option<string>})
   // For tests: pass custom sources directly
   | CustomSources(array<Source.t>)
 
@@ -91,7 +91,7 @@ module EnvioAddresses = {
   let index = -1
 
   let makeId = (~chainId, ~address) => {
-    chainId->Belt.Int.toString ++ "-" ++ address->Address.toString
+    chainId->Int.toString ++ "-" ++ address->Address.toString
   }
 
   type t = {
@@ -121,8 +121,6 @@ module EnvioAddresses = {
     contractName: s.matches(S.string),
   })
 
-  let rowsSchema = S.array(schema)
-
   let table = Table.mkTable(
     name,
     ~fields=[
@@ -141,7 +139,6 @@ module EnvioAddresses = {
     Internal.name,
     index,
     schema,
-    rowsSchema,
     table,
     // Internal address tracking is Postgres-only; the global config is
     // always required to have Postgres enabled (Storage::resolve forbids
@@ -194,6 +191,39 @@ 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),
@@ -202,6 +232,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)),
   }
 )
 
@@ -211,6 +242,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)),
   }
 )
 
@@ -218,6 +251,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))),
   }
 )
 
@@ -252,6 +289,8 @@ let derivedFieldSchema = S.schema(s =>
 let propertySchema = S.schema(s =>
   {
     "name": s.matches(S.string),
+    "postgresDbName": s.matches(S.option(S.string)),
+    "clickhouseDbName": s.matches(S.option(S.string)),
     "type": s.matches(S.string),
     "isNullable": s.matches(S.option(S.bool)),
     "isArray": s.matches(S.option(S.bool)),
@@ -373,6 +412,8 @@ let parseEntitiesFromJson = (
         ~isIndex,
         ~linkedEntity=?prop["linkedEntity"],
         ~description=?prop["description"],
+        ~postgresDbName=?prop["postgresDbName"],
+        ~clickhouseDbName=?prop["clickhouseDbName"],
       )
     })
 
@@ -407,19 +448,21 @@ let parseEntitiesFromJson = (
       ~description=?entityJson["description"],
     )
 
+    let getApiFieldName = prop =>
+      switch prop["linkedEntity"] {
+      | Some(_) => prop["name"] ++ "_id"
+      | None => prop["name"]
+      }
+
     // Build schema dynamically from properties
-    // Use db field names (with _id suffix for linked entities) as schema locations
-    // to match the database column names used in Table.toSqlParams
+    // Use API field names (with _id suffix for linked entities) as schema
+    // locations to match the generated entity types
     let schema = S.schema(s => {
       let dict = Dict.make()
       entityJson["properties"]->Array.forEach(
         prop => {
           let (_, fieldSchema, _, _, _) = getFieldTypeAndSchema(prop, ~enumConfigsByName)
-          let dbFieldName = switch prop["linkedEntity"] {
-          | Some(_) => prop["name"] ++ "_id"
-          | None => prop["name"]
-          }
-          dict->Dict.set(dbFieldName, s.matches(fieldSchema))
+          dict->Dict.set(prop->getApiFieldName, s.matches(fieldSchema))
         },
       )
       dict
@@ -444,9 +487,6 @@ let parseEntitiesFromJson = (
       Internal.name: entityName,
       index,
       schema: schema->(Utils.magic: S.t<dict<unknown>> => S.t<Internal.entity>),
-      rowsSchema: S.array(schema)->(
-        Utils.magic: S.t<array<dict<unknown>>> => S.t<array<Internal.entity>>
-      ),
       table,
       storage,
     }->Internal.fromGenericEntityConfig
@@ -518,10 +558,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
   }
 
@@ -539,7 +588,16 @@ let fromPublic = (publicConfigJson: JSON.t) => {
   | None => (Utils.Set.fromArray(EventConfigBuilder.alwaysIncludedBlockFields), Utils.Set.make())
   }
 
-  let contractDataByName: dict<{"abi": EvmTypes.Abi.t, "events": option<array<_>>}> = Dict.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()
   switch publicContractsConfig {
   | Some(contractsDict) =>
     contractsDict
@@ -547,21 +605,48 @@ 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, "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 => []
@@ -592,6 +677,73 @@ 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,
@@ -651,11 +803,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)
@@ -669,6 +821,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),
           )
 
           {
@@ -680,6 +836,29 @@ let fromPublic = (publicConfigJson: JSON.t) => {
           }
         })
 
+      // The same address under two contract definitions (or twice under one)
+      // would later violate the (chainId, address) primary key of
+      // envio_addresses with an opaque Postgres error — fail fast with the
+      // offending pair instead. parseAddress already canonicalizes casing
+      // (checksum or lowercase), so an exact match catches case variants too.
+      let contractNameByAddress = Dict.make()
+      contracts->Array.forEach(contract => {
+        contract.addresses->Array.forEach(
+          address => {
+            let addressString = address->Address.toString
+            switch contractNameByAddress->Dict.get(addressString) {
+            | Some(existingContractName) =>
+              JsError.throwWithMessage(
+                existingContractName === contract.name
+                  ? `Address ${addressString} is listed multiple times for the contract ${contract.name} on chain ${chainId->Int.toString}. Please remove the duplicate from your config.`
+                  : `Address ${addressString} on chain ${chainId->Int.toString} is configured for multiple contracts: ${existingContractName} and ${contract.name}. Indexing the same address with multiple contract definitions is not supported. Please define the events on a single contract definition instead.`,
+              )
+            | None => contractNameByAddress->Dict.set(addressString, contract.name)
+            }
+          },
+        )
+      })
+
       let sourceConfig = switch ecosystemName {
       | Ecosystem.Evm =>
         let rpcs =
@@ -732,10 +911,14 @@ let fromPublic = (publicConfigJson: JSON.t) => {
           JsError.throwWithMessage(`Chain ${chainName} is missing hypersync endpoint in config`)
         }
       | Ecosystem.Svm =>
-        switch publicChainConfig["rpc"] {
-        | Some(rpc) => SvmSourceConfig({rpc: rpc})
-        | None => JsError.throwWithMessage(`Chain ${chainName} is missing rpc endpoint in config`)
+        let hypersync = publicChainConfig["hypersync"]
+        let rpc = publicChainConfig["rpc"]
+        if hypersync->Option.isNone && rpc->Option.isNone {
+          JsError.throwWithMessage(
+            `Chain ${chainName} is missing a data source: provide either an rpc endpoint or an experimental hypersync config`,
+          )
         }
+        SvmSourceConfig({hypersync, rpc})
       }
 
       {
@@ -849,7 +1032,7 @@ let getEventConfig = (config: t, ~contractName, ~eventName, ~chainId: option<int
     | None =>
       chain.contracts
       ->Array.find(c => c.name == contractName)
-      ->Belt.Option.flatMap(contract => contract.events->Array.find(e => e.name == eventName))
+      ->Option.flatMap(contract => contract.events->Array.find(e => e.name == eventName))
     }
   })
 }
@@ -973,7 +1156,7 @@ let diffPaths = (~stored: JSON.t, ~current: JSON.t): array<string> => {
         let maxLen = Math.Int.max(sArr->Array.length, cArr->Array.length)
         for i in 0 to maxLen - 1 {
           let p = `${prefix}[${Int.toString(i)}]`
-          switch (sArr->Belt.Array.get(i), cArr->Belt.Array.get(i)) {
+          switch (sArr->Array.get(i), cArr->Array.get(i)) {
           | (None, _) | (_, None) => acc->Array.push(p)->ignore
           | (Some(sv), Some(cv)) => go(sv, cv, p)
           }
@@ -1019,7 +1202,7 @@ let diffPaths = (~stored: JSON.t, ~current: JSON.t): array<string> => {
     switch firstHit {
     | Some(hits) => runTier(hits)
     | None =>
-      let knownSet = Utils.Set.fromArray(tiers->Belt.Array.concatMany)
+      let knownSet = Utils.Set.fromArray(tiers->Array.flat)
       let extras =
         Utils.Set.fromArray(Array.concat(sObj->Dict.keysToArray, cObj->Dict.keysToArray))
         ->Utils.Set.toArray