envio 2.17.1 → 2.19.0

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "envio",
-  "version": "v2.17.1",
+  "version": "v2.19.0",
   "description": "A latency and sync speed optimized, developer friendly blockchain data indexer.",
   "bin": "./bin.js",
-  "types": "index.d.ts",
+  "main": "./index.js",
+  "types": "./index.d.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/enviodev/hyperindex.git"
@@ -24,15 +25,15 @@
   },
   "homepage": "https://envio.dev",
   "optionalDependencies": {
-    "envio-linux-x64": "v2.17.1",
-    "envio-linux-arm64": "v2.17.1",
-    "envio-darwin-x64": "v2.17.1",
-    "envio-darwin-arm64": "v2.17.1"
+    "envio-linux-x64": "v2.19.0",
+    "envio-linux-arm64": "v2.19.0",
+    "envio-darwin-x64": "v2.19.0",
+    "envio-darwin-arm64": "v2.19.0"
   },
   "dependencies": {
     "@envio-dev/hypersync-client": "0.6.3",
     "rescript": "11.1.3",
-    "rescript-schema": "9.1.0",
+    "rescript-schema": "9.3.0",
     "viem": "2.21.0"
   },
   "files": [

package/src/Envio.gen.ts

@@ -3,6 +3,27 @@
 /* eslint-disable */
 /* tslint:disable */
 
+import type {EffectContext as $$effectContext} from './Types.ts';
+
+import type {Effect as $$effect} from './Types.ts';
+
 import type {Logger as $$logger} from './Types.ts';
 
+import type {S_t as RescriptSchema_S_t} from './RescriptSchema.gen';
+
 export type logger = $$logger;
+
+export type effect<input,output> = $$effect<input,output>;
+
+export type effectOptions<input,output> = {
+  /** The name of the effect. Used for logging and debugging. */
+  readonly name: string; 
+  /** The input schema of the effect. */
+  readonly input: RescriptSchema_S_t<input>; 
+  /** The output schema of the effect. */
+  readonly output: RescriptSchema_S_t<output>
+};
+
+export type effectContext = $$effectContext;
+
+export type effectArgs<input> = { readonly input: input; readonly context: effectContext };

package/src/Envio.res

@@ -10,3 +10,41 @@ type logger = {
   error: 'params. (string, ~params: {..} as 'params=?) => unit,
   errorWithExn: (string, exn) => unit,
 }
+
+@@warning("-30") // Duplicated type names (input)
+@genType.import(("./Types.ts", "Effect"))
+type rec effect<'input, 'output>
+@genType
+and effectOptions<'input, 'output> = {
+  /** The name of the effect. Used for logging and debugging. */
+  name: string,
+  /** The input schema of the effect. */
+  input: S.t<'input>,
+  /** The output schema of the effect. */
+  output: S.t<'output>,
+}
+@genType.import(("./Types.ts", "EffectContext"))
+and effectContext = {
+  log: logger,
+  effect: 'input 'output. (effect<'input, 'output>, 'input) => promise<'output>,
+}
+@genType
+and effectArgs<'input> = {
+  input: 'input,
+  context: effectContext,
+}
+@@warning("+30")
+
+let experimental_createEffect = (
+  options: effectOptions<'input, 'output>,
+  handler: effectArgs<'input> => promise<'output>,
+) => {
+  {
+    name: options.name,
+    handler: handler->(
+      Utils.magic: (effectArgs<'input> => promise<'output>) => Internal.effectArgs => promise<
+        Internal.effectOutput,
+      >
+    ),
+  }->(Utils.magic: Internal.effect => effect<'input, 'output>)
+}

package/src/Internal.gen.ts

@@ -37,6 +37,7 @@ export type genericHandlerWithLoader<loader,handler,eventFilters> = {
   readonly handler: handler; 
   readonly wildcard?: boolean; 
   readonly eventFilters?: eventFilters; 
+  /** @deprecated The option is removed starting from v2.19 since we made the default mode even faster than pre-registration. */
   readonly preRegisterDynamicContracts?: boolean
 };
 

package/src/Internal.res

@@ -61,6 +61,9 @@ type genericHandlerWithLoader<'loader, 'handler, 'eventFilters> = {
   handler: 'handler,
   wildcard?: bool,
   eventFilters?: 'eventFilters,
+  /**
+   @deprecated The option is removed starting from v2.19 since we made the default mode even faster than pre-registration.
+   */
   preRegisterDynamicContracts?: bool,
 }
 
@@ -73,10 +76,11 @@ type eventConfig = private {
   name: string,
   contractName: string,
   isWildcard: bool,
+  // Whether the event has an event filter which uses addresses
+  filterByAddresses: bool,
   // Usually always false for wildcard events
   // But might be true for wildcard event with dynamic event filter by addresses
   dependsOnAddresses: bool,
-  preRegisterDynamicContracts: bool,
   loader: option<loader>,
   handler: option<handler>,
   contractRegister: option<contractRegister>,
@@ -130,10 +134,6 @@ type eventItem = {
   blockNumber: int,
   logIndex: int,
   event: event,
-  //Default to false, if an event needs to
-  //be reprocessed after it has loaded dynamic contracts
-  //This gets set to true and does not try and reload events
-  hasRegisteredDynamicContracts?: bool,
   // Reuse logger object for event
   mutable loggerCache?: Pino.t,
 }
@@ -161,6 +161,19 @@ let fuelTransferParamsSchema = S.schema(s => {
 
 type entity = private {id: string}
 
+type effectInput
+type effectOutput
+type effectContext
+type effectArgs = {
+  input: effectInput,
+  context: effectContext,
+  cacheKey: string,
+}
+type effect = {
+  name: string,
+  handler: effectArgs => promise<effectOutput>,
+}
+
 @genType.import(("./Types.ts", "Invalid"))
 type noEventFilters
 

package/src/LoadManager.res

@@ -106,6 +106,11 @@ let call = (
   ~key,
   ~load,
   ~hasher,
+  /*
+   Whether the call should be grouped
+   with the same calls until the next microtask
+   or executed immediately
+ */
   ~shouldGroup,
   ~hasInMemory,
   ~getUnsafeInMemory,

package/src/LogSelection.res

@@ -59,7 +59,7 @@ let make = (~addresses, ~topicSelections) => {
 
 type parsedEventFilters = {
   getEventFiltersOrThrow: ChainMap.Chain.t => Internal.eventFilters,
-  dependsOnAddresses: bool,
+  filterByAddresses: bool,
 }
 
 let parseEventFiltersOrThrow = {
@@ -74,7 +74,7 @@ let parseEventFiltersOrThrow = {
     ~topic2=noopGetter,
     ~topic3=noopGetter,
   ): parsedEventFilters => {
-    let dependsOnAddresses = ref(false)
+    let filterByAddresses = ref(false)
     let topic0 = [sighash->EvmTypes.Hex.fromStringUnsafe]
     let default = {
       Internal.topic0,
@@ -145,7 +145,7 @@ let parseEventFiltersOrThrow = {
             "addresses",
             {
               get: () => {
-                dependsOnAddresses := true
+                filterByAddresses := true
                 []
               },
             },
@@ -154,7 +154,7 @@ let parseEventFiltersOrThrow = {
         } catch {
         | _ => ()
         }
-        if dependsOnAddresses.contents {
+        if filterByAddresses.contents {
           chain => Internal.Dynamic(
             addresses => fn({chainId: chain->ChainMap.Chain.toChainId, addresses})->parse,
           )
@@ -173,7 +173,7 @@ let parseEventFiltersOrThrow = {
 
     {
       getEventFiltersOrThrow,
-      dependsOnAddresses: dependsOnAddresses.contents,
+      filterByAddresses: filterByAddresses.contents,
     }
   }
 }

package/src/Prometheus.res

@@ -0,0 +1,316 @@
+let loadEntitiesDurationCounter = PromClient.Counter.makeCounter({
+  "name": "load_entities_processing_time_spent",
+  "help": "Duration spend on loading entities",
+  "labelNames": [],
+})
+
+let eventRouterDurationCounter = PromClient.Counter.makeCounter({
+  "name": "event_router_processing_time_spent",
+  "help": "Duration spend on event routing",
+  "labelNames": [],
+})
+
+let executeBatchDurationCounter = PromClient.Counter.makeCounter({
+  "name": "execute_batch_processing_time_spent",
+  "help": "Duration spend on executing batch",
+  "labelNames": [],
+})
+
+let eventsProcessedCounter = PromClient.Gauge.makeGauge({
+  "name": "events_processed",
+  "help": "Total number of events processed",
+  "labelNames": ["chainId"],
+})
+
+let reorgsDetectedCounter = PromClient.Counter.makeCounter({
+  "name": "reorgs_detected",
+  "help": "Total number of reorgs detected",
+  "labelNames": ["chainId"],
+})
+
+let allChainsSyncedToHead = PromClient.Gauge.makeGauge({
+  "name": "hyperindex_synced_to_head",
+  "help": "All chains fully synced",
+  "labelNames": [],
+})
+
+let sourceChainHeight = PromClient.Gauge.makeGauge({
+  "name": "chain_block_height",
+  "help": "Chain Height of Source Chain",
+  "labelNames": ["chainId"],
+})
+
+module Labels = {
+  let rec schemaIsString = (schema: S.t<'a>) =>
+    switch schema->S.classify {
+    | String => true
+    | Null(s)
+    | Option(s) =>
+      s->schemaIsString
+    | _ => false
+    }
+
+  let getLabelNames = (schema: S.t<'a>) =>
+    switch schema->S.classify {
+    | Object({items}) =>
+      let nonStringFields = items->Belt.Array.reduce([], (nonStringFields, item) => {
+        if item.schema->schemaIsString {
+          nonStringFields
+        } else {
+          nonStringFields->Belt.Array.concat([item.location])
+        }
+      })
+
+      switch nonStringFields {
+      | [] => items->Belt.Array.map(item => item.location)->Ok
+      | nonStringItems =>
+        let nonStringItems = nonStringItems->Js.Array2.joinWith(", ")
+        Error(
+          `Label schema must be an object with string (or optional string) values. Non string values: ${nonStringItems}`,
+        )
+      }
+    | _ => Error("Label schema must be an object")
+    }
+}
+
+let metricNames: Utils.Set.t<string> = Utils.Set.make()
+
+module MakeSafePromMetric = (
+  M: {
+    type t
+    let make: {"name": string, "help": string, "labelNames": array<string>} => t
+    let labels: (t, 'a) => t
+    let handleFloat: (t, float) => unit
+    let handleInt: (t, int) => unit
+  },
+): {
+  type t<'a>
+  let makeOrThrow: (~name: string, ~help: string, ~labelSchema: S.t<'a>) => t<'a>
+  let handleInt: (t<'a>, ~labels: 'a, ~value: int) => unit
+  let handleFloat: (t<'a>, ~labels: 'a, ~value: float) => unit
+} => {
+  type t<'a> = {metric: M.t, labelSchema: S.t<'a>}
+
+  let makeOrThrow = (~name, ~help, ~labelSchema: S.t<'a>): t<'a> =>
+    switch labelSchema->Labels.getLabelNames {
+    | Ok(labelNames) =>
+      if metricNames->Utils.Set.has(name) {
+        Js.Exn.raiseError("Duplicate prometheus metric name: " ++ name)
+      } else {
+        metricNames->Utils.Set.add(name)->ignore
+        let metric = M.make({
+          "name": name,
+          "help": help,
+          "labelNames": labelNames,
+        })
+
+        {metric, labelSchema}
+      }
+
+    | Error(error) => Js.Exn.raiseError(error)
+    }
+
+  let handleFloat = ({metric, labelSchema}: t<'a>, ~labels: 'a, ~value) =>
+    metric
+    ->M.labels(labels->S.reverseConvertToJsonOrThrow(labelSchema))
+    ->M.handleFloat(value)
+
+  let handleInt = ({metric, labelSchema}: t<'a>, ~labels: 'a, ~value) =>
+    metric
+    ->M.labels(labels->S.reverseConvertToJsonOrThrow(labelSchema))
+    ->M.handleInt(value)
+}
+
+module SafeCounter = MakeSafePromMetric({
+  type t = PromClient.Counter.counter
+  let make = PromClient.Counter.makeCounter
+  let labels = PromClient.Counter.labels
+  let handleInt = PromClient.Counter.incMany
+  let handleFloat = PromClient.Counter.incMany->Utils.magic
+})
+
+module SafeGauge = MakeSafePromMetric({
+  type t = PromClient.Gauge.gauge
+  let make = PromClient.Gauge.makeGauge
+  let labels = PromClient.Gauge.labels
+  let handleInt = PromClient.Gauge.set
+  let handleFloat = PromClient.Gauge.setFloat
+})
+
+module BenchmarkSummaryData = {
+  type labels = {
+    group: string,
+    stat: string,
+    label: string,
+  }
+  let labelSchema = S.schema(s => {
+    group: s.matches(S.string),
+    stat: s.matches(S.string),
+    label: s.matches(S.string),
+  })
+
+  let gauge = SafeGauge.makeOrThrow(
+    ~name="benchmark_summary_data",
+    ~help="All data points collected during indexer benchmark",
+    ~labelSchema,
+  )
+
+  let set = (
+    ~group: string,
+    ~label: string,
+    ~n: float,
+    ~mean: float,
+    ~stdDev: option<float>,
+    ~min: float,
+    ~max: float,
+    ~sum: float,
+  ) => {
+    let mk = stat => {
+      group,
+      stat,
+      label,
+    }
+    gauge->SafeGauge.handleFloat(~labels=mk("n"), ~value=n)
+    gauge->SafeGauge.handleFloat(~labels=mk("mean"), ~value=mean)
+    gauge->SafeGauge.handleFloat(~labels=mk("min"), ~value=min)
+    gauge->SafeGauge.handleFloat(~labels=mk("max"), ~value=max)
+    gauge->SafeGauge.handleFloat(~labels=mk("sum"), ~value=sum)
+    switch stdDev {
+    | Some(stdDev) => gauge->SafeGauge.handleFloat(~labels=mk("stdDev"), ~value=stdDev)
+    | None => ()
+    }
+  }
+}
+
+let processedUntilHeight = PromClient.Gauge.makeGauge({
+  "name": "chain_block_height_processed",
+  "help": "Block height processed by indexer",
+  "labelNames": ["chainId"],
+})
+
+let fetchedUntilHeight = PromClient.Gauge.makeGauge({
+  "name": "chain_block_height_fully_fetched",
+  "help": "Block height fully fetched by indexer",
+  "labelNames": ["chainId"],
+})
+
+let incrementLoadEntityDurationCounter = (~duration) => {
+  loadEntitiesDurationCounter->PromClient.Counter.incMany(duration)
+}
+
+let incrementEventRouterDurationCounter = (~duration) => {
+  eventRouterDurationCounter->PromClient.Counter.incMany(duration)
+}
+
+let incrementExecuteBatchDurationCounter = (~duration) => {
+  executeBatchDurationCounter->PromClient.Counter.incMany(duration)
+}
+
+let setEventsProcessedGuage = (~number, ~chainId) => {
+  eventsProcessedCounter
+  ->PromClient.Gauge.labels({"chainId": chainId})
+  ->PromClient.Gauge.set(number)
+}
+
+let incrementReorgsDetected = (~chain) => {
+  reorgsDetectedCounter->PromClient.Counter.incLabels({"chainId": chain->ChainMap.Chain.toString})
+}
+
+let setSourceChainHeight = (~blockNumber, ~chain) => {
+  sourceChainHeight
+  ->PromClient.Gauge.labels({"chainId": chain->ChainMap.Chain.toString})
+  ->PromClient.Gauge.set(blockNumber)
+}
+
+let setAllChainsSyncedToHead = () => {
+  allChainsSyncedToHead->PromClient.Gauge.set(1)
+}
+
+let setProcessedUntilHeight = (~blockNumber, ~chain) => {
+  processedUntilHeight
+  ->PromClient.Gauge.labels({"chainId": chain->ChainMap.Chain.toString})
+  ->PromClient.Gauge.set(blockNumber)
+}
+
+let setFetchedUntilHeight = (~blockNumber, ~chain) => {
+  fetchedUntilHeight
+  ->PromClient.Gauge.labels({"chainId": chain->ChainMap.Chain.toString})
+  ->PromClient.Gauge.set(blockNumber)
+}
+
+module BenchmarkCounters = {
+  type labels = {label: string}
+  let labelSchema = S.schema(s => {
+    label: s.matches(S.string),
+  })
+
+  let gauge = SafeGauge.makeOrThrow(
+    ~name="benchmark_counters",
+    ~help="All counters collected during indexer benchmark",
+    ~labelSchema,
+  )
+
+  let set = (~label, ~millis, ~totalRuntimeMillis) => {
+    gauge->SafeGauge.handleFloat(~labels={label: label}, ~value=millis)
+    gauge->SafeGauge.handleFloat(~labels={label: "Total Run Time (ms)"}, ~value=totalRuntimeMillis)
+  }
+}
+
+module PartitionBlockFetched = {
+  type labels = {chainId: int, partitionId: string}
+
+  let labelSchema = S.schema(s => {
+    chainId: s.matches(S.string->S.coerce(S.int)),
+    partitionId: s.matches(S.string),
+  })
+
+  let counter = SafeGauge.makeOrThrow(
+    ~name="partition_block_fetched",
+    ~help="The latest fetched block number for each partition",
+    ~labelSchema,
+  )
+
+  let set = (~blockNumber, ~partitionId, ~chainId) => {
+    counter->SafeGauge.handleInt(~labels={chainId, partitionId}, ~value=blockNumber)
+  }
+}
+
+let chainIdLabelsSchema = S.object(s => {
+  s.field("chainId", S.string->S.coerce(S.int))
+})
+
+module IndexingAddresses = {
+  let gauge = SafeGauge.makeOrThrow(
+    ~name="envio_indexing_addresses",
+    ~help="The number of addresses indexed on chain. Includes both static and dynamic addresses.",
+    ~labelSchema=chainIdLabelsSchema,
+  )
+
+  let set = (~addressesCount, ~chainId) => {
+    gauge->SafeGauge.handleInt(~labels=chainId, ~value=addressesCount)
+  }
+}
+
+module IndexingEndBlock = {
+  let gauge = SafeGauge.makeOrThrow(
+    ~name="envio_indexing_end_block",
+    ~help="The block number to stop indexing at. (inclusive)",
+    ~labelSchema=chainIdLabelsSchema,
+  )
+
+  let set = (~endBlock, ~chainId) => {
+    gauge->SafeGauge.handleInt(~labels=chainId, ~value=endBlock)
+  }
+}
+
+module ProgressBlockNumber = {
+  let gauge = SafeGauge.makeOrThrow(
+    ~name="envio_progress_block_number",
+    ~help="The block number to track the progress of indexing at. Currently uses the fully fetched block number. In the future will be changed to block number processed and stored in the database.",
+    ~labelSchema=chainIdLabelsSchema,
+  )
+
+  let set = (~endBlock, ~chainId) => {
+    gauge->SafeGauge.handleInt(~labels=chainId, ~value=endBlock)
+  }
+}

package/src/Types.ts

@@ -20,3 +20,28 @@ export type Logger = {
     params?: Record<string, unknown> | Error
   ) => void;
 };
+
+export abstract class Effect<I, O> {
+  protected opaque!: I | O;
+}
+
+export type EffectCaller = <I, O>(
+  effect: Effect<I, O>,
+  // This is a hack to make the call complain on undefined
+  // when it's not needed, instead of extending the input type.
+  // Might be not needed if I misunderstand something in TS.
+  input: I extends undefined ? undefined : I
+) => Promise<O>;
+
+export type EffectContext = {
+  /**
+   * Access the logger instance with event as a context. The logs will be displayed in the console and Envio Hosted Service.
+   */
+  readonly log: Logger;
+  /**
+   * Call the provided Effect with the given input.
+   * Effects are the best for external calls with automatic deduplication, error handling and caching.
+   * Define a new Effect using createEffect outside of the handler.
+   */
+  readonly effect: EffectCaller;
+};

package/src/Utils.res

@@ -70,6 +70,8 @@ module Dict = {
    */
   external dangerouslyGetNonOption: (dict<'a>, string) => option<'a> = ""
 
+  let has: (dict<'a>, string) => bool = %raw(`(dict, key) => key in dict`)
+
   let push = (dict, key, value) => {
     switch dict->dangerouslyGetNonOption(key) {
     | Some(arr) => arr->Js.Array2.push(value)->ignore
@@ -86,6 +88,9 @@ module Dict = {
 
   let merge: (dict<'a>, dict<'a>) => dict<'a> = %raw(`(dictA, dictB) => ({...dictA, ...dictB})`)
 
+  @val
+  external mergeInPlace: (dict<'a>, dict<'a>) => dict<'a> = "Object.assign"
+
   let map = (dict, fn) => {
     let newDict = Js.Dict.empty()
     let keys = dict->Js.Dict.keys
@@ -103,6 +108,14 @@ module Dict = {
     }
   }
 
+  let forEachWithKey = (dict, fn) => {
+    let keys = dict->Js.Dict.keys
+    for idx in 0 to keys->Js.Array2.length - 1 {
+      let key = keys->Js.Array2.unsafe_get(idx)
+      fn(key, dict->Js.Dict.unsafeGet(key))
+    }
+  }
+
   let deleteInPlace: (dict<'a>, string) => unit = %raw(`(dict, key) => {
       delete dict[key];
     }
@@ -115,6 +128,8 @@ module Dict = {
   ) => dict<'a> = %raw(`(dict, key, value) => ({...dict, [key]: value})`)
 
   let shallowCopy: dict<'a> => dict<'a> = %raw(`(dict) => ({...dict})`)
+
+  let size = dict => dict->Js.Dict.keys->Js.Array2.length
 }
 
 module Math = {
@@ -205,6 +220,12 @@ Helper to check if a value exists in an array
     | _ => false
     }
 
+  let notEmpty = (arr: array<_>) =>
+    switch arr {
+    | [] => false
+    | _ => true
+    }
+
   let awaitEach = async (arr: array<'a>, fn: 'a => promise<unit>) => {
     for i in 0 to arr->Array.length - 1 {
       let item = arr[i]
@@ -270,6 +291,9 @@ Helper to check if a value exists in an array
 
   @send
   external flatten: (array<array<'a>>, @as(1) _) => array<'a> = "flat"
+
+  @send
+  external copy: array<'a> => array<'a> = "slice"
 }
 
 module String = {
@@ -467,3 +491,49 @@ module Proxy = {
   @new
   external make: ('a, traps<'a>) => 'a = "Proxy"
 }
+
+module Hash = {
+  let rec makeOrThrow = (any: 'a): string => {
+    switch any->Js.typeof {
+    | "string" => any->magic
+    | "number" => any->magic->Js.Int.toString
+    | "bigint" => any->magic->BigInt.toString
+    | "boolean" => any->magic ? "true" : "false"
+    | "undefined" => "undefined"
+    | "object" =>
+      if any === %raw(`null`) {
+        "null"
+      } else if any->Js.Array2.isArray {
+        let any: array<'a> = any->magic
+        let hash = ref("[")
+        for i in 0 to any->Js.Array2.length - 1 {
+          hash := hash.contents ++ any->Js.Array2.unsafe_get(i)->makeOrThrow ++ ","
+        }
+        hash.contents ++ "]"
+      } else {
+        let any: dict<'a> = any->magic
+        let constructor = any->Js.Dict.unsafeGet("constructor")->magic
+        if constructor === %raw(`Object`) {
+          let hash = ref("{")
+          let keys = any->Js.Dict.keys->Js.Array2.sortInPlace
+          for i in 0 to keys->Js.Array2.length - 1 {
+            let key = keys->Js.Array2.unsafe_get(i)
+            // Ideally should escape and wrap the key in double quotes
+            // but since we don't need to decode the hash,
+            // it's fine to keep it super simple
+            hash := hash.contents ++ key ++ ":" ++ any->Js.Dict.unsafeGet(key)->makeOrThrow ++ ","
+          }
+          hash.contents ++ "}"
+        } else if constructor["name"] === "BigNumber" {
+          (any->magic)["toString"]()
+        } else {
+          Js.Exn.raiseError(`Don't know how to serialize ${(constructor->magic)["name"]}`)
+        }
+      }
+    | "symbol"
+    | "function" =>
+      (any->magic)["toString"]()
+    | typeof => Js.Exn.raiseError(`Don't know how to serialize ${typeof}`)
+    }
+  }
+}

package/src/bindings/BigDecimal.gen.ts

@@ -0,0 +1,14 @@
+/* TypeScript file generated from BigDecimal.res by genType. */
+
+/* eslint-disable */
+/* tslint:disable */
+
+const BigDecimalJS = require('./BigDecimal.bs.js');
+
+import type {S_t as RescriptSchema_S_t} from './RescriptSchema.gen';
+
+import type {default as $$t} from 'bignumber.js';
+
+export type t = $$t;
+
+export const schema: RescriptSchema_S_t<t> = BigDecimalJS.schema as any;

package/src/bindings/BigDecimal.res

@@ -0,0 +1,61 @@
+@genType.import(("bignumber.js", "default"))
+type rec t = {
+  toString: unit => string,
+  toFixed: int => string,
+  plus: t => t,
+  minus: t => t,
+  times: t => t,
+  div: t => t,
+  isEqualTo: t => bool,
+  gt: t => bool,
+  gte: t => bool,
+  lt: t => bool,
+  lte: t => bool,
+}
+
+// Constructors
+@new @module external fromBigInt: bigint => t = "bignumber.js"
+@new @module external fromFloat: float => t = "bignumber.js"
+@new @module external fromInt: int => t = "bignumber.js"
+@new @module external fromStringUnsafe: string => t = "bignumber.js"
+@new @module external fromString: string => option<t> = "bignumber.js"
+
+// Methods
+@send external toString: t => string = "toString"
+@send external toFixed: t => string = "toFixed"
+let toInt = (b: t): option<int> => b->toString->Belt.Int.fromString
+@send external toNumber: t => float = "toNumber"
+
+// Arithmetic Operations
+@send external plus: (t, t) => t = "plus"
+@send external minus: (t, t) => t = "minus"
+@send external times: (t, t) => t = "multipliedBy"
+@send external div: (t, t) => t = "dividedBy"
+@send external sqrt: t => t = "sqrt"
+
+// Comparison
+@send external equals: (t, t) => bool = "isEqualTo"
+let notEquals: (t, t) => bool = (a, b) => !equals(a, b)
+@send external gt: (t, t) => bool = "isGreaterThan"
+@send external gte: (t, t) => bool = "isGreaterThanOrEqualTo"
+@send external lt: (t, t) => bool = "isLessThan"
+@send external lte: (t, t) => bool = "isLessThanOrEqualTo"
+
+// Utilities
+let zero = fromInt(0)
+let one = fromInt(1)
+@send external decimalPlaces: (t, int) => t = "decimalPlaces"
+
+// Serialization
+@genType
+let schema =
+  S.string
+  ->S.setName("BigDecimal")
+  ->S.transform(s => {
+    parser: string =>
+      switch string->fromString {
+      | Some(bigDecimal) => bigDecimal
+      | None => s.fail("The string is not valid BigDecimal")
+      },
+    serializer: bigDecimal => bigDecimal.toString(),
+  })

package/src/bindings/PromClient.res

@@ -0,0 +1,58 @@
+/** All metric types have two mandatory parameters: name and help. Refer to https://prometheus.io/docs/practices/naming/ for guidance on naming metrics. */
+type customMetric<'a> = {.."name": string, "help": string} as 'a
+
+@module("prom-client") external collectDefaultMetrics: 'a => unit = "collectDefaultMetrics"
+
+type registry
+@new @module("prom-client") external makeRegistry: unit => registry = "Registry"
+
+@module("prom-client") external defaultRegister: registry = "register"
+
+@send external metrics: registry => Promise.t<string> = "metrics"
+@get external getContentType: registry => string = "contentType"
+
+module Counter = {
+  type counter
+  @new @module("prom-client") external makeCounter: customMetric<'a> => counter = "Counter"
+
+  @send external inc: counter => unit = "inc"
+  @send external incMany: (counter, int) => unit = "inc"
+
+  @send external incLabels: (counter, 'labelsObject) => unit = "labels"
+  @send external labels: (counter, 'labelsObject) => counter = "labels"
+}
+
+module Gauge = {
+  type gauge
+  @new @module("prom-client") external makeGauge: customMetric<'a> => gauge = "Gauge"
+
+  @send external inc: gauge => unit = "inc"
+  @send external incMany: (gauge, int) => unit = "inc"
+
+  @send external dec: gauge => unit = "dec"
+  @send external decMany: (gauge, int) => unit = "dec"
+
+  @send external set: (gauge, int) => unit = "set"
+
+  @send external setFloat: (gauge, float) => unit = "set"
+
+  @send external labels: (gauge, 'labelsObject) => gauge = "labels"
+}
+
+module Histogram = {
+  type histogram
+  @new @module("prom-client") external makeHistogram: customMetric<'a> => histogram = "Histogram"
+
+  @send external observe: (histogram, float) => unit = "observe"
+  @send external startTimer: (histogram, unit) => float = "startTimer"
+
+  @send external labels: (histogram, 'labelsObject) => histogram = "labels"
+}
+
+module Summary = {
+  type summary
+  @new @module("prom-client") external makeSummary: customMetric<'a> => summary = "Summary"
+
+  @send external observe: (summary, float) => unit = "observe"
+  @send external startTimer: (summary, unit) => float = "startTimer"
+}

package/src/db/Table.res

@@ -214,7 +214,10 @@ let toSqlParams = (table: table, ~schema) => {
             }
           | Bool =>
             // Workaround for https://github.com/porsager/postgres/issues/471
-            S.union([S.literal(1)->S.to(_ => true), S.literal(0)->S.to(_ => false)])->S.toUnknown
+            S.union([
+              S.literal(1)->S.shape(_ => true),
+              S.literal(0)->S.shape(_ => false),
+            ])->S.toUnknown
           | _ => schema
           }
 

package/src/ContractAddressingMap.res

@@ -1,115 +0,0 @@
-type contractName = string
-
-// Currently this mapping append only, so we don't need to worry about
-// protecting static addresses from de-registration.
-
-type mapping = {
-  nameByAddress: dict<contractName>,
-  addressesByName: dict<Belt.Set.String.t>,
-}
-
-exception AddressRegisteredForMultipleContracts({address: Address.t, names: array<contractName>})
-
-let addAddress = (map: mapping, ~name: string, ~address: Address.t) => {
-  switch map.nameByAddress->Utils.Dict.dangerouslyGetNonOption(address->Address.toString) {
-  | Some(currentName) if currentName != name =>
-    let logger = Logging.createChild(
-      ~params={
-        "address": address->Address.toString,
-        "existingContract": currentName,
-        "newContract": name,
-      },
-    )
-    AddressRegisteredForMultipleContracts({
-      address,
-      names: [currentName, name],
-    })->ErrorHandling.mkLogAndRaise(~msg="Address registered for multiple contracts", ~logger)
-  | _ => ()
-  }
-  map.nameByAddress->Js.Dict.set(address->Address.toString, name)
-
-  let oldAddresses =
-    map.addressesByName
-    ->Utils.Dict.dangerouslyGetNonOption(name)
-    ->Belt.Option.getWithDefault(Belt.Set.String.empty)
-  let newAddresses = oldAddresses->Belt.Set.String.add(address->Address.toString)
-  map.addressesByName->Js.Dict.set(name, newAddresses)
-}
-
-let getAddresses = (map: mapping, name: string) => {
-  map.addressesByName->Utils.Dict.dangerouslyGetNonOption(name)
-}
-
-let getName = (map: mapping, address: string) => {
-  map.nameByAddress->Utils.Dict.dangerouslyGetNonOption(address)
-}
-
-let make = () => {
-  nameByAddress: Js.Dict.empty(),
-  addressesByName: Js.Dict.empty(),
-}
-
-let getContractNameFromAddress = (mapping, ~contractAddress: Address.t): option<contractName> => {
-  mapping->getName(contractAddress->Address.toString)
-}
-
-let stringsToAddresses: array<string> => array<Address.t> = Utils.magic
-let keyValStringToAddress: array<(string, string)> => array<(Address.t, string)> = Utils.magic
-
-let getAddressesFromContractName = (mapping, ~contractName) => {
-  switch mapping->getAddresses(contractName) {
-  | Some(addresses) => addresses
-  | None => Belt.Set.String.empty
-  }
-  ->Belt.Set.String.toArray
-  ->stringsToAddresses
-}
-
-let getAllAddresses = (mapping: mapping) => {
-  mapping.nameByAddress->Js.Dict.keys->stringsToAddresses
-}
-
-let copy = (mapping: mapping) => {
-  {
-    nameByAddress: mapping.nameByAddress->Utils.Dict.shallowCopy,
-    // Since Belt.Set.String.t is immutable, we can simply do shallow copy here
-    addressesByName: mapping.addressesByName->Utils.Dict.shallowCopy,
-  }
-}
-
-let mergeInPlace = (map, ~target) => {
-  map.nameByAddress
-  ->Js.Dict.keys
-  ->Belt.Array.forEach(addr => {
-    let name = map.nameByAddress->Js.Dict.unsafeGet(addr)
-    target->addAddress(~address=addr->Address.unsafeFromString, ~name)
-  })
-}
-
-let fromArray = (nameAddrTuples: array<(Address.t, string)>) => {
-  let m = make()
-  nameAddrTuples->Belt.Array.forEach(((address, name)) => m->addAddress(~name, ~address))
-  m
-}
-
-/**
-Creates a new mapping from the previous without the addresses passed in as "addressesToRemove"
-*/
-let removeAddresses = (mapping: mapping, ~addressesToRemove: array<Address.t>) => {
-  switch addressesToRemove {
-  | [] => mapping
-  | _ =>
-    mapping.nameByAddress
-    ->Js.Dict.entries
-    ->Belt.Array.keep(((addr, _name)) => {
-      let shouldRemove = addressesToRemove->Utils.Array.includes(addr->Utils.magic)
-      !shouldRemove
-    })
-    ->keyValStringToAddress
-    ->fromArray
-  }
-}
-
-let addressCount = (mapping: mapping) => mapping.nameByAddress->Js.Dict.keys->Belt.Array.length
-
-let isEmpty = (mapping: mapping) => mapping->addressCount == 0