envio 3.1.1 → 3.2.0

package/src/db/Schema.res

@@ -6,11 +6,11 @@ let make = (tables: array<Table.table>) => {
 
 exception UndefinedEntity(Table.derivedFromField)
 exception UndefinedFieldInEntity(Table.derivedFromField)
-let getDerivedFromFieldName = (schema: t, derivedFromField: Table.derivedFromField) =>
+let getDerivedFromPgFieldName = (schema: t, derivedFromField: Table.derivedFromField) =>
   switch schema->Utils.Dict.dangerouslyGetNonOption(derivedFromField.derivedFromEntity) {
   | Some(entity) =>
     switch entity->Table.getFieldByName(derivedFromField.derivedFromField) {
-    | Some(field) => field->Table.getFieldName->Ok
+    | Some(field) => field->Table.getPgFieldName->Ok
     | None => Error(UndefinedFieldInEntity(derivedFromField)) //Unexpected, schema should be parsed on codegen
     }
   | None => Error(UndefinedEntity(derivedFromField)) //Unexpected, schema should be parsed on codegen

package/src/db/Schema.res.mjs

@@ -14,7 +14,7 @@ let UndefinedEntity = /* @__PURE__ */Primitive_exceptions.create("Schema.Undefin
 
 let UndefinedFieldInEntity = /* @__PURE__ */Primitive_exceptions.create("Schema.UndefinedFieldInEntity");
 
-function getDerivedFromFieldName(schema, derivedFromField) {
+function getDerivedFromPgFieldName(schema, derivedFromField) {
   let entity = schema[derivedFromField.derivedFromEntity];
   if (entity === undefined) {
     return {
@@ -29,7 +29,7 @@ function getDerivedFromFieldName(schema, derivedFromField) {
   if (field !== undefined) {
     return {
       TAG: "Ok",
-      _0: Table.getFieldName(field)
+      _0: Table.getPgFieldName(field)
     };
   } else {
     return {
@@ -46,6 +46,6 @@ export {
   make,
   UndefinedEntity,
   UndefinedFieldInEntity,
-  getDerivedFromFieldName,
+  getDerivedFromPgFieldName,
 }
 /* Table Not a pure module */

package/src/db/Table.res

@@ -44,6 +44,11 @@ type field = {
   linkedEntity: option<string>,
   defaultValue: option<string>,
   description: option<string>,
+  // Override the column name per storage backend (eg when `column_name_format:
+  // snake_case` is configured), while the API keeps using fieldName. The
+  // backends can be configured with different formats, so each gets its own override.
+  postgresDbName: option<string>,
+  clickhouseDbName: option<string>,
 }
 
 type derivedFromField = {
@@ -66,6 +71,8 @@ let mkField = (
   ~isIndex=false,
   ~linkedEntity=?,
   ~description=?,
+  ~postgresDbName=?,
+  ~clickhouseDbName=?,
 ) =>
   {
     fieldName,
@@ -78,6 +85,8 @@ let mkField = (
     linkedEntity,
     defaultValue: default,
     description,
+    postgresDbName,
+    clickhouseDbName,
   }->Field
 
 let mkDerivedFromField = (fieldName, ~derivedFromEntity, ~derivedFromField, ~description=?) =>
@@ -96,12 +105,29 @@ let getUserDefinedFieldName = fieldOrDerived =>
 
 let isLinkedEntityField = field => field.linkedEntity->Option.isSome
 
-let getDbFieldName = field =>
+// The field name exposed to the user-facing APIs (entity records, getWhere,
+// Hasura GraphQL). Entity references get an `_id` suffix since the column
+// stores the referenced entity id.
+let getApiFieldName = field =>
   field->isLinkedEntityField ? field.fieldName ++ "_id" : field.fieldName
 
-let getFieldName = fieldOrDerived =>
+// The actual column name in the storage. Matches the API field name unless
+// the storage is configured with a different column naming.
+let getPgDbFieldName = field =>
+  switch field.postgresDbName {
+  | Some(dbName) => dbName
+  | None => field->getApiFieldName
+  }
+
+let getClickHouseDbFieldName = field =>
+  switch field.clickhouseDbName {
+  | Some(dbName) => dbName
+  | None => field->getApiFieldName
+  }
+
+let getPgFieldName = fieldOrDerived =>
   switch fieldOrDerived {
-  | Field(field) => field->getDbFieldName
+  | Field(field) => field->getPgDbFieldName
   | DerivedFrom({fieldName}) => fieldName
   }
 
@@ -177,10 +203,10 @@ let mkTable = (tableName, ~compositeIndices=[], ~fields, ~description=?) => {
   description,
 }
 
-let getPrimaryKeyFieldNames = table =>
+let getPgPrimaryKeyFieldNames = table =>
   table.fields->Array.filterMap(field =>
     switch field {
-    | Field({isPrimaryKey: true, fieldName}) => Some(fieldName)
+    | Field({isPrimaryKey: true} as field) => Some(field->getPgDbFieldName)
     | _ => None
     }
   )
@@ -193,10 +219,6 @@ let getFields = table =>
     }
   )
 
-let getFieldNames = table => {
-  table->getFields->Array.map(getDbFieldName)
-}
-
 let getNonDefaultFields = table =>
   table.fields->Array.filterMap(field =>
     switch field {
@@ -223,23 +245,82 @@ let getDerivedFromFields = table =>
     }
   )
 
-let getNonDefaultFieldNames = table => {
-  table->getNonDefaultFields->Array.map(getDbFieldName)
-}
-
 let getFieldByName = (table, fieldName) =>
   table.fields->Array.find(field => field->getUserDefinedFieldName === fieldName)
 
 // TODO: Test whether it should be passed via args and match the column type
 
-let getFieldByDbName = (table, dbFieldName) =>
+let getFieldByApiName = (table, apiFieldName) =>
   table.fields->Array.find(field =>
     switch field {
-    | Field(f) => f->getDbFieldName
+    | Field(f) => f->getApiFieldName
     | DerivedFrom({fieldName}) => fieldName
-    } === dbFieldName
+    } === apiFieldName
   )
 
+// Both schema instances are created once per field: rescript-schema compiles
+// and caches operations on the schema instance, so building S.array(fieldSchema)
+// per query would recompile the serializer on every call.
+type queryField = {
+  fieldSchema: S.t<unknown>,
+  // Serializes the values array of an "in" filter
+  arrayFieldSchema: S.t<unknown>,
+  // The Postgres column referenced in load SQL, which only differs from the
+  // API field name keying this entry when column renaming is configured.
+  // Loads are served by Postgres only (ClickHouse is a write-only sink), so
+  // no ClickHouse counterpart is needed here.
+  pgDbFieldName: string,
+}
+let queryFields: table => dict<queryField> = Utils.WeakMap.memoize(table => {
+  let dict = Dict.make()
+  table.fields->Array.forEach(field =>
+    switch field {
+    | Field(field) =>
+      dict->Dict.set(
+        field->getApiFieldName,
+        {
+          fieldSchema: field.fieldSchema,
+          arrayFieldSchema: S.array(field.fieldSchema)->S.toUnknown,
+          pgDbFieldName: field->getPgDbFieldName,
+        },
+      )
+    | DerivedFrom(_) => ()
+    }
+  )
+  dict
+})
+
+// Parses rows into entity objects keyed by API field names (the camelCase
+// record field names are type-level only), reading each value from the
+// row key produced by ~rowFieldName.
+let makeRowsSchema = (table, ~rowFieldName) =>
+  S.array(
+    S.object(s => {
+      let dict = Dict.make()
+      table.fields->Array.forEach(
+        field =>
+          switch field {
+          | Field(field) =>
+            dict->Dict.set(field->getApiFieldName, s.field(field->rowFieldName, field.fieldSchema))
+          | DerivedFrom(_) => ()
+          },
+      )
+      dict
+    })->(Utils.magic: S.t<dict<unknown>> => S.t<unknown>),
+  )
+
+let rowsSchema: table => S.t<array<unknown>> = Utils.WeakMap.memoize(table =>
+  table->makeRowsSchema(~rowFieldName=getApiFieldName)
+)
+
+// Rows loaded from Postgres are keyed by the possibly renamed column names.
+// Lives here rather than in PgStorage because InMemoryStore also parses
+// Postgres rollback rows and can't depend on PgStorage without a module
+// cycle.
+let pgRowsSchema: table => S.t<array<unknown>> = Utils.WeakMap.memoize(table =>
+  table->makeRowsSchema(~rowFieldName=getPgDbFieldName)
+)
+
 exception NonExistingTableField(string)
 
 /*
@@ -250,7 +331,7 @@ let getUnfilteredCompositeIndicesUnsafe = (table): array<array<compositeIndexFie
   table.compositeIndices->Array.map(compositeIndex =>
     compositeIndex->Array.map(indexField => {
       let dbFieldName = switch table->getFieldByName(indexField.fieldName) {
-      | Some(field) => field->getFieldName
+      | Some(field) => field->getPgFieldName
       | None => throw(NonExistingTableField(indexField.fieldName)) //Unexpected should be validated in schema parser
       }
       {fieldName: dbFieldName, direction: indexField.direction}
@@ -276,7 +357,7 @@ let toSqlParams = (table: table, ~schema, ~pgSchema) => {
     switch schema->S.classify {
     | Object({items}) =>
       let dict = Dict.make()
-      items->Belt.Array.forEach(({location, inlinedLocation, schema}) => {
+      items->Array.forEach(({location, schema}) => {
         let rec coerceSchema = schema =>
           switch schema->S.classify {
           | BigInt => Utils.BigInt.schema->S.toUnknown
@@ -300,18 +381,21 @@ let toSqlParams = (table: table, ~schema, ~pgSchema) => {
           | _ => schema
           }
 
-        let field = switch table->getFieldByDbName(location) {
+        let field = switch table->getFieldByApiName(location) {
         | Some(field) => field
         | None => throw(NonExistingTableField(location))
         }
 
+        // Schema locations use API field names, while the SQL references
+        // columns by their possibly renamed db names.
+        let quotedDbName = `"${field->getPgFieldName}"`
         quotedFieldNames
-        ->Array.push(inlinedLocation)
+        ->Array.push(quotedDbName)
         ->ignore
         switch field {
         | Field({isPrimaryKey: false}) =>
           quotedNonPrimaryFieldNames
-          ->Array.push(inlinedLocation)
+          ->Array.push(quotedDbName)
           ->ignore
         | _ => ()
         }
@@ -360,7 +444,7 @@ And maps the fields defined to their actual db name (some have _id suffix)
 let getSingleIndices = (table): array<string> => {
   let indexFields = table.fields->Array.filterMap(field =>
     switch field {
-    | Field(field) if field.isIndex => Some(field->getDbFieldName)
+    | Field(field) if field.isIndex => Some(field->getPgDbFieldName)
     | _ => None
     }
   )

package/src/db/Table.res.mjs

@@ -1,7 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "../Utils.res.mjs";
-import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
@@ -17,7 +16,7 @@ function makeEnumConfig(name, variants) {
   };
 }
 
-function mkField(fieldName, fieldType, fieldSchema, $$default, isArrayOpt, isNullableOpt, isPrimaryKeyOpt, isIndexOpt, linkedEntity, description) {
+function mkField(fieldName, fieldType, fieldSchema, $$default, isArrayOpt, isNullableOpt, isPrimaryKeyOpt, isIndexOpt, linkedEntity, description, postgresDbName, clickhouseDbName) {
   let isArray = isArrayOpt !== undefined ? isArrayOpt : false;
   let isNullable = isNullableOpt !== undefined ? isNullableOpt : false;
   let isPrimaryKey = isPrimaryKeyOpt !== undefined ? isPrimaryKeyOpt : false;
@@ -34,7 +33,9 @@ function mkField(fieldName, fieldType, fieldSchema, $$default, isArrayOpt, isNul
       isIndex: isIndex,
       linkedEntity: linkedEntity,
       defaultValue: $$default,
-      description: description
+      description: description,
+      postgresDbName: postgresDbName,
+      clickhouseDbName: clickhouseDbName
     }
   };
 }
@@ -59,7 +60,7 @@ function isLinkedEntityField(field) {
   return Stdlib_Option.isSome(field.linkedEntity);
 }
 
-function getDbFieldName(field) {
+function getApiFieldName(field) {
   if (Stdlib_Option.isSome(field.linkedEntity)) {
     return field.fieldName + "_id";
   } else {
@@ -67,9 +68,27 @@ function getDbFieldName(field) {
   }
 }
 
-function getFieldName(fieldOrDerived) {
+function getPgDbFieldName(field) {
+  let dbName = field.postgresDbName;
+  if (dbName !== undefined) {
+    return dbName;
+  } else {
+    return getApiFieldName(field);
+  }
+}
+
+function getClickHouseDbFieldName(field) {
+  let dbName = field.clickhouseDbName;
+  if (dbName !== undefined) {
+    return dbName;
+  } else {
+    return getApiFieldName(field);
+  }
+}
+
+function getPgFieldName(fieldOrDerived) {
   if (fieldOrDerived.TAG === "Field") {
-    return getDbFieldName(fieldOrDerived._0);
+    return getPgDbFieldName(fieldOrDerived._0);
   } else {
     return fieldOrDerived._0.fieldName;
   }
@@ -145,14 +164,14 @@ function mkTable(tableName, compositeIndicesOpt, fields, description) {
   };
 }
 
-function getPrimaryKeyFieldNames(table) {
+function getPgPrimaryKeyFieldNames(table) {
   return Stdlib_Array.filterMap(table.fields, field => {
     if (field.TAG !== "Field") {
       return;
     }
-    let match = field._0;
-    if (match.isPrimaryKey) {
-      return match.fieldName;
+    let field$1 = field._0;
+    if (field$1.isPrimaryKey) {
+      return getPgDbFieldName(field$1);
     }
   });
 }
@@ -165,10 +184,6 @@ function getFields(table) {
   });
 }
 
-function getFieldNames(table) {
-  return getFields(table).map(getDbFieldName);
-}
-
 function getNonDefaultFields(table) {
   return Stdlib_Array.filterMap(table.fields, field => {
     if (field.TAG !== "Field") {
@@ -207,22 +222,52 @@ function getDerivedFromFields(table) {
   });
 }
 
-function getNonDefaultFieldNames(table) {
-  return getNonDefaultFields(table).map(getDbFieldName);
-}
-
 function getFieldByName(table, fieldName) {
   return table.fields.find(field => getUserDefinedFieldName(field) === fieldName);
 }
 
-function getFieldByDbName(table, dbFieldName) {
+function getFieldByApiName(table, apiFieldName) {
   return table.fields.find(field => {
     let tmp;
-    tmp = field.TAG === "Field" ? getDbFieldName(field._0) : field._0.fieldName;
-    return tmp === dbFieldName;
+    tmp = field.TAG === "Field" ? getApiFieldName(field._0) : field._0.fieldName;
+    return tmp === apiFieldName;
+  });
+}
+
+let queryFields = Utils.$$WeakMap.memoize(table => {
+  let dict = {};
+  table.fields.forEach(field => {
+    if (field.TAG !== "Field") {
+      return;
+    }
+    let field$1 = field._0;
+    dict[getApiFieldName(field$1)] = {
+      fieldSchema: field$1.fieldSchema,
+      arrayFieldSchema: S$RescriptSchema.array(field$1.fieldSchema),
+      pgDbFieldName: getPgDbFieldName(field$1)
+    };
   });
+  return dict;
+});
+
+function makeRowsSchema(table, rowFieldName) {
+  return S$RescriptSchema.array(S$RescriptSchema.object(s => {
+    let dict = {};
+    table.fields.forEach(field => {
+      if (field.TAG !== "Field") {
+        return;
+      }
+      let field$1 = field._0;
+      dict[getApiFieldName(field$1)] = s.f(rowFieldName(field$1), field$1.fieldSchema);
+    });
+    return dict;
+  }));
 }
 
+let rowsSchema = Utils.$$WeakMap.memoize(table => makeRowsSchema(table, getApiFieldName));
+
+let pgRowsSchema = Utils.$$WeakMap.memoize(table => makeRowsSchema(table, getPgDbFieldName));
+
 let NonExistingTableField = /* @__PURE__ */Primitive_exceptions.create("Table.NonExistingTableField");
 
 function getUnfilteredCompositeIndicesUnsafe(table) {
@@ -230,7 +275,7 @@ function getUnfilteredCompositeIndicesUnsafe(table) {
     let field = getFieldByName(table, indexField.fieldName);
     let dbFieldName;
     if (field !== undefined) {
-      dbFieldName = getFieldName(field);
+      dbFieldName = getPgFieldName(field);
     } else {
       throw {
         RE_EXN_ID: NonExistingTableField,
@@ -261,8 +306,7 @@ function toSqlParams(table, schema, pgSchema) {
       return Stdlib_JsError.throwWithMessage("Failed creating db schema. Expected an object schema for table");
     }
     let dict = {};
-    Belt_Array.forEach(match.items, param => {
-      let inlinedLocation = param.inlinedLocation;
+    match.items.forEach(param => {
       let location = param.location;
       let coerceSchema = schema => {
         let child = schema.t;
@@ -294,7 +338,7 @@ function toSqlParams(table, schema, pgSchema) {
           }
         }
       };
-      let field = getFieldByDbName(table, location);
+      let field = getFieldByApiName(table, location);
       let field$1;
       if (field !== undefined) {
         field$1 = field;
@@ -305,12 +349,13 @@ function toSqlParams(table, schema, pgSchema) {
           Error: new Error()
         };
       }
-      quotedFieldNames.push(inlinedLocation);
+      let quotedDbName = `"` + getPgFieldName(field$1) + `"`;
+      quotedFieldNames.push(quotedDbName);
       if (field$1.TAG === "Field") {
         if (field$1._0.isPrimaryKey) {
           
         } else {
-          quotedNonPrimaryFieldNames.push(inlinedLocation);
+          quotedNonPrimaryFieldNames.push(quotedDbName);
         }
       }
       let tmp;
@@ -347,7 +392,7 @@ function getSingleIndices(table) {
     }
     let field$1 = field._0;
     if (field$1.isIndex) {
-      return getDbFieldName(field$1);
+      return getPgDbFieldName(field$1);
     }
   });
   return Array.from(new Set(Stdlib_Array.filterMap(getUnfilteredCompositeIndicesUnsafe(table), cidx => {
@@ -371,24 +416,28 @@ export {
   mkDerivedFromField,
   getUserDefinedFieldName,
   isLinkedEntityField,
-  getDbFieldName,
-  getFieldName,
+  getApiFieldName,
+  getPgDbFieldName,
+  getClickHouseDbFieldName,
+  getPgFieldName,
   idFieldName,
   getPgFieldType,
   mkTable,
-  getPrimaryKeyFieldNames,
+  getPgPrimaryKeyFieldNames,
   getFields,
-  getFieldNames,
   getNonDefaultFields,
   getLinkedEntityFields,
   getDerivedFromFields,
-  getNonDefaultFieldNames,
   getFieldByName,
-  getFieldByDbName,
+  getFieldByApiName,
+  queryFields,
+  makeRowsSchema,
+  rowsSchema,
+  pgRowsSchema,
   NonExistingTableField,
   getUnfilteredCompositeIndicesUnsafe,
   toSqlParams,
   getSingleIndices,
   getCompositeIndices,
 }
-/* Utils Not a pure module */
+/* queryFields Not a pure module */

package/src/sources/EventRouter.res

@@ -97,14 +97,14 @@ let get = (router: t<'a>, ~tag, ~contractAddress, ~blockNumber, ~indexingAddress
 }
 
 let getEvmEventId = (~sighash, ~topicCount) => {
-  sighash ++ "_" ++ topicCount->Belt.Int.toString
+  sighash ++ "_" ++ topicCount->Int.toString
 }
 
 let fromEvmEventModsOrThrow = (events: array<Internal.evmEventConfig>, ~chain): t<
   Internal.evmEventConfig,
 > => {
   let router = empty()
-  events->Belt.Array.forEach(config => {
+  events->Array.forEach(config => {
     router->addOrThrow(
       config.id,
       config,
@@ -116,3 +116,68 @@ let fromEvmEventModsOrThrow = (events: array<Internal.evmEventConfig>, ~chain):
   })
   router
 }
+
+/** Dispatch key for SVM instructions. `None` matches any instruction in the
+ program (lowest priority). */
+let getSvmEventId = (~programId: SvmTypes.Pubkey.t, ~discriminator: option<string>) =>
+  switch discriminator {
+  | None => programId->SvmTypes.Pubkey.toString ++ "_none"
+  | Some(d) => programId->SvmTypes.Pubkey.toString ++ "_" ++ d
+  }
+
+/** Discriminator byte-lengths declared by a program, sorted descending. The
+ source uses this to probe `(programId, dN)` keys longest-first when routing
+ a returned instruction to a handler — matching the locked Q1 answer. */
+type svmProgramOrdering = {
+  programId: SvmTypes.Pubkey.t,
+  /** Byte lengths in descending order, deduplicated. Includes `0` only when
+   a handler is registered with no discriminator (program-wide match). */
+  byteLengthsDesc: array<int>,
+}
+
+let fromSvmEventConfigsOrThrow = (events: array<Internal.svmInstructionEventConfig>, ~chain): (
+  t<Internal.svmInstructionEventConfig>,
+  array<svmProgramOrdering>,
+) => {
+  let router = empty()
+  events->Array.forEach(config => {
+    // The router tag must include the programId so two programs declaring the
+    // same discriminator coexist. The source-side lookup uses the same shape
+    // via `getSvmEventId(~programId, ~discriminator)`.
+    let routerTag = getSvmEventId(~programId=config.programId, ~discriminator=config.discriminator)
+    router->addOrThrow(
+      routerTag,
+      config,
+      ~contractName=config.contractName,
+      ~eventName=config.name,
+      ~chain,
+      ~isWildcard=config.isWildcard,
+    )
+  })
+
+  // Per-program list of declared discriminator byte lengths, sorted desc.
+  let byProgram: dict<Utils.Set.t<int>> = Dict.make()
+  events->Array.forEach(config => {
+    let key = config.programId->SvmTypes.Pubkey.toString
+    let set = switch byProgram->Utils.Dict.dangerouslyGetNonOption(key) {
+    | Some(s) => s
+    | None =>
+      let s = Utils.Set.make()
+      byProgram->Dict.set(key, s)
+      s
+    }
+    let _ = set->Utils.Set.add(config.discriminatorByteLen)
+  })
+  let ordering =
+    byProgram
+    ->Dict.toArray
+    ->Array.map(((programIdString, lens)) => {
+      let sorted = lens->Utils.Set.toArray->Array.toSorted((a, b) => (b - a)->Int.toFloat)
+      {
+        programId: programIdString->SvmTypes.Pubkey.fromStringUnsafe,
+        byteLengthsDesc: sorted,
+      }
+    })
+
+  (router, ordering)
+}

package/src/sources/EventRouter.res.mjs

@@ -1,7 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as ChainMap from "../ChainMap.res.mjs";
-import * as Belt_Array from "@rescript/runtime/lib/es6/Belt_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
@@ -102,15 +101,56 @@ function get$1(router, tag, contractAddress, blockNumber, indexingAddresses) {
 }
 
 function getEvmEventId(sighash, topicCount) {
-  return sighash + "_" + String(topicCount);
+  return sighash + "_" + topicCount.toString();
 }
 
 function fromEvmEventModsOrThrow(events, chain) {
   let router = {};
-  Belt_Array.forEach(events, config => addOrThrow$1(router, config.id, config, config.contractName, config.isWildcard, config.name, chain));
+  events.forEach(config => addOrThrow$1(router, config.id, config, config.contractName, config.isWildcard, config.name, chain));
   return router;
 }
 
+function getSvmEventId(programId, discriminator) {
+  if (discriminator !== undefined) {
+    return programId + "_" + discriminator;
+  } else {
+    return programId + "_none";
+  }
+}
+
+function fromSvmEventConfigsOrThrow(events, chain) {
+  let router = {};
+  events.forEach(config => {
+    let routerTag = getSvmEventId(config.programId, config.discriminator);
+    addOrThrow$1(router, routerTag, config, config.contractName, config.isWildcard, config.name, chain);
+  });
+  let byProgram = {};
+  events.forEach(config => {
+    let key = config.programId;
+    let s = byProgram[key];
+    let set;
+    if (s !== undefined) {
+      set = Primitive_option.valFromOption(s);
+    } else {
+      let s$1 = new Set();
+      byProgram[key] = s$1;
+      set = s$1;
+    }
+    set.add(config.discriminatorByteLen);
+  });
+  let ordering = Object.entries(byProgram).map(param => {
+    let sorted = Array.from(param[1]).toSorted((a, b) => b - a | 0);
+    return {
+      programId: param[0],
+      byteLengthsDesc: sorted
+    };
+  });
+  return [
+    router,
+    ordering
+  ];
+}
+
 export {
   EventDuplicate,
   WildcardCollision,
@@ -120,5 +160,7 @@ export {
   get$1 as get,
   getEvmEventId,
   fromEvmEventModsOrThrow,
+  getSvmEventId,
+  fromSvmEventConfigsOrThrow,
 }
 /* ChainMap Not a pure module */

package/src/sources/Evm.res

@@ -1,7 +1,3 @@
-@get external getNumber: Internal.eventBlock => int = "number"
-@get external getTimestamp: Internal.eventBlock => int = "timestamp"
-@get external getId: Internal.eventBlock => string = "hash"
-
 let cleanUpRawEventFieldsInPlace: JSON.t => unit = %raw(`fields => {
     delete fields.hash
     delete fields.number
@@ -77,9 +73,6 @@ let ecosystem: Ecosystem.t = {
   blockNumberName: "number",
   blockTimestampName: "timestamp",
   blockHashName: "hash",
-  getNumber,
-  getTimestamp,
-  getId,
   cleanUpRawEventFieldsInPlace,
   onBlockMethodName: "onBlock",
   // EVM filter shape: `{block: {number: {_gte?, _lte?, _every?}}}`.