envio 2.27.6 → 2.28.0-alpha.1

package/src/db/InternalTable.res

@@ -0,0 +1,392 @@
+open Table
+
+//shorthand for punning
+let isPrimaryKey = true
+let isNullable = true
+let isIndex = true
+
+module EventSyncState = {
+  //Used unsafely in DbFunctions.res so just enforcing the naming here
+  let blockTimestampFieldName = "block_timestamp"
+  let blockNumberFieldName = "block_number"
+  let logIndexFieldName = "log_index"
+  let isPreRegisteringDynamicContractsFieldName = "is_pre_registering_dynamic_contracts"
+
+  // @genType Used for Test DB
+  @genType
+  type t = {
+    @as("chain_id") chainId: int,
+    @as("block_number") blockNumber: int,
+    @as("log_index") logIndex: int,
+    @as("block_timestamp") blockTimestamp: int,
+  }
+
+  let table = mkTable(
+    "event_sync_state",
+    ~fields=[
+      mkField("chain_id", Integer, ~fieldSchema=S.int, ~isPrimaryKey),
+      mkField(blockNumberFieldName, Integer, ~fieldSchema=S.int),
+      mkField(logIndexFieldName, Integer, ~fieldSchema=S.int),
+      mkField(blockTimestampFieldName, Integer, ~fieldSchema=S.int),
+      // Keep it in case Hosted Service relies on it to prevent a breaking changes
+      mkField(
+        isPreRegisteringDynamicContractsFieldName,
+        Boolean,
+        ~default="false",
+        ~fieldSchema=S.bool,
+      ),
+    ],
+  )
+
+  //We need to update values here not delet the rows, since restarting without a row
+  //has a different behaviour to restarting with an initialised row with zero values
+  let resetCurrentCurrentSyncStateQuery = (~pgSchema) =>
+    `UPDATE "${pgSchema}"."${table.tableName}"
+    SET ${blockNumberFieldName} = 0, 
+        ${logIndexFieldName} = 0, 
+        ${blockTimestampFieldName} = 0, 
+        ${isPreRegisteringDynamicContractsFieldName} = false;`
+}
+
+module Chains = {
+  type field = [
+    | #id
+    | #start_block
+    | #end_block
+    | #source_block
+    | #first_event_block
+    | #buffer_block
+    | #ready_at
+    | #events_processed
+    | #_is_hyper_sync
+    | #_latest_processed_block
+    | #_num_batches_fetched
+  ]
+
+  let fields: array<field> = [
+    #id,
+    #start_block,
+    #end_block,
+    #source_block,
+    #first_event_block,
+    #buffer_block,
+    #ready_at,
+    #events_processed,
+    #_is_hyper_sync,
+    #_latest_processed_block,
+    #_num_batches_fetched,
+  ]
+
+  type t = {
+    @as("id") id: int,
+    @as("start_block") startBlock: int,
+    @as("end_block") endBlock: Js.null<int>,
+    @as("source_block") blockHeight: int,
+    @as("first_event_block") firstEventBlockNumber: Js.null<int>,
+    @as("buffer_block") latestFetchedBlockNumber: int,
+    @as("ready_at")
+    timestampCaughtUpToHeadOrEndblock: Js.null<Js.Date.t>,
+    @as("events_processed") numEventsProcessed: int,
+    @as("_latest_processed_block") latestProcessedBlock: Js.null<int>,
+    @as("_is_hyper_sync") isHyperSync: bool,
+    @as("_num_batches_fetched") numBatchesFetched: int,
+  }
+
+  let table = mkTable(
+    "envio_chains",
+    ~fields=[
+      mkField((#id: field :> string), Integer, ~fieldSchema=S.int, ~isPrimaryKey),
+      // Values populated from config
+      mkField((#start_block: field :> string), Integer, ~fieldSchema=S.int),
+      mkField((#end_block: field :> string), Integer, ~fieldSchema=S.null(S.int), ~isNullable),
+      // Block number of the latest block that was fetched from the source
+      mkField((#buffer_block: field :> string), Integer, ~fieldSchema=S.int),
+      // Block number of the currently active source
+      mkField((#source_block: field :> string), Integer, ~fieldSchema=S.int),
+      // Block number of the first event that was processed for this chain
+      mkField(
+        (#first_event_block: field :> string),
+        Integer,
+        ~fieldSchema=S.null(S.int),
+        ~isNullable,
+      ),
+      // Used to show how much time historical sync has taken, so we need a timezone here (TUI and Hosted Service)
+      // null during historical sync, set to current time when sync is complete
+      mkField(
+        (#ready_at: field :> string),
+        TimestampWithNullTimezone,
+        ~fieldSchema=S.null(Utils.Schema.dbDate),
+        ~isNullable,
+      ),
+      mkField((#events_processed: field :> string), Integer, ~fieldSchema=S.int), // TODO: In the future it should reference a table with sources
+      mkField((#_is_hyper_sync: field :> string), Boolean, ~fieldSchema=S.bool),
+      // TODO: Make the data more public facing
+      mkField(
+        (#_latest_processed_block: field :> string),
+        Integer,
+        ~fieldSchema=S.null(S.int),
+        ~isNullable,
+      ),
+      mkField((#_num_batches_fetched: field :> string), Integer, ~fieldSchema=S.int),
+    ],
+  )
+
+  let initialFromConfig = (chainConfig: InternalConfig.chain) => {
+    {
+      id: chainConfig.id,
+      startBlock: chainConfig.startBlock,
+      endBlock: chainConfig.endBlock->Js.Null.fromOption,
+      blockHeight: 0,
+      firstEventBlockNumber: Js.Null.empty,
+      latestFetchedBlockNumber: -1,
+      timestampCaughtUpToHeadOrEndblock: Js.Null.empty,
+      latestProcessedBlock: Js.Null.empty,
+      isHyperSync: false,
+      numEventsProcessed: 0,
+      numBatchesFetched: 0,
+    }
+  }
+
+  let makeInitialValuesQuery = (~pgSchema, ~chainConfigs: array<InternalConfig.chain>) => {
+    if chainConfigs->Array.length === 0 {
+      None
+    } else {
+      // Create column names list
+      let columnNames = fields->Belt.Array.map(field => `"${(field :> string)}"`)
+
+      // Create VALUES rows for each chain config
+      let valuesRows = chainConfigs->Belt.Array.map(chainConfig => {
+        let initialValues = initialFromConfig(chainConfig)
+        let values = fields->Belt.Array.map((field: field) => {
+          let value =
+            initialValues->(Utils.magic: t => dict<unknown>)->Js.Dict.get((field :> string))
+          switch Js.typeof(value) {
+          | "object" => "NULL"
+          | "number" => value->Utils.magic->Belt.Int.toString
+          | "boolean" => value->Utils.magic ? "true" : "false"
+          | _ => Js.Exn.raiseError("Invalid envio_chains value type")
+          }
+        })
+
+        `(${values->Js.Array2.joinWith(", ")})`
+      })
+
+      Some(
+        `INSERT INTO "${pgSchema}"."${table.tableName}" (${columnNames->Js.Array2.joinWith(", ")})
+VALUES ${valuesRows->Js.Array2.joinWith(",\n       ")};`,
+      )
+    }
+  }
+
+  // Fields that should be updated on conflict (excluding static config fields)
+  let updateFields: array<field> = [
+    #source_block,
+    #first_event_block,
+    #buffer_block,
+    #ready_at,
+    #events_processed,
+    #_is_hyper_sync,
+    #_latest_processed_block,
+    #_num_batches_fetched,
+  ]
+
+  let makeSingleUpdateQuery = (~pgSchema) => {
+    // Generate SET clauses with parameter placeholders
+    let setClauses = Belt.Array.mapWithIndex(updateFields, (index, field) => {
+      let fieldName = (field :> string)
+      let paramIndex = index + 2 // +2 because $1 is for id in WHERE clause
+      `"${fieldName}" = $${Belt.Int.toString(paramIndex)}`
+    })
+
+    `UPDATE "${pgSchema}"."${table.tableName}"
+SET ${setClauses->Js.Array2.joinWith(",\n    ")}
+WHERE "id" = $1;`
+  }
+
+  let setValues = (sql, ~pgSchema, ~chainsData: array<t>) => {
+    let query = makeSingleUpdateQuery(~pgSchema)
+
+    let promises = chainsData->Belt.Array.map(chain => {
+      let params = []
+
+      // Push id first (for WHERE clause)
+      let idValue = chain->(Utils.magic: t => dict<unknown>)->Js.Dict.get("id")
+      params->Js.Array2.push(idValue)->ignore
+
+      // Then push all updateable field values (for SET clause)
+      updateFields->Js.Array2.forEach(field => {
+        let value = chain->(Utils.magic: t => dict<unknown>)->Js.Dict.get((field :> string))
+        params->Js.Array2.push(value)->ignore
+      })
+
+      sql->Postgres.preparedUnsafe(query, params->Obj.magic)
+    })
+
+    Promise.all(promises)
+  }
+}
+
+module PersistedState = {
+  type t = {
+    id: int,
+    envio_version: string,
+    config_hash: string,
+    schema_hash: string,
+    handler_files_hash: string,
+    abi_files_hash: string,
+  }
+
+  let table = mkTable(
+    "persisted_state",
+    ~fields=[
+      mkField("id", Serial, ~fieldSchema=S.int, ~isPrimaryKey),
+      mkField("envio_version", Text, ~fieldSchema=S.string),
+      mkField("config_hash", Text, ~fieldSchema=S.string),
+      mkField("schema_hash", Text, ~fieldSchema=S.string),
+      mkField("handler_files_hash", Text, ~fieldSchema=S.string),
+      mkField("abi_files_hash", Text, ~fieldSchema=S.string),
+    ],
+  )
+}
+
+module EndOfBlockRangeScannedData = {
+  type t = {
+    chain_id: int,
+    block_number: int,
+    block_hash: string,
+  }
+
+  let table = mkTable(
+    "end_of_block_range_scanned_data",
+    ~fields=[
+      mkField("chain_id", Integer, ~fieldSchema=S.int, ~isPrimaryKey),
+      mkField("block_number", Integer, ~fieldSchema=S.int, ~isPrimaryKey),
+      mkField("block_hash", Text, ~fieldSchema=S.string),
+    ],
+  )
+}
+
+module RawEvents = {
+  // @genType Used for Test DB and internal tests
+  @genType
+  type t = {
+    @as("chain_id") chainId: int,
+    @as("event_id") eventId: bigint,
+    @as("event_name") eventName: string,
+    @as("contract_name") contractName: string,
+    @as("block_number") blockNumber: int,
+    @as("log_index") logIndex: int,
+    @as("src_address") srcAddress: Address.t,
+    @as("block_hash") blockHash: string,
+    @as("block_timestamp") blockTimestamp: int,
+    @as("block_fields") blockFields: Js.Json.t,
+    @as("transaction_fields") transactionFields: Js.Json.t,
+    params: Js.Json.t,
+  }
+
+  let schema = S.schema(s => {
+    chainId: s.matches(S.int),
+    eventId: s.matches(S.bigint),
+    eventName: s.matches(S.string),
+    contractName: s.matches(S.string),
+    blockNumber: s.matches(S.int),
+    logIndex: s.matches(S.int),
+    srcAddress: s.matches(Address.schema),
+    blockHash: s.matches(S.string),
+    blockTimestamp: s.matches(S.int),
+    blockFields: s.matches(S.json(~validate=false)),
+    transactionFields: s.matches(S.json(~validate=false)),
+    params: s.matches(S.json(~validate=false)),
+  })
+
+  let table = mkTable(
+    "raw_events",
+    ~fields=[
+      mkField("chain_id", Integer, ~fieldSchema=S.int),
+      mkField("event_id", Numeric, ~fieldSchema=S.bigint),
+      mkField("event_name", Text, ~fieldSchema=S.string),
+      mkField("contract_name", Text, ~fieldSchema=S.string),
+      mkField("block_number", Integer, ~fieldSchema=S.int),
+      mkField("log_index", Integer, ~fieldSchema=S.int),
+      mkField("src_address", Text, ~fieldSchema=Address.schema),
+      mkField("block_hash", Text, ~fieldSchema=S.string),
+      mkField("block_timestamp", Integer, ~fieldSchema=S.int),
+      mkField("block_fields", JsonB, ~fieldSchema=S.json(~validate=false)),
+      mkField("transaction_fields", JsonB, ~fieldSchema=S.json(~validate=false)),
+      mkField("params", JsonB, ~fieldSchema=S.json(~validate=false)),
+      mkField(
+        "db_write_timestamp",
+        TimestampWithoutTimezone,
+        ~default="CURRENT_TIMESTAMP",
+        ~fieldSchema=S.int,
+      ),
+      mkField("serial", Serial, ~isNullable, ~isPrimaryKey, ~fieldSchema=S.null(S.int)),
+    ],
+  )
+}
+
+module DynamicContractRegistry = {
+  let name = "dynamic_contract_registry"
+
+  let makeId = (~chainId, ~contractAddress) => {
+    chainId->Belt.Int.toString ++ "-" ++ contractAddress->Address.toString
+  }
+
+  // @genType Used for Test DB
+  @genType
+  type t = {
+    id: string,
+    @as("chain_id") chainId: int,
+    @as("registering_event_block_number") registeringEventBlockNumber: int,
+    @as("registering_event_log_index") registeringEventLogIndex: int,
+    @as("registering_event_block_timestamp") registeringEventBlockTimestamp: int,
+    @as("registering_event_contract_name") registeringEventContractName: string,
+    @as("registering_event_name") registeringEventName: string,
+    @as("registering_event_src_address") registeringEventSrcAddress: Address.t,
+    @as("contract_address") contractAddress: Address.t,
+    @as("contract_name") contractName: string,
+  }
+
+  let schema = S.schema(s => {
+    id: s.matches(S.string),
+    chainId: s.matches(S.int),
+    registeringEventBlockNumber: s.matches(S.int),
+    registeringEventLogIndex: s.matches(S.int),
+    registeringEventContractName: s.matches(S.string),
+    registeringEventName: s.matches(S.string),
+    registeringEventSrcAddress: s.matches(Address.schema),
+    registeringEventBlockTimestamp: s.matches(S.int),
+    contractAddress: s.matches(Address.schema),
+    contractName: s.matches(S.string),
+  })
+
+  let rowsSchema = S.array(schema)
+
+  let table = mkTable(
+    name,
+    ~fields=[
+      mkField("id", Text, ~isPrimaryKey, ~fieldSchema=S.string),
+      mkField("chain_id", Integer, ~fieldSchema=S.int),
+      mkField("registering_event_block_number", Integer, ~fieldSchema=S.int),
+      mkField("registering_event_log_index", Integer, ~fieldSchema=S.int),
+      mkField("registering_event_block_timestamp", Integer, ~fieldSchema=S.int),
+      mkField("registering_event_contract_name", Text, ~fieldSchema=S.string),
+      mkField("registering_event_name", Text, ~fieldSchema=S.string),
+      mkField("registering_event_src_address", Text, ~fieldSchema=Address.schema),
+      mkField("contract_address", Text, ~fieldSchema=Address.schema),
+      mkField("contract_name", Text, ~fieldSchema=S.string),
+    ],
+  )
+
+  let entityHistory = table->EntityHistory.fromTable(~schema)
+
+  external castToInternal: t => Internal.entity = "%identity"
+
+  let config = {
+    name,
+    schema,
+    rowsSchema,
+    table,
+    entityHistory,
+  }->Internal.fromGenericEntityConfig
+}

package/src/db/InternalTable.res.js

@@ -0,0 +1,295 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+'use strict';
+
+var Table = require("./Table.res.js");
+var Utils = require("../Utils.res.js");
+var Js_exn = require("rescript/lib/js/js_exn.js");
+var Address = require("../Address.res.js");
+var Js_dict = require("rescript/lib/js/js_dict.js");
+var Js_null = require("rescript/lib/js/js_null.js");
+var Belt_Array = require("rescript/lib/js/belt_Array.js");
+var EntityHistory = require("./EntityHistory.res.js");
+var S$RescriptSchema = require("rescript-schema/src/S.res.js");
+
+var blockTimestampFieldName = "block_timestamp";
+
+var blockNumberFieldName = "block_number";
+
+var logIndexFieldName = "log_index";
+
+var isPreRegisteringDynamicContractsFieldName = "is_pre_registering_dynamic_contracts";
+
+var table = Table.mkTable("event_sync_state", undefined, [
+      Table.mkField("chain_id", "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, true, undefined, undefined),
+      Table.mkField(blockNumberFieldName, "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField(logIndexFieldName, "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField(blockTimestampFieldName, "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField(isPreRegisteringDynamicContractsFieldName, "BOOLEAN", S$RescriptSchema.bool, "false", undefined, undefined, undefined, undefined, undefined)
+    ]);
+
+function resetCurrentCurrentSyncStateQuery(pgSchema) {
+  return "UPDATE \"" + pgSchema + "\".\"" + table.tableName + "\"\n    SET " + blockNumberFieldName + " = 0, \n        " + logIndexFieldName + " = 0, \n        " + blockTimestampFieldName + " = 0, \n        " + isPreRegisteringDynamicContractsFieldName + " = false;";
+}
+
+var EventSyncState = {
+  blockTimestampFieldName: blockTimestampFieldName,
+  blockNumberFieldName: blockNumberFieldName,
+  logIndexFieldName: logIndexFieldName,
+  isPreRegisteringDynamicContractsFieldName: isPreRegisteringDynamicContractsFieldName,
+  table: table,
+  resetCurrentCurrentSyncStateQuery: resetCurrentCurrentSyncStateQuery
+};
+
+var fields = [
+  "id",
+  "start_block",
+  "end_block",
+  "source_block",
+  "first_event_block",
+  "buffer_block",
+  "ready_at",
+  "events_processed",
+  "_is_hyper_sync",
+  "_latest_processed_block",
+  "_num_batches_fetched"
+];
+
+var table$1 = Table.mkTable("envio_chains", undefined, [
+      Table.mkField("id", "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, true, undefined, undefined),
+      Table.mkField("start_block", "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("end_block", "INTEGER", S$RescriptSchema.$$null(S$RescriptSchema.$$int), undefined, undefined, true, undefined, undefined, undefined),
+      Table.mkField("buffer_block", "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("source_block", "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("first_event_block", "INTEGER", S$RescriptSchema.$$null(S$RescriptSchema.$$int), undefined, undefined, true, undefined, undefined, undefined),
+      Table.mkField("ready_at", "TIMESTAMP WITH TIME ZONE NULL", S$RescriptSchema.$$null(Utils.Schema.dbDate), undefined, undefined, true, undefined, undefined, undefined),
+      Table.mkField("events_processed", "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("_is_hyper_sync", "BOOLEAN", S$RescriptSchema.bool, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("_latest_processed_block", "INTEGER", S$RescriptSchema.$$null(S$RescriptSchema.$$int), undefined, undefined, true, undefined, undefined, undefined),
+      Table.mkField("_num_batches_fetched", "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined)
+    ]);
+
+function initialFromConfig(chainConfig) {
+  return {
+          id: chainConfig.id,
+          start_block: chainConfig.startBlock,
+          end_block: Js_null.fromOption(chainConfig.endBlock),
+          source_block: 0,
+          first_event_block: null,
+          buffer_block: -1,
+          ready_at: null,
+          events_processed: 0,
+          _latest_processed_block: null,
+          _is_hyper_sync: false,
+          _num_batches_fetched: 0
+        };
+}
+
+function makeInitialValuesQuery(pgSchema, chainConfigs) {
+  if (chainConfigs.length === 0) {
+    return ;
+  }
+  var columnNames = Belt_Array.map(fields, (function (field) {
+          return "\"" + field + "\"";
+        }));
+  var valuesRows = Belt_Array.map(chainConfigs, (function (chainConfig) {
+          var initialValues = initialFromConfig(chainConfig);
+          var values = Belt_Array.map(fields, (function (field) {
+                  var value = Js_dict.get(initialValues, field);
+                  var match = typeof value;
+                  switch (match) {
+                    case "boolean" :
+                        if (value) {
+                          return "true";
+                        } else {
+                          return "false";
+                        }
+                    case "number" :
+                        return String(value);
+                    case "object" :
+                        return "NULL";
+                    default:
+                      return Js_exn.raiseError("Invalid envio_chains value type");
+                  }
+                }));
+          return "(" + values.join(", ") + ")";
+        }));
+  return "INSERT INTO \"" + pgSchema + "\".\"" + table$1.tableName + "\" (" + columnNames.join(", ") + ")\nVALUES " + valuesRows.join(",\n       ") + ";";
+}
+
+var updateFields = [
+  "source_block",
+  "first_event_block",
+  "buffer_block",
+  "ready_at",
+  "events_processed",
+  "_is_hyper_sync",
+  "_latest_processed_block",
+  "_num_batches_fetched"
+];
+
+function makeSingleUpdateQuery(pgSchema) {
+  var setClauses = Belt_Array.mapWithIndex(updateFields, (function (index, field) {
+          var paramIndex = index + 2 | 0;
+          return "\"" + field + "\" = $" + String(paramIndex);
+        }));
+  return "UPDATE \"" + pgSchema + "\".\"" + table$1.tableName + "\"\nSET " + setClauses.join(",\n    ") + "\nWHERE \"id\" = $1;";
+}
+
+function setValues(sql, pgSchema, chainsData) {
+  var query = makeSingleUpdateQuery(pgSchema);
+  return Promise.all(Belt_Array.map(chainsData, (function (chain) {
+                    var params = [];
+                    var idValue = Js_dict.get(chain, "id");
+                    params.push(idValue);
+                    updateFields.forEach(function (field) {
+                          var value = Js_dict.get(chain, field);
+                          params.push(value);
+                        });
+                    return sql.unsafe(query, params, {prepare: true});
+                  })));
+}
+
+var Chains = {
+  fields: fields,
+  table: table$1,
+  initialFromConfig: initialFromConfig,
+  makeInitialValuesQuery: makeInitialValuesQuery,
+  updateFields: updateFields,
+  makeSingleUpdateQuery: makeSingleUpdateQuery,
+  setValues: setValues
+};
+
+var table$2 = Table.mkTable("persisted_state", undefined, [
+      Table.mkField("id", "SERIAL", S$RescriptSchema.$$int, undefined, undefined, undefined, true, undefined, undefined),
+      Table.mkField("envio_version", "TEXT", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("config_hash", "TEXT", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("schema_hash", "TEXT", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("handler_files_hash", "TEXT", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("abi_files_hash", "TEXT", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined)
+    ]);
+
+var PersistedState = {
+  table: table$2
+};
+
+var table$3 = Table.mkTable("end_of_block_range_scanned_data", undefined, [
+      Table.mkField("chain_id", "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, true, undefined, undefined),
+      Table.mkField("block_number", "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, true, undefined, undefined),
+      Table.mkField("block_hash", "TEXT", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined)
+    ]);
+
+var EndOfBlockRangeScannedData = {
+  table: table$3
+};
+
+var schema = S$RescriptSchema.schema(function (s) {
+      return {
+              chain_id: s.m(S$RescriptSchema.$$int),
+              event_id: s.m(S$RescriptSchema.bigint),
+              event_name: s.m(S$RescriptSchema.string),
+              contract_name: s.m(S$RescriptSchema.string),
+              block_number: s.m(S$RescriptSchema.$$int),
+              log_index: s.m(S$RescriptSchema.$$int),
+              src_address: s.m(Address.schema),
+              block_hash: s.m(S$RescriptSchema.string),
+              block_timestamp: s.m(S$RescriptSchema.$$int),
+              block_fields: s.m(S$RescriptSchema.json(false)),
+              transaction_fields: s.m(S$RescriptSchema.json(false)),
+              params: s.m(S$RescriptSchema.json(false))
+            };
+    });
+
+var table$4 = Table.mkTable("raw_events", undefined, [
+      Table.mkField("chain_id", "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("event_id", "NUMERIC", S$RescriptSchema.bigint, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("event_name", "TEXT", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("contract_name", "TEXT", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("block_number", "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("log_index", "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("src_address", "TEXT", Address.schema, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("block_hash", "TEXT", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("block_timestamp", "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("block_fields", "JSONB", S$RescriptSchema.json(false), undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("transaction_fields", "JSONB", S$RescriptSchema.json(false), undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("params", "JSONB", S$RescriptSchema.json(false), undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("db_write_timestamp", "TIMESTAMP", S$RescriptSchema.$$int, "CURRENT_TIMESTAMP", undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("serial", "SERIAL", S$RescriptSchema.$$null(S$RescriptSchema.$$int), undefined, undefined, true, true, undefined, undefined)
+    ]);
+
+var RawEvents = {
+  schema: schema,
+  table: table$4
+};
+
+var name = "dynamic_contract_registry";
+
+function makeId(chainId, contractAddress) {
+  return String(chainId) + "-" + contractAddress;
+}
+
+var schema$1 = S$RescriptSchema.schema(function (s) {
+      return {
+              id: s.m(S$RescriptSchema.string),
+              chain_id: s.m(S$RescriptSchema.$$int),
+              registering_event_block_number: s.m(S$RescriptSchema.$$int),
+              registering_event_log_index: s.m(S$RescriptSchema.$$int),
+              registering_event_block_timestamp: s.m(S$RescriptSchema.$$int),
+              registering_event_contract_name: s.m(S$RescriptSchema.string),
+              registering_event_name: s.m(S$RescriptSchema.string),
+              registering_event_src_address: s.m(Address.schema),
+              contract_address: s.m(Address.schema),
+              contract_name: s.m(S$RescriptSchema.string)
+            };
+    });
+
+var rowsSchema = S$RescriptSchema.array(schema$1);
+
+var table$5 = Table.mkTable(name, undefined, [
+      Table.mkField("id", "TEXT", S$RescriptSchema.string, undefined, undefined, undefined, true, undefined, undefined),
+      Table.mkField("chain_id", "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("registering_event_block_number", "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("registering_event_log_index", "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("registering_event_block_timestamp", "INTEGER", S$RescriptSchema.$$int, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("registering_event_contract_name", "TEXT", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("registering_event_name", "TEXT", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("registering_event_src_address", "TEXT", Address.schema, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("contract_address", "TEXT", Address.schema, undefined, undefined, undefined, undefined, undefined, undefined),
+      Table.mkField("contract_name", "TEXT", S$RescriptSchema.string, undefined, undefined, undefined, undefined, undefined, undefined)
+    ]);
+
+var entityHistory = EntityHistory.fromTable(table$5, schema$1);
+
+var config = {
+  name: name,
+  schema: schema$1,
+  rowsSchema: rowsSchema,
+  table: table$5,
+  entityHistory: entityHistory
+};
+
+var DynamicContractRegistry = {
+  name: name,
+  makeId: makeId,
+  schema: schema$1,
+  rowsSchema: rowsSchema,
+  table: table$5,
+  entityHistory: entityHistory,
+  config: config
+};
+
+var isPrimaryKey = true;
+
+var isNullable = true;
+
+var isIndex = true;
+
+exports.isPrimaryKey = isPrimaryKey;
+exports.isNullable = isNullable;
+exports.isIndex = isIndex;
+exports.EventSyncState = EventSyncState;
+exports.Chains = Chains;
+exports.PersistedState = PersistedState;
+exports.EndOfBlockRangeScannedData = EndOfBlockRangeScannedData;
+exports.RawEvents = RawEvents;
+exports.DynamicContractRegistry = DynamicContractRegistry;
+/* table Not a pure module */