envio 3.0.0-alpha.1 → 3.0.0-alpha.3

package/src/Config.res.mjs

@@ -1,23 +1,26 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Evm from "./sources/Evm.res.mjs";
+import * as Fuel from "./sources/Fuel.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Js_exn from "rescript/lib/es6/js_exn.js";
+import * as Solana from "./sources/Solana.res.mjs";
+import * as Js_dict from "rescript/lib/es6/js_dict.js";
 import * as ChainMap from "./ChainMap.res.mjs";
-import * as Platform from "./Platform.res.mjs";
 import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
 
-function make(shouldRollbackOnReorgOpt, shouldSaveFullHistoryOpt, chainsOpt, enableRawEventsOpt, preloadHandlersOpt, ecosystemOpt, batchSizeOpt, lowercaseAddressesOpt, multichainOpt, shouldUseHypersyncClientDecoderOpt, maxAddrInPartitionOpt) {
+function make(shouldRollbackOnReorgOpt, shouldSaveFullHistoryOpt, chainsOpt, enableRawEventsOpt, ecosystemOpt, batchSizeOpt, lowercaseAddressesOpt, multichainOpt, shouldUseHypersyncClientDecoderOpt, maxAddrInPartitionOpt, userEntitiesOpt) {
   var shouldRollbackOnReorg = shouldRollbackOnReorgOpt !== undefined ? shouldRollbackOnReorgOpt : true;
   var shouldSaveFullHistory = shouldSaveFullHistoryOpt !== undefined ? shouldSaveFullHistoryOpt : false;
   var chains = chainsOpt !== undefined ? chainsOpt : [];
   var enableRawEvents = enableRawEventsOpt !== undefined ? enableRawEventsOpt : false;
-  var preloadHandlers = preloadHandlersOpt !== undefined ? preloadHandlersOpt : false;
   var ecosystem = ecosystemOpt !== undefined ? ecosystemOpt : "evm";
   var batchSize = batchSizeOpt !== undefined ? batchSizeOpt : 5000;
   var lowercaseAddresses = lowercaseAddressesOpt !== undefined ? lowercaseAddressesOpt : false;
   var multichain = multichainOpt !== undefined ? multichainOpt : "unordered";
   var shouldUseHypersyncClientDecoder = shouldUseHypersyncClientDecoderOpt !== undefined ? shouldUseHypersyncClientDecoderOpt : true;
   var maxAddrInPartition = maxAddrInPartitionOpt !== undefined ? maxAddrInPartitionOpt : 5000;
+  var userEntities = userEntitiesOpt !== undefined ? userEntitiesOpt : [];
   if (lowercaseAddresses && !shouldUseHypersyncClientDecoder) {
     Js_exn.raiseError("lowercase addresses is not supported when event_decoder is 'viem'. Please set event_decoder to 'hypersync-client' or change address_format to 'checksum'.");
   }
@@ -34,20 +37,38 @@ function make(shouldRollbackOnReorgOpt, shouldSaveFullHistoryOpt, chainsOpt, ena
                   addContractNameToContractNameMapping[addKey] = contract.name;
                 }));
         }));
-  var platform = Platform.fromName(ecosystem);
+  var ecosystem$1;
+  switch (ecosystem) {
+    case "evm" :
+        ecosystem$1 = Evm.ecosystem;
+        break;
+    case "fuel" :
+        ecosystem$1 = Fuel.ecosystem;
+        break;
+    case "solana" :
+        ecosystem$1 = Solana.ecosystem;
+        break;
+    
+  }
+  var userEntitiesByName = Js_dict.fromArray(userEntities.map(function (entityConfig) {
+            return [
+                    entityConfig.name,
+                    entityConfig
+                  ];
+          }));
   return {
           shouldRollbackOnReorg: shouldRollbackOnReorg,
           shouldSaveFullHistory: shouldSaveFullHistory,
           multichain: multichain,
           chainMap: chainMap,
           defaultChain: Belt_Array.get(chains, 0),
-          platform: platform,
+          ecosystem: ecosystem$1,
           enableRawEvents: enableRawEvents,
-          preloadHandlers: preloadHandlers,
           maxAddrInPartition: maxAddrInPartition,
           batchSize: batchSize,
           lowercaseAddresses: lowercaseAddresses,
-          addContractNameToContractNameMapping: addContractNameToContractNameMapping
+          addContractNameToContractNameMapping: addContractNameToContractNameMapping,
+          userEntitiesByName: userEntitiesByName
         };
 }
 

package/src/Ecosystem.res

@@ -0,0 +1,25 @@
+type name = | @as("evm") Evm | @as("fuel") Fuel | @as("solana") Solana
+
+type t = {
+  name: name,
+  blockFields: array<string>,
+  transactionFields: array<string>,
+  blockNumberName: string,
+  blockTimestampName: string,
+  blockHashName: string,
+  getNumber: Internal.eventBlock => int,
+  getTimestamp: Internal.eventBlock => int,
+  getId: Internal.eventBlock => string,
+  cleanUpRawEventFieldsInPlace: Js.Json.t => unit,
+}
+
+let makeOnBlockArgs = (~blockNumber: int, ~ecosystem: t, ~context): Internal.onBlockArgs => {
+  switch ecosystem.name {
+  | Solana => {slot: blockNumber, context}
+  | _ => {
+      let blockEvent = Js.Dict.empty()
+      blockEvent->Js.Dict.set(ecosystem.blockNumberName, blockNumber->Utils.magic)
+      {block: blockEvent->Utils.magic, context}
+    }
+  }
+}

package/src/Ecosystem.res.mjs

@@ -0,0 +1,29 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Caml_option from "rescript/lib/es6/caml_option.js";
+
+function makeOnBlockArgs(blockNumber, ecosystem, context) {
+  var match = ecosystem.name;
+  switch (match) {
+    case "evm" :
+    case "fuel" :
+        break;
+    case "solana" :
+        return {
+                slot: blockNumber,
+                context: context
+              };
+    
+  }
+  var blockEvent = {};
+  blockEvent[ecosystem.blockNumberName] = blockNumber;
+  return {
+          block: Caml_option.some(blockEvent),
+          context: context
+        };
+}
+
+export {
+  makeOnBlockArgs ,
+}
+/* No side effect */

package/src/Env.res

@@ -0,0 +1,243 @@
+
+// Loads the .env from the root working directory
+%%raw(`import 'dotenv/config'`)
+
+%%private(
+  let envSafe = EnvSafe.make()
+
+  let getLogLevelConfig = (name, ~default): Pino.logLevel =>
+    envSafe->EnvSafe.get(
+      name,
+      S.enum([#trace, #debug, #info, #warn, #error, #fatal, #udebug, #uinfo, #uwarn, #uerror]),
+      ~fallback=default,
+    )
+)
+// resets the timestampCaughtUpToHeadOrEndblock after a restart when true
+let updateSyncTimeOnRestart =
+  envSafe->EnvSafe.get("UPDATE_SYNC_TIME_ON_RESTART", S.bool, ~fallback=true)
+let targetBufferSize = envSafe->EnvSafe.get("ENVIO_INDEXING_MAX_BUFFER_SIZE", S.option(S.int))
+let maxAddrInPartition = envSafe->EnvSafe.get("MAX_PARTITION_SIZE", S.int, ~fallback=5_000)
+let maxPartitionConcurrency =
+  envSafe->EnvSafe.get("ENVIO_MAX_PARTITION_CONCURRENCY", S.int, ~fallback=10)
+let indexingBlockLag = envSafe->EnvSafe.get("ENVIO_INDEXING_BLOCK_LAG", S.option(S.int))
+
+// FIXME: This broke HS grafana dashboard. Should investigate it later. Maybe we should use :: as a default value?
+// We want to be able to set it to 0.0.0.0
+// to allow to passthrough the port from a Docker container
+// let serverHost = envSafe->EnvSafe.get("ENVIO_INDEXER_HOST", S.string, ~fallback="localhost")
+let serverPort =
+  envSafe->EnvSafe.get(
+    "ENVIO_INDEXER_PORT",
+    S.int->S.port,
+    ~fallback=envSafe->EnvSafe.get("METRICS_PORT", S.int->S.port, ~fallback=9898),
+  )
+
+let tuiOffEnvVar = envSafe->EnvSafe.get("TUI_OFF", S.bool, ~fallback=false)
+
+let logFilePath = envSafe->EnvSafe.get("LOG_FILE", S.string, ~fallback="logs/envio.log")
+let userLogLevel = getLogLevelConfig("LOG_LEVEL", ~default=#info)
+let defaultFileLogLevel = getLogLevelConfig("FILE_LOG_LEVEL", ~default=#trace)
+
+let prodEnvioAppUrl = "https://envio.dev"
+let envioAppUrl = envSafe->EnvSafe.get("ENVIO_APP", S.string, ~fallback=prodEnvioAppUrl)
+let envioApiToken = envSafe->EnvSafe.get("ENVIO_API_TOKEN", S.option(S.string))
+let hyperSyncClientTimeoutMillis =
+  envSafe->EnvSafe.get("ENVIO_HYPERSYNC_CLIENT_TIMEOUT_MILLIS", S.int, ~fallback=120_000)
+
+/** 
+This is the number of retries that the binary client makes before rejecting the promise with an error 
+Default is 0 so that the indexer can handle retries internally
+*/
+let hyperSyncClientMaxRetries =
+  envSafe->EnvSafe.get("ENVIO_HYPERSYNC_CLIENT_MAX_RETRIES", S.int, ~fallback=0)
+
+let hypersyncClientSerializationFormat =
+  envSafe->EnvSafe.get(
+    "ENVIO_HYPERSYNC_CLIENT_SERIALIZATION_FORMAT",
+    HyperSyncClient.serializationFormatSchema,
+    ~fallback=CapnProto,
+  )
+
+let hypersyncClientEnableQueryCaching =
+  envSafe->EnvSafe.get("ENVIO_HYPERSYNC_CLIENT_ENABLE_QUERY_CACHING", S.bool, ~fallback=true)
+
+module Benchmark = {
+  module SaveDataStrategy: {
+    type t
+    let schema: S.t<t>
+    let default: t
+    let shouldSaveJsonFile: t => bool
+    let shouldSavePrometheus: t => bool
+    let shouldSaveData: t => bool
+  } = {
+    @unboxed
+    type t = Bool(bool) | @as("json-file") JsonFile | @as("prometheus") Prometheus
+
+    let schema = S.enum([Bool(true), Bool(false), JsonFile, Prometheus])
+    let default = Bool(false)
+
+    let shouldSaveJsonFile = self =>
+      switch self {
+      | JsonFile | Bool(true) => true
+      | _ => false
+      }
+
+    let shouldSavePrometheus = _ => true
+
+    let shouldSaveData = self => self->shouldSavePrometheus || self->shouldSaveJsonFile
+  }
+
+  let saveDataStrategy =
+    envSafe->EnvSafe.get(
+      "ENVIO_SAVE_BENCHMARK_DATA",
+      SaveDataStrategy.schema,
+      ~fallback=SaveDataStrategy.default,
+    )
+
+  let shouldSaveData = saveDataStrategy->SaveDataStrategy.shouldSaveData
+
+  /**
+  StdDev involves saving sum of squares of data points, which could get very large.
+
+  Currently only do this for local runs on json-file and not prometheus.
+  */
+  let shouldSaveStdDev =
+    saveDataStrategy->SaveDataStrategy.shouldSaveJsonFile
+}
+
+let logStrategy =
+  envSafe->EnvSafe.get(
+    "LOG_STRATEGY",
+    S.enum([
+      Logging.EcsFile,
+      EcsConsole,
+      EcsConsoleMultistream,
+      FileOnly,
+      ConsoleRaw,
+      ConsolePretty,
+      Both,
+    ]),
+    ~fallback=ConsolePretty,
+  )
+
+Logging.setLogger(
+  Logging.makeLogger(~logStrategy, ~logFilePath, ~defaultFileLogLevel, ~userLogLevel),
+)
+
+module Db = {
+  let host = envSafe->EnvSafe.get("ENVIO_PG_HOST", S.string, ~devFallback="localhost")
+  let port = envSafe->EnvSafe.get("ENVIO_PG_PORT", S.int->S.port, ~devFallback=5433)
+  let user = envSafe->EnvSafe.get("ENVIO_PG_USER", S.string, ~devFallback="postgres")
+  let password = envSafe->EnvSafe.get(
+    "ENVIO_PG_PASSWORD",
+    S.string,
+    ~fallback={
+      envSafe->EnvSafe.get("ENVIO_POSTGRES_PASSWORD", S.string, ~fallback="testing")
+    },
+  )
+  let database = envSafe->EnvSafe.get("ENVIO_PG_DATABASE", S.string, ~devFallback="envio-dev")
+  let publicSchema = envSafe->EnvSafe.get("ENVIO_PG_PUBLIC_SCHEMA", S.string, ~fallback="public")
+  let ssl = envSafe->EnvSafe.get(
+    "ENVIO_PG_SSL_MODE",
+    Postgres.sslOptionsSchema,
+    //this is a dev fallback option for local deployments, shouldn't run in the prod env
+    //the SSL modes should be provided as string otherwise as 'require' | 'allow' | 'prefer' | 'verify-full'
+    ~devFallback=Bool(false),
+  )
+}
+
+module ClickHouseSink = {
+  let host = envSafe->EnvSafe.get("ENVIO_CLICKHOUSE_SINK_HOST", S.option(S.string))
+  let database = envSafe->EnvSafe.get("ENVIO_CLICKHOUSE_SINK_DATABASE", S.option(S.string))
+  let username = switch host {
+  | None => ""
+  | Some(_) => envSafe->EnvSafe.get("ENVIO_CLICKHOUSE_SINK_USERNAME", S.string)
+  }
+  let password = switch host {
+  | None => ""
+  | Some(_) => envSafe->EnvSafe.get("ENVIO_CLICKHOUSE_SINK_PASSWORD", S.string)
+  }
+}
+
+module Hasura = {
+  // Disable it on HS indexer run, since we don't have Hasura credentials anyways
+  // Also, it might be useful for some users who don't care about Hasura
+  let enabled = envSafe->EnvSafe.get("ENVIO_HASURA", S.bool, ~fallback=true)
+
+  let responseLimit = switch envSafe->EnvSafe.get("ENVIO_HASURA_RESPONSE_LIMIT", S.option(S.int)) {
+  | Some(_) as s => s
+  | None => envSafe->EnvSafe.get("HASURA_RESPONSE_LIMIT", S.option(S.int))
+  }
+
+  let graphqlEndpoint =
+    envSafe->EnvSafe.get(
+      "HASURA_GRAPHQL_ENDPOINT",
+      S.string,
+      ~devFallback="http://localhost:8080/v1/metadata",
+    )
+
+  let url = graphqlEndpoint->Js.String2.slice(~from=0, ~to_=-("/v1/metadata"->Js.String2.length))
+
+  let role = envSafe->EnvSafe.get("HASURA_GRAPHQL_ROLE", S.string, ~devFallback="admin")
+
+  let secret = envSafe->EnvSafe.get("HASURA_GRAPHQL_ADMIN_SECRET", S.string, ~devFallback="testing")
+
+  let aggregateEntities = envSafe->EnvSafe.get(
+    "ENVIO_HASURA_PUBLIC_AGGREGATE",
+    S.union([
+      S.array(S.string),
+      // Temporary workaround: Hosted Service can't use commas in env vars for multiple entities.
+      // Will be removed once comma support is added — don't rely on this.
+      S.string->S.transform(s => {
+        parser: string =>
+          switch string->Js.String2.split("&") {
+          | []
+          | [_] =>
+            s.fail(`Provide an array of entities in the JSON format.`)
+          | entities => entities
+          },
+      }),
+    ]),
+    ~fallback=[],
+  )
+}
+
+module Configurable = {
+  module SyncConfig = {
+    let initialBlockInterval =
+      envSafe->EnvSafe.get("ENVIO_RPC_INITIAL_BLOCK_INTERVAL", S.option(S.int))
+    let backoffMultiplicative =
+      envSafe->EnvSafe.get("ENVIO_RPC_BACKOFF_MULTIPLICATIVE", S.option(S.float))
+    let accelerationAdditive =
+      envSafe->EnvSafe.get("ENVIO_RPC_ACCELERATION_ADDITIVE", S.option(S.int))
+    let intervalCeiling = envSafe->EnvSafe.get("ENVIO_RPC_INTERVAL_CEILING", S.option(S.int))
+  }
+}
+
+module ThrottleWrites = {
+  let chainMetadataIntervalMillis =
+    envSafe->EnvSafe.get("ENVIO_THROTTLE_CHAIN_METADATA_INTERVAL_MILLIS", S.int, ~devFallback=500)
+  let pruneStaleDataIntervalMillis =
+    envSafe->EnvSafe.get(
+      "ENVIO_THROTTLE_PRUNE_STALE_DATA_INTERVAL_MILLIS",
+      S.int,
+      ~devFallback=30_000,
+    )
+
+  let liveMetricsBenchmarkIntervalMillis =
+    envSafe->EnvSafe.get(
+      "ENVIO_THROTTLE_LIVE_METRICS_BENCHMARK_INTERVAL_MILLIS",
+      S.int,
+      ~devFallback=1_000,
+    )
+
+  let jsonFileBenchmarkIntervalMillis =
+    envSafe->EnvSafe.get(
+      "ENVIO_THROTTLE_JSON_FILE_BENCHMARK_INTERVAL_MILLIS",
+      S.int,
+      ~devFallback=500,
+    )
+}
+
+// You need to close the envSafe after you're done with it so that it immediately tells you about your  misconfigured environment on startup.
+envSafe->EnvSafe.close

package/src/Env.res.mjs

@@ -0,0 +1,270 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as EnvSafe from "rescript-envsafe/src/EnvSafe.res.mjs";
+import * as Logging from "./Logging.res.mjs";
+import * as Postgres from "./bindings/Postgres.res.mjs";
+import * as Caml_option from "rescript/lib/es6/caml_option.js";
+import * as HyperSyncClient from "./sources/HyperSyncClient.res.mjs";
+import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
+
+import 'dotenv/config'
+;
+
+var envSafe = EnvSafe.make(undefined);
+
+function getLogLevelConfig(name, $$default) {
+  return EnvSafe.get(envSafe, name, S$RescriptSchema.$$enum([
+                  "trace",
+                  "debug",
+                  "info",
+                  "warn",
+                  "error",
+                  "fatal",
+                  "udebug",
+                  "uinfo",
+                  "uwarn",
+                  "uerror"
+                ]), undefined, $$default, undefined, undefined);
+}
+
+var updateSyncTimeOnRestart = EnvSafe.get(envSafe, "UPDATE_SYNC_TIME_ON_RESTART", S$RescriptSchema.bool, undefined, true, undefined, undefined);
+
+var targetBufferSize = EnvSafe.get(envSafe, "ENVIO_INDEXING_MAX_BUFFER_SIZE", S$RescriptSchema.option(S$RescriptSchema.$$int), undefined, undefined, undefined, undefined);
+
+var maxAddrInPartition = EnvSafe.get(envSafe, "MAX_PARTITION_SIZE", S$RescriptSchema.$$int, undefined, 5000, undefined, undefined);
+
+var maxPartitionConcurrency = EnvSafe.get(envSafe, "ENVIO_MAX_PARTITION_CONCURRENCY", S$RescriptSchema.$$int, undefined, 10, undefined, undefined);
+
+var indexingBlockLag = EnvSafe.get(envSafe, "ENVIO_INDEXING_BLOCK_LAG", S$RescriptSchema.option(S$RescriptSchema.$$int), undefined, undefined, undefined, undefined);
+
+var serverPort = EnvSafe.get(envSafe, "ENVIO_INDEXER_PORT", S$RescriptSchema.port(S$RescriptSchema.$$int, undefined), undefined, EnvSafe.get(envSafe, "METRICS_PORT", S$RescriptSchema.port(S$RescriptSchema.$$int, undefined), undefined, 9898, undefined, undefined), undefined, undefined);
+
+var tuiOffEnvVar = EnvSafe.get(envSafe, "TUI_OFF", S$RescriptSchema.bool, undefined, false, undefined, undefined);
+
+var logFilePath = EnvSafe.get(envSafe, "LOG_FILE", S$RescriptSchema.string, undefined, "logs/envio.log", undefined, undefined);
+
+var userLogLevel = getLogLevelConfig("LOG_LEVEL", "info");
+
+var defaultFileLogLevel = getLogLevelConfig("FILE_LOG_LEVEL", "trace");
+
+var prodEnvioAppUrl = "https://envio.dev";
+
+var envioAppUrl = EnvSafe.get(envSafe, "ENVIO_APP", S$RescriptSchema.string, undefined, prodEnvioAppUrl, undefined, undefined);
+
+var envioApiToken = EnvSafe.get(envSafe, "ENVIO_API_TOKEN", S$RescriptSchema.option(S$RescriptSchema.string), undefined, undefined, undefined, undefined);
+
+var hyperSyncClientTimeoutMillis = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_CLIENT_TIMEOUT_MILLIS", S$RescriptSchema.$$int, undefined, 120000, undefined, undefined);
+
+var hyperSyncClientMaxRetries = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_CLIENT_MAX_RETRIES", S$RescriptSchema.$$int, undefined, 0, undefined, undefined);
+
+var hypersyncClientSerializationFormat = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_CLIENT_SERIALIZATION_FORMAT", HyperSyncClient.serializationFormatSchema, undefined, "CapnProto", undefined, undefined);
+
+var hypersyncClientEnableQueryCaching = EnvSafe.get(envSafe, "ENVIO_HYPERSYNC_CLIENT_ENABLE_QUERY_CACHING", S$RescriptSchema.bool, undefined, true, undefined, undefined);
+
+var schema = S$RescriptSchema.$$enum([
+      true,
+      false,
+      "json-file",
+      "prometheus"
+    ]);
+
+var $$default = false;
+
+function shouldSaveJsonFile(self) {
+  if (typeof self !== "boolean") {
+    if (self === "json-file") {
+      return true;
+    } else {
+      return false;
+    }
+  } else if (self) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+function shouldSavePrometheus(param) {
+  return true;
+}
+
+function shouldSaveData(self) {
+  return true;
+}
+
+var SaveDataStrategy = {
+  schema: schema,
+  $$default: $$default,
+  shouldSaveJsonFile: shouldSaveJsonFile,
+  shouldSavePrometheus: shouldSavePrometheus,
+  shouldSaveData: shouldSaveData
+};
+
+var saveDataStrategy = EnvSafe.get(envSafe, "ENVIO_SAVE_BENCHMARK_DATA", schema, undefined, Caml_option.some($$default), undefined, undefined);
+
+var shouldSaveData$1 = shouldSaveData(saveDataStrategy);
+
+var shouldSaveStdDev = shouldSaveJsonFile(saveDataStrategy);
+
+var Benchmark = {
+  SaveDataStrategy: SaveDataStrategy,
+  saveDataStrategy: saveDataStrategy,
+  shouldSaveData: shouldSaveData$1,
+  shouldSaveStdDev: shouldSaveStdDev
+};
+
+var logStrategy = EnvSafe.get(envSafe, "LOG_STRATEGY", S$RescriptSchema.$$enum([
+          "ecs-file",
+          "ecs-console",
+          "ecs-console-multistream",
+          "file-only",
+          "console-raw",
+          "console-pretty",
+          "both-prettyconsole"
+        ]), undefined, "console-pretty", undefined, undefined);
+
+Logging.setLogger(Logging.makeLogger(logStrategy, logFilePath, defaultFileLogLevel, userLogLevel));
+
+var host = EnvSafe.get(envSafe, "ENVIO_PG_HOST", S$RescriptSchema.string, undefined, undefined, "localhost", undefined);
+
+var port = EnvSafe.get(envSafe, "ENVIO_PG_PORT", S$RescriptSchema.port(S$RescriptSchema.$$int, undefined), undefined, undefined, 5433, undefined);
+
+var user = EnvSafe.get(envSafe, "ENVIO_PG_USER", S$RescriptSchema.string, undefined, undefined, "postgres", undefined);
+
+var password = EnvSafe.get(envSafe, "ENVIO_PG_PASSWORD", S$RescriptSchema.string, undefined, EnvSafe.get(envSafe, "ENVIO_POSTGRES_PASSWORD", S$RescriptSchema.string, undefined, "testing", undefined, undefined), undefined, undefined);
+
+var database = EnvSafe.get(envSafe, "ENVIO_PG_DATABASE", S$RescriptSchema.string, undefined, undefined, "envio-dev", undefined);
+
+var publicSchema = EnvSafe.get(envSafe, "ENVIO_PG_PUBLIC_SCHEMA", S$RescriptSchema.string, undefined, "public", undefined, undefined);
+
+var ssl = EnvSafe.get(envSafe, "ENVIO_PG_SSL_MODE", Postgres.sslOptionsSchema, undefined, undefined, false, undefined);
+
+var Db = {
+  host: host,
+  port: port,
+  user: user,
+  password: password,
+  database: database,
+  publicSchema: publicSchema,
+  ssl: ssl
+};
+
+var host$1 = EnvSafe.get(envSafe, "ENVIO_CLICKHOUSE_SINK_HOST", S$RescriptSchema.option(S$RescriptSchema.string), undefined, undefined, undefined, undefined);
+
+var database$1 = EnvSafe.get(envSafe, "ENVIO_CLICKHOUSE_SINK_DATABASE", S$RescriptSchema.option(S$RescriptSchema.string), undefined, undefined, undefined, undefined);
+
+var username = host$1 !== undefined ? EnvSafe.get(envSafe, "ENVIO_CLICKHOUSE_SINK_USERNAME", S$RescriptSchema.string, undefined, undefined, undefined, undefined) : "";
+
+var password$1 = host$1 !== undefined ? EnvSafe.get(envSafe, "ENVIO_CLICKHOUSE_SINK_PASSWORD", S$RescriptSchema.string, undefined, undefined, undefined, undefined) : "";
+
+var ClickHouseSink = {
+  host: host$1,
+  database: database$1,
+  username: username,
+  password: password$1
+};
+
+var enabled = EnvSafe.get(envSafe, "ENVIO_HASURA", S$RescriptSchema.bool, undefined, true, undefined, undefined);
+
+var s = EnvSafe.get(envSafe, "ENVIO_HASURA_RESPONSE_LIMIT", S$RescriptSchema.option(S$RescriptSchema.$$int), undefined, undefined, undefined, undefined);
+
+var responseLimit = s !== undefined ? s : EnvSafe.get(envSafe, "HASURA_RESPONSE_LIMIT", S$RescriptSchema.option(S$RescriptSchema.$$int), undefined, undefined, undefined, undefined);
+
+var graphqlEndpoint = EnvSafe.get(envSafe, "HASURA_GRAPHQL_ENDPOINT", S$RescriptSchema.string, undefined, undefined, "http://localhost:8080/v1/metadata", undefined);
+
+var url = graphqlEndpoint.slice(0, -"/v1/metadata".length | 0);
+
+var role = EnvSafe.get(envSafe, "HASURA_GRAPHQL_ROLE", S$RescriptSchema.string, undefined, undefined, "admin", undefined);
+
+var secret = EnvSafe.get(envSafe, "HASURA_GRAPHQL_ADMIN_SECRET", S$RescriptSchema.string, undefined, undefined, "testing", undefined);
+
+var aggregateEntities = EnvSafe.get(envSafe, "ENVIO_HASURA_PUBLIC_AGGREGATE", S$RescriptSchema.union([
+          S$RescriptSchema.array(S$RescriptSchema.string),
+          S$RescriptSchema.transform(S$RescriptSchema.string, (function (s) {
+                  return {
+                          p: (function (string) {
+                              var entities = string.split("&");
+                              var len = entities.length;
+                              if (len !== 1 && len !== 0) {
+                                return entities;
+                              } else {
+                                return s.fail("Provide an array of entities in the JSON format.", undefined);
+                              }
+                            })
+                        };
+                }))
+        ]), undefined, [], undefined, undefined);
+
+var Hasura = {
+  enabled: enabled,
+  responseLimit: responseLimit,
+  graphqlEndpoint: graphqlEndpoint,
+  url: url,
+  role: role,
+  secret: secret,
+  aggregateEntities: aggregateEntities
+};
+
+var initialBlockInterval = EnvSafe.get(envSafe, "ENVIO_RPC_INITIAL_BLOCK_INTERVAL", S$RescriptSchema.option(S$RescriptSchema.$$int), undefined, undefined, undefined, undefined);
+
+var backoffMultiplicative = EnvSafe.get(envSafe, "ENVIO_RPC_BACKOFF_MULTIPLICATIVE", S$RescriptSchema.option(S$RescriptSchema.$$float), undefined, undefined, undefined, undefined);
+
+var accelerationAdditive = EnvSafe.get(envSafe, "ENVIO_RPC_ACCELERATION_ADDITIVE", S$RescriptSchema.option(S$RescriptSchema.$$int), undefined, undefined, undefined, undefined);
+
+var intervalCeiling = EnvSafe.get(envSafe, "ENVIO_RPC_INTERVAL_CEILING", S$RescriptSchema.option(S$RescriptSchema.$$int), undefined, undefined, undefined, undefined);
+
+var SyncConfig = {
+  initialBlockInterval: initialBlockInterval,
+  backoffMultiplicative: backoffMultiplicative,
+  accelerationAdditive: accelerationAdditive,
+  intervalCeiling: intervalCeiling
+};
+
+var Configurable = {
+  SyncConfig: SyncConfig
+};
+
+var chainMetadataIntervalMillis = EnvSafe.get(envSafe, "ENVIO_THROTTLE_CHAIN_METADATA_INTERVAL_MILLIS", S$RescriptSchema.$$int, undefined, undefined, 500, undefined);
+
+var pruneStaleDataIntervalMillis = EnvSafe.get(envSafe, "ENVIO_THROTTLE_PRUNE_STALE_DATA_INTERVAL_MILLIS", S$RescriptSchema.$$int, undefined, undefined, 30000, undefined);
+
+var liveMetricsBenchmarkIntervalMillis = EnvSafe.get(envSafe, "ENVIO_THROTTLE_LIVE_METRICS_BENCHMARK_INTERVAL_MILLIS", S$RescriptSchema.$$int, undefined, undefined, 1000, undefined);
+
+var jsonFileBenchmarkIntervalMillis = EnvSafe.get(envSafe, "ENVIO_THROTTLE_JSON_FILE_BENCHMARK_INTERVAL_MILLIS", S$RescriptSchema.$$int, undefined, undefined, 500, undefined);
+
+var ThrottleWrites = {
+  chainMetadataIntervalMillis: chainMetadataIntervalMillis,
+  pruneStaleDataIntervalMillis: pruneStaleDataIntervalMillis,
+  liveMetricsBenchmarkIntervalMillis: liveMetricsBenchmarkIntervalMillis,
+  jsonFileBenchmarkIntervalMillis: jsonFileBenchmarkIntervalMillis
+};
+
+EnvSafe.close(envSafe);
+
+export {
+  updateSyncTimeOnRestart ,
+  targetBufferSize ,
+  maxAddrInPartition ,
+  maxPartitionConcurrency ,
+  indexingBlockLag ,
+  serverPort ,
+  tuiOffEnvVar ,
+  logFilePath ,
+  userLogLevel ,
+  defaultFileLogLevel ,
+  prodEnvioAppUrl ,
+  envioAppUrl ,
+  envioApiToken ,
+  hyperSyncClientTimeoutMillis ,
+  hyperSyncClientMaxRetries ,
+  hypersyncClientSerializationFormat ,
+  hypersyncClientEnableQueryCaching ,
+  Benchmark ,
+  logStrategy ,
+  Db ,
+  ClickHouseSink ,
+  Hasura ,
+  Configurable ,
+  ThrottleWrites ,
+}
+/*  Not a pure module */

package/src/Envio.gen.ts

@@ -13,7 +13,9 @@ import type {S_t as RescriptSchema_S_t} from 'rescript-schema/RescriptSchema.gen
 
 export type blockEvent = { readonly number: number };
 
-export type fuelBlockEvent = { readonly height: number; readonly chainId: number };
+export type fuelBlockEvent = { readonly height: number };
+
+export type solanaOnBlockArgs<context> = { readonly slot: number; readonly context: context };
 
 export type onBlockArgs<block,context> = { readonly block: block; readonly context: context };
 
@@ -25,6 +27,12 @@ export type onBlockOptions<chain> = {
   readonly endBlock?: number
 };
 
+export type whereOperations<entity,fieldType> = {
+  readonly eq: (_1:fieldType) => Promise<entity[]>; 
+  readonly gt: (_1:fieldType) => Promise<entity[]>; 
+  readonly lt: (_1:fieldType) => Promise<entity[]>
+};
+
 export type logger = $$logger;
 
 export type effect<input,output> = $$effect<input,output>;