envio 2.18.0 → 2.19.1

package/index.d.ts

@@ -0,0 +1,144 @@
+export type {
+  logger as Logger,
+  effect as Effect,
+  effectContext as EffectContext,
+  effectArgs as EffectArgs,
+  effectOptions as EffectOptions,
+} from "./src/Envio.gen.ts";
+export type { EffectCaller } from "./src/Types.ts";
+
+import type {
+  effect as Effect,
+  effectArgs as EffectArgs,
+} from "./src/Envio.gen.ts";
+
+import { schema as bigDecimalSchema } from "./src/bindings/BigDecimal.gen.ts";
+import * as Sury from "rescript-schema";
+
+type UnknownToOutput<T> = T extends Sury.Schema<unknown>
+  ? Sury.Output<T>
+  : T extends (...args: any[]) => any
+  ? T
+  : T extends unknown[]
+  ? { [K in keyof T]: UnknownToOutput<T[K]> }
+  : T extends { [k in keyof T]: unknown }
+  ? Flatten<
+      {
+        [k in keyof T as HasUndefined<UnknownToOutput<T[k]>> extends true
+          ? k
+          : never]?: UnknownToOutput<T[k]>;
+      } & {
+        [k in keyof T as HasUndefined<UnknownToOutput<T[k]>> extends true
+          ? never
+          : k]: UnknownToOutput<T[k]>;
+      }
+    >
+  : T;
+
+type UnknownToInput<T> = T extends Sury.Schema<unknown>
+  ? Sury.Input<T>
+  : T extends (...args: any[]) => any
+  ? T
+  : T extends unknown[]
+  ? { [K in keyof T]: UnknownToInput<T[K]> }
+  : T extends { [k in keyof T]: unknown }
+  ? Flatten<
+      {
+        [k in keyof T as HasUndefined<UnknownToInput<T[k]>> extends true
+          ? k
+          : never]?: UnknownToInput<T[k]>;
+      } & {
+        [k in keyof T as HasUndefined<UnknownToInput<T[k]>> extends true
+          ? never
+          : k]: UnknownToInput<T[k]>;
+      }
+    >
+  : T;
+
+type HasUndefined<T> = [T] extends [undefined]
+  ? true
+  : undefined extends T
+  ? true
+  : false;
+
+// Utility to flatten the type into a single object
+type Flatten<T> = T extends object
+  ? { [K in keyof T as T[K] extends never ? never : K]: T[K] }
+  : T;
+
+// All the type gymnastics with generics to be able to
+// define schema without an additional `S.schema` call in TS:
+// createEffect({
+//   input: undefined,
+// })
+// Instead of:
+// createEffect({
+//   input: S.schema(undefined),
+// })
+// Or for objects:
+// createEffect({
+//   input: {
+//     foo: S.string,
+//   },
+// })
+// Instead of:
+// createEffect({
+//   input: S.schema({
+//     foo: S.string,
+//   }),
+// })
+// The behaviour is inspired by Sury code:
+// https://github.com/DZakh/sury/blob/551f8ee32c1af95320936d00c086e5fb337f59fa/packages/sury/src/S.d.ts#L344C1-L355C50
+export function experimental_createEffect<
+  IS,
+  OS,
+  I = UnknownToInput<IS>,
+  O = UnknownToOutput<OS>,
+  // A hack to enforce that the inferred return type
+  // matches the output schema type
+  R extends O = O
+>(
+  options: {
+    /** The name of the effect. Used for logging and debugging. */
+    readonly name: string;
+    /** The input schema of the effect. */
+    readonly input: IS;
+    /** The output schema of the effect. */
+    readonly output: OS;
+  },
+  handler: (args: EffectArgs<I>) => Promise<R>
+): Effect<I, O>;
+
+// Important! Should match the index.js file
+export declare namespace S {
+  export type Output<T> = Sury.Output<T>;
+  export type Input<T> = Sury.Input<T>;
+  export type Schema<Output, Input = unknown> = Sury.Schema<Output, Input>;
+  export const string: typeof Sury.string;
+  export const jsonString: typeof Sury.jsonString;
+  export const boolean: typeof Sury.boolean;
+  export const int32: typeof Sury.int32;
+  export const number: typeof Sury.number;
+  export const bigint: typeof Sury.bigint;
+  export const never: typeof Sury.never;
+  export const union: typeof Sury.union;
+  export const object: typeof Sury.object;
+  // Might change in a near future
+  // export const custom: typeof Sury.custom;
+  // Don't expose recursive for now, since it's too advanced
+  // export const recursive: typeof Sury.recursive;
+  export const transform: typeof Sury.transform;
+  export const refine: typeof Sury.refine;
+  export const schema: typeof Sury.schema;
+  export const record: typeof Sury.record;
+  export const array: typeof Sury.array;
+  export const tuple: typeof Sury.tuple;
+  export const merge: typeof Sury.merge;
+  export const optional: typeof Sury.optional;
+  export const nullable: typeof Sury.nullable;
+  export const bigDecimal: typeof bigDecimalSchema;
+  export const unknown: typeof Sury.unknown;
+  // Nullish type will change in "sury@10"
+  // export const nullish: typeof Sury.nullish;
+  export const assertOrThrow: typeof Sury.assertOrThrow;
+}

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "envio",
-  "version": "v2.18.0",
+  "version": "v2.19.1",
   "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,10 +25,10 @@
   },
   "homepage": "https://envio.dev",
   "optionalDependencies": {
-    "envio-linux-x64": "v2.18.0",
-    "envio-linux-arm64": "v2.18.0",
-    "envio-darwin-x64": "v2.18.0",
-    "envio-darwin-arm64": "v2.18.0"
+    "envio-linux-x64": "v2.19.1",
+    "envio-linux-arm64": "v2.19.1",
+    "envio-darwin-x64": "v2.19.1",
+    "envio-darwin-arm64": "v2.19.1"
   },
   "dependencies": {
     "@envio-dev/hypersync-client": "0.6.3",
@@ -40,6 +41,7 @@
     "evm.schema.json",
     "fuel.schema.json",
     "rescript.json",
+    "index.d.ts",
     "src",
     "!src/**/*.bs.js"
   ]

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/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

@@ -3,6 +3,12 @@
 /* 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

@@ -47,6 +47,7 @@ let one = fromInt(1)
 @send external decimalPlaces: (t, int) => t = "decimalPlaces"
 
 // Serialization
+@genType
 let schema =
   S.string
   ->S.setName("BigDecimal")

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