envio 3.13.0 → 3.14.0-subgraph

package/src/db/InternalTable.res.mjs

@@ -133,12 +133,15 @@ function $$delete(sql, pgSchema, keys, chainIdModeOpt) {
   ], {prepare: true});
 }
 
-function makeGetRowsQuery(pgSchema) {
+function makeGetRowsQuery(pgSchema, onlyConfigOpt) {
+  let onlyConfig = onlyConfigOpt !== undefined ? onlyConfigOpt : false;
   return `SELECT "chain_id" as "chainId",
 "address" as "address",
 "contract_id" as "contractId",
 "registration_block" as "registrationBlock"
-FROM "` + pgSchema + `"."` + table$1.tableName + `";`;
+FROM "` + pgSchema + `"."` + table$1.tableName + `"` + (
+    onlyConfig ? ` WHERE "registration_block" = ` + AddressRows.configRegistrationBlock.toString() : ""
+  ) + `;`;
 }
 
 let EnvioAddresses = {
@@ -264,6 +267,31 @@ WHERE "` + "id" + `" = $2
   AND "` + "ready_at" + `" IS NULL;`;
 }
 
+async function readStoredChains(sql, pgSchema) {
+  let match = await Promise.all([
+    sql.unsafe(`SELECT "` + "id" + `" as "id",
+"` + "ecosystem" + `" as "ecosystem",
+"` + "start_block" + `" as "startBlock",
+"` + "end_block" + `" as "endBlock",
+"` + "max_reorg_depth" + `" as "maxReorgDepth"
+FROM "` + pgSchema + `"."` + table$2.tableName + `";`),
+    sql.unsafe(makeGetRowsQuery(pgSchema, true))
+  ]);
+  let configAddressesByChain = {};
+  match[1].forEach(addressRow => Utils.Dict.push(configAddressesByChain, ChainId.toString(ChainId.normalizeOrThrow(addressRow.chainId)), addressRow));
+  return match[0].map(row => {
+    let id = ChainId.normalizeOrThrow(row.id);
+    return {
+      id: id,
+      ecosystem: row.ecosystem,
+      startBlock: row.startBlock,
+      endBlock: Primitive_option.fromNull(row.endBlock),
+      maxReorgDepth: row.maxReorgDepth,
+      configAddresses: Stdlib_Option.getOr(configAddressesByChain[ChainId.toString(id)], [])
+    };
+  });
+}
+
 function makeGetInitialStateQuery(pgSchema) {
   return `SELECT "` + "id" + `" as "id",
 "` + "start_block" + `" as "startBlock",
@@ -282,7 +310,7 @@ FROM "` + pgSchema + `"."` + table$2.tableName + `";`;
 async function getInitialState(sql, pgSchema) {
   let match = await Promise.all([
     sql.unsafe(makeGetInitialStateQuery(pgSchema)),
-    sql.unsafe(makeGetRowsQuery(pgSchema))
+    sql.unsafe(makeGetRowsQuery(pgSchema, undefined))
   ]);
   let addressRowsByChainId = AddressRows.group(match[1]);
   return match[0].map(rawInitialState => {
@@ -384,6 +412,7 @@ let Chains = {
   metaFields: metaFields,
   makeMetaFieldsUpdateQuery: makeMetaFieldsUpdateQuery,
   makeSetReadyAtQuery: makeSetReadyAtQuery,
+  readStoredChains: readStoredChains,
   makeGetInitialStateQuery: makeGetInitialStateQuery,
   getInitialState: getInitialState,
   blockTimeToDb: blockTimeToDb,

package/src/db/Table.res

@@ -454,6 +454,7 @@ type sqlParams<'entity> = {
   quotedNonPrimaryFieldNames: array<string>,
   arrayFieldTypes: array<string>,
   byteaColumnIndexes: array<int>,
+  booleanArrayColumnIndexes: array<int>,
   hasArrayField: bool,
 }
 
@@ -464,6 +465,10 @@ let toSqlParams = (table: table, ~schema, ~pgSchema, ~chainIdMode: ChainId.mode=
   // Positions of the bytea columns among the unnest parameters, which the
   // caller binds as array literals (see `Utils.Bytes.toPgArrayLiteral`).
   let byteaColumnIndexes = []
+  // postgres binds a JS array of booleans as a single `boolean`, whatever the
+  // column (https://github.com/porsager/postgres/issues/471), so the VALUES
+  // insert binds these columns as integer arrays and casts them back.
+  let booleanArrayColumnIndexes = []
   let hasArrayField = ref(false)
 
   let dbSchema: S.t<dict<unknown>> = S.schema(s =>
@@ -499,6 +504,10 @@ let toSqlParams = (table: table, ~schema, ~pgSchema, ~chainIdMode: ChainId.mode=
         | None => throw(NonExistingTableField(location))
         }
         switch field {
+        | Field({isArray: true, fieldType: Boolean}) => {
+            hasArrayField := true
+            booleanArrayColumnIndexes->Array.push(arrayFieldTypes->Array.length)->ignore
+          }
         | Field({isArray: true}) => hasArrayField := true
         | Field({fieldType: Bytea}) =>
           byteaColumnIndexes->Array.push(arrayFieldTypes->Array.length)->ignore
@@ -554,6 +563,7 @@ let toSqlParams = (table: table, ~schema, ~pgSchema, ~chainIdMode: ChainId.mode=
     quotedNonPrimaryFieldNames,
     arrayFieldTypes,
     byteaColumnIndexes,
+    booleanArrayColumnIndexes,
     hasArrayField: hasArrayField.contents,
   }
 }

package/src/db/Table.res.mjs

@@ -384,6 +384,7 @@ function toSqlParams(table, schema, pgSchema, chainIdModeOpt) {
   let quotedNonPrimaryFieldNames = [];
   let arrayFieldTypes = [];
   let byteaColumnIndexes = [];
+  let booleanArrayColumnIndexes = [];
   let hasArrayField = {
     contents: false
   };
@@ -441,11 +442,20 @@ function toSqlParams(table, schema, pgSchema, chainIdModeOpt) {
       }
       if (field$1.TAG === "Field") {
         let match = field$1._0;
-        if (match.isArray) {
-          hasArrayField.contents = true;
+        let match$1 = match.fieldType;
+        let exit = 0;
+        if (typeof match$1 !== "object" && match$1 === "Boolean") {
+          if (match.isArray) {
+            hasArrayField.contents = true;
+            booleanArrayColumnIndexes.push(arrayFieldTypes.length);
+          }
         } else {
-          let tmp = match.fieldType;
-          if (typeof tmp !== "object" && tmp === "Bytea") {
+          exit = 1;
+        }
+        if (exit === 1) {
+          if (match.isArray) {
+            hasArrayField.contents = true;
+          } else if (typeof match$1 !== "object" && match$1 === "Bytea") {
             byteaColumnIndexes.push(arrayFieldTypes.length);
           }
         }
@@ -459,20 +469,20 @@ function toSqlParams(table, schema, pgSchema, chainIdModeOpt) {
           quotedNonPrimaryFieldNames.push(quotedDbName);
         }
       }
-      let tmp$1;
+      let tmp;
       if (field$1.TAG === "Field") {
         let f = field$1._0;
         let pgFieldType = getPgFieldType(f.fieldType, pgSchema, true, false, f.isNullable, chainIdMode);
-        let match$1 = f.fieldType;
-        tmp$1 = typeof match$1 !== "object" ? (
-            match$1 === "Boolean" ? "INTEGER" + `[]::` + pgFieldType : pgFieldType
+        let match$2 = f.fieldType;
+        tmp = typeof match$2 !== "object" ? (
+            match$2 === "Boolean" ? "INTEGER" + `[]::` + pgFieldType : pgFieldType
           ) : (
-            match$1.type === "Enum" ? "TEXT" + `[]::` + pgFieldType : pgFieldType
+            match$2.type === "Enum" ? "TEXT" + `[]::` + pgFieldType : pgFieldType
           );
       } else {
-        tmp$1 = "TEXT[]";
+        tmp = "TEXT[]";
       }
-      arrayFieldTypes.push(tmp$1);
+      arrayFieldTypes.push(tmp);
       dict[location] = s.m(coerceSchema(param.schema));
     });
     return dict;
@@ -483,6 +493,7 @@ function toSqlParams(table, schema, pgSchema, chainIdModeOpt) {
     quotedNonPrimaryFieldNames: quotedNonPrimaryFieldNames,
     arrayFieldTypes: arrayFieldTypes,
     byteaColumnIndexes: byteaColumnIndexes,
+    booleanArrayColumnIndexes: booleanArrayColumnIndexes,
     hasArrayField: hasArrayField.contents
   };
 }

package/src/sources/FuelHyperSync.res

@@ -1,5 +1,6 @@
 type logsQueryPage = {
   items: array<FuelHyperSyncClient.EventItems.item>,
+  rejectedLogData: array<FuelHyperSyncClient.EventItems.rejectedLogData>,
   // Blocks referenced by `items`, one per height.
   nextBlock: int,
   archiveHeight: int,
@@ -72,6 +73,7 @@ module GetLogs = {
     }
     {
       items: res.items,
+      rejectedLogData: res.rejectedLogData,
       nextBlock: res.nextBlock,
       archiveHeight: res.archiveHeight->Option.getOr(0), // TODO: FIXME: Shouldn't have a default here
       blockStore,

package/src/sources/FuelHyperSync.res.mjs

@@ -64,6 +64,7 @@ async function query(client, fromBlock, toBlock, registrationIndexes, addressSet
   }
   return {
     items: res.items,
+    rejectedLogData: res.rejectedLogData,
     nextBlock: res.nextBlock,
     archiveHeight: Stdlib_Option.getOr(res.archiveHeight, 0),
     blockStore: match[1]

package/src/sources/FuelHyperSync.resi

@@ -1,5 +1,6 @@
 type logsQueryPage = {
   items: array<FuelHyperSyncClient.EventItems.item>,
+  rejectedLogData: array<FuelHyperSyncClient.EventItems.rejectedLogData>,
   nextBlock: int,
   archiveHeight: int,
   // Page store owning this page's raw blocks (built on the Rust side); its ids

package/src/sources/FuelHyperSyncClient.res

@@ -27,6 +27,9 @@ module Registration = {
     kind: kind,
     // The LogData `rb` value as a decimal string; absent for other kinds.
     logId?: string,
+    // The contract's Fuel ABI, which LogData receipts are decoded against in
+    // Rust; absent for other kinds.
+    abi?: JSON.t,
   }
 
   let fromOnEventRegistrations = (
@@ -35,12 +38,12 @@ module Registration = {
     onEventRegistrations->Array.map(reg => {
       let eventConfig =
         reg.eventConfig->(Utils.magic: Internal.eventConfig => Internal.fuelEventConfig)
-      let (kind, logId) = switch eventConfig.kind {
-      | LogData({logId}) => (LogData, Some(logId))
-      | Mint => (Mint, None)
-      | Burn => (Burn, None)
-      | Transfer => (Transfer, None)
-      | Call => (Call, None)
+      let (kind, logId, abi) = switch eventConfig.kind {
+      | LogData({logId, abi}) => (LogData, Some(logId), Some(abi))
+      | Mint => (Mint, None, None)
+      | Burn => (Burn, None, None)
+      | Transfer => (Transfer, None, None)
+      | Call => (Call, None, None)
       }
       {
         index: reg.index,
@@ -50,6 +53,7 @@ module Registration = {
         startBlock: reg.startBlock,
         kind,
         ?logId,
+        ?abi,
       }
     })
 }
@@ -70,7 +74,8 @@ module EventItems = {
   }
 
   // One routed receipt with its kind-specific columns flattened: LogData
-  // carries `data` (decoded here in JS), Mint/Burn carry `val`/`subId`,
+  // carries `params` decoded against the ABI (a receipt its logged type
+  // rejects is dropped in Rust), Mint/Burn carry `val`/`subId`,
   // Transfer/TransferOut/Call carry `amount`/`assetId`/`to` (TransferOut's
   // wallet recipient normalised into `to`).
   type item = {
@@ -79,7 +84,7 @@ module EventItems = {
     txId: string,
     blockHeight: int,
     srcAddress: Address.t,
-    data?: string,
+    params?: Internal.eventParams,
     subId?: string,
     val?: bigint,
     amount?: bigint,
@@ -87,10 +92,22 @@ module EventItems = {
     to?: string,
   }
 
+  // The page's first LogData receipt a contract-bound registration's ABI
+  // rejected, with how many it rejected. The receipts themselves are dropped.
+  type rejectedLogData = {
+    onEventRegistrationIndex: int,
+    blockHeight: int,
+    receiptIndex: int,
+    txId: string,
+    dataLength: int,
+    count: int,
+  }
+
   type response = {
     archiveHeight: option<int>,
     nextBlock: int,
     items: array<item>,
+    rejectedLogData: array<rejectedLogData>,
   }
 }
 

package/src/sources/FuelHyperSyncClient.res.mjs

@@ -13,24 +13,28 @@ function fromOnEventRegistrations(onEventRegistrations) {
         case "Mint" :
           match$1 = [
             "Mint",
+            undefined,
             undefined
           ];
           break;
         case "Burn" :
           match$1 = [
             "Burn",
+            undefined,
             undefined
           ];
           break;
         case "Transfer" :
           match$1 = [
             "Transfer",
+            undefined,
             undefined
           ];
           break;
         case "Call" :
           match$1 = [
             "Call",
+            undefined,
             undefined
           ];
           break;
@@ -38,7 +42,8 @@ function fromOnEventRegistrations(onEventRegistrations) {
     } else {
       match$1 = [
         "LogData",
-        match.logId
+        match.logId,
+        match.abi
       ];
     }
     return {
@@ -48,7 +53,8 @@ function fromOnEventRegistrations(onEventRegistrations) {
       isWildcard: reg.isWildcard,
       startBlock: reg.startBlock,
       kind: match$1[0],
-      logId: match$1[1]
+      logId: match$1[1],
+      abi: match$1[2]
     };
   });
 }

package/src/sources/FuelHyperSyncSource.res

@@ -16,6 +16,9 @@ let make = ({chainId, endpointUrl, apiToken, onEventRegistrations, addressStore}
   // Per source, so one rejected token is reported once rather than on every
   // height retry for the life of the process.
   let unauthorizedWarned = ref(false)
+  // Registration indexes already warned about undecodable LogData — a stale
+  // ABI rejects every receipt, so one line per event is enough.
+  let rejectedLogDataWarned = Utils.Set.make()
 
   let apiToken = apiToken->HyperSync.requireApiToken
 
@@ -106,6 +109,24 @@ let make = ({chainId, endpointUrl, apiToken, onEventRegistrations, addressStore}
 
     let parsingTimeRef = Performance.now()
 
+    pageUnsafe.rejectedLogData->Array.forEach(rejected => {
+      if !(rejectedLogDataWarned->Utils.Set.has(rejected.onEventRegistrationIndex)) {
+        rejectedLogDataWarned->Utils.Set.add(rejected.onEventRegistrationIndex)->ignore
+        let eventConfig = (
+          onEventRegistrations->Array.getUnsafe(rejected.onEventRegistrationIndex)
+        ).eventConfig
+        logger->Logging.childWarn({
+          "msg": `Skipped ${eventConfig.contractName}.${eventConfig.name} LogData receipts whose data doesn't decode against the contract ABI. Check that the ABI matches the deployed contract.`,
+          "chainId": chainId,
+          "blockNumber": rejected.blockHeight,
+          "logIndex": rejected.receiptIndex,
+          "txId": rejected.txId,
+          "dataLength": rejected.dataLength,
+          "skippedInPage": rejected.count,
+        })
+      }
+    })
+
     let parsedQueueItems = pageUnsafe.items->Array.map(item => {
       // Routing happened in Rust; the item references its registration by
       // chain-scoped index.
@@ -116,24 +137,8 @@ let make = ({chainId, endpointUrl, apiToken, onEventRegistrations, addressStore}
         )
 
       let params = switch eventConfig.kind {
-      | LogData({decode}) =>
-        // Kind-required columns are validated present in Rust before the item
-        // crosses the boundary.
-        let data = item.data->Option.getOr("")
-        try decode(data) catch {
-        | exn => {
-            let params = {
-              "chainId": chainId,
-              "blockNumber": item.blockHeight,
-              "logIndex": item.receiptIndex,
-            }
-            let logger = Logging.createChildFrom(~logger, ~params)
-            exn->ErrorHandling.mkLogAndRaise(
-              ~msg="Failed to decode Fuel LogData receipt, please double check your ABI.",
-              ~logger,
-            )
-          }
-        }
+      // Rust only routes a LogData receipt once its data decoded.
+      | LogData(_) => item.params->Option.getUnsafe
       | Mint | Burn =>
         (
           {
@@ -213,10 +218,7 @@ let make = ({chainId, endpointUrl, apiToken, onEventRegistrations, addressStore}
       let timerRef = Performance.now()
       let height = try await client->FuelHyperSyncClient.getHeight catch {
       | exn =>
-        exn->HyperSync.rethrowLoggingUnauthorized(
-          ~warned=unauthorizedWarned,
-          ~product="HyperFuel",
-        )
+        exn->HyperSync.rethrowLoggingUnauthorized(~warned=unauthorizedWarned, ~product="HyperFuel")
       }
       let seconds = timerRef->Performance.secondsSince
       {height, requestStats: [{method: "getHeight", seconds}]}

package/src/sources/FuelHyperSyncSource.res.mjs

@@ -18,6 +18,7 @@ function make(param) {
   let unauthorizedWarned = {
     contents: false
   };
+  let rejectedLogDataWarned = new Set();
   let apiToken = HyperSync.requireApiToken(param.apiToken);
   let client;
   try {
@@ -82,6 +83,22 @@ function make(param) {
     let knownHeight$1 = pageUnsafe.archiveHeight;
     let heighestBlockQueried = pageUnsafe.nextBlock - 1 | 0;
     let parsingTimeRef = Performance.now();
+    pageUnsafe.rejectedLogData.forEach(rejected => {
+      if (rejectedLogDataWarned.has(rejected.onEventRegistrationIndex)) {
+        return;
+      }
+      rejectedLogDataWarned.add(rejected.onEventRegistrationIndex);
+      let eventConfig = onEventRegistrations[rejected.onEventRegistrationIndex].eventConfig;
+      Logging.childWarn(logger, {
+        msg: `Skipped ` + eventConfig.contractName + `.` + eventConfig.name + ` LogData receipts whose data doesn't decode against the contract ABI. Check that the ABI matches the deployed contract.`,
+        chainId: chainId,
+        blockNumber: rejected.blockHeight,
+        logIndex: rejected.receiptIndex,
+        txId: rejected.txId,
+        dataLength: rejected.dataLength,
+        skippedInPage: rejected.count
+      });
+    });
     let parsedQueueItems = pageUnsafe.items.map(item => {
       let onEventRegistration = onEventRegistrations[item.onEventRegistrationIndex];
       let eventConfig = onEventRegistration.eventConfig;
@@ -100,19 +117,7 @@ function make(param) {
             break;
         }
       } else {
-        let data = Stdlib_Option.getOr(item.data, "");
-        try {
-          params = match.decode(data);
-        } catch (raw_exn) {
-          let exn = Primitive_exceptions.internalToException(raw_exn);
-          let params$1 = {
-            chainId: chainId,
-            blockNumber: item.blockHeight,
-            logIndex: item.receiptIndex
-          };
-          let logger$1 = Logging.createChildFrom(logger, params$1);
-          params = ErrorHandling.mkLogAndRaise(logger$1, "Failed to decode Fuel LogData receipt, please double check your ABI.", exn);
-        }
+        params = item.params;
       }
       switch (exit) {
         case 1 :

package/src/subgraph/abi-types.ts

@@ -0,0 +1,63 @@
+/**
+ * Contract-call signatures and ABI type lists as graph codegen writes them.
+ * Free of envio imports: the graph-ts shim reads them too.
+ */
+
+export type ParsedSignature = {
+  name: string;
+  inputs: string;
+  outputs: string;
+};
+
+/**
+ * graph codegen emits `"balanceOf(address):(uint256)"`. Types only, no names —
+ * which is all `parseAbiParameters` needs.
+ */
+export function parseSignature(signature: string): ParsedSignature {
+  const open = signature.indexOf("(");
+  if (open === -1) {
+    throw new Error(`Unreadable contract call signature "${signature}"`);
+  }
+  const name = signature.slice(0, open);
+
+  let depth = 0;
+  let close = -1;
+  for (let index = open; index < signature.length; index++) {
+    const char = signature[index];
+    if (char === "(") depth++;
+    if (char === ")") {
+      depth--;
+      if (depth === 0) {
+        close = index;
+        break;
+      }
+    }
+  }
+  if (close === -1) {
+    throw new Error(`Unreadable contract call signature "${signature}"`);
+  }
+
+  const inputs = signature.slice(open + 1, close);
+  const rest = signature.slice(close + 1).replace(/^:/, "");
+  const outputs = rest.startsWith("(") ? rest.slice(1, -1) : rest;
+
+  return { name, inputs, outputs };
+}
+
+/** `address,(uint256,bytes)` → `["address", "(uint256,bytes)"]`. */
+export function splitTypes(list: string): string[] {
+  const types: string[] = [];
+  let depth = 0;
+  let start = 0;
+  for (let index = 0; index < list.length; index++) {
+    const char = list[index];
+    if (char === "(") depth++;
+    else if (char === ")") depth--;
+    else if (char === "," && depth === 0) {
+      types.push(list.slice(start, index));
+      start = index + 1;
+    }
+  }
+  if (list.length > 0) types.push(list.slice(start));
+  return types;
+}

package/src/subgraph/assemblyscript.ts

@@ -0,0 +1,85 @@
+/**
+ * The runtime half of `packages/cli/src/subgraph/assemblyscript.rs`, which
+ * rewrites every arithmetic and comparison operator in a mapping into a call
+ * on `OPERATORS_HELPER`, every `changetype<Foo>(x)` into one to `RETAG_HELPER`,
+ * and exports each handler's event class as `EVENT_CLASSES_EXPORT`. The names
+ * are shared with that file.
+ */
+
+export const OPERATORS_HELPER = "__envio_op";
+export const RETAG_HELPER = "__envio_retag";
+export const EVENT_CLASSES_EXPORT = "__envio_event_classes";
+
+/**
+ * AssemblyScript divides two integers as integers; this truncates only when
+ * both operands really are integers and otherwise divides as before — an `f64`
+ * divides as a float in AssemblyScript too.
+ */
+export function integerDivision(a: unknown, b: unknown): unknown {
+  const left = typeof a === "object" && a !== null ? (a as any).valueOf() : a;
+  const right = typeof b === "object" && b !== null ? (b as any).valueOf() : b;
+
+  const integral = (v: unknown) =>
+    typeof v === "bigint" || (typeof v === "number" && Number.isInteger(v));
+  if (integral(left) && integral(right)) {
+    // Only i64 / i64 stays 64-bit; anything narrower is an i32 in AssemblyScript
+    // and must come back as a number, or the bigint spreads through every
+    // arithmetic that follows.
+    if (typeof left === "bigint" && typeof right === "bigint") {
+      return left / right;
+    }
+    return Math.trunc(Number(left) / Number(right));
+  }
+  return (left as number) / (right as number);
+}
+
+/** The graph-ts operator overload `value` declares under `method`, if any. */
+function overload(value: unknown, method: string): Function | undefined {
+  if (!isObject(value)) return undefined;
+  const fn = (value as Record<string, unknown>)[method];
+  return typeof fn === "function" ? fn : undefined;
+}
+
+function isObject(value: unknown): boolean {
+  return value !== null && typeof value === "object";
+}
+
+// Both operands are objects wherever AssemblyScript picks the overload — it
+// doesn't compile `BigInt < i32` — so a primitive on either side is left to
+// JavaScript, which reads the object through `valueOf`.
+const binary =
+  (method: string, fallback: (a: any, b: any) => unknown) =>
+  (a: unknown, b: unknown): unknown => {
+    const declared = isObject(b) ? overload(a, method) : undefined;
+    return declared ? declared.call(a, b) : fallback(a, b);
+  };
+
+// Against null AssemblyScript compares the reference, overload or not.
+const equals = (a: unknown, b: unknown): boolean => {
+  const declared = isObject(b) ? overload(a, "equals") : undefined;
+  return declared ? (declared.call(a, b) as boolean) : a == b;
+};
+
+/**
+ * graph-ts overloads the arithmetic and comparison operators on `BigInt`,
+ * `BigDecimal` and `ByteArray`, and AssemblyScript calls the overload: a
+ * JavaScript operator would coerce them, or compare their identity — so
+ * `address == ZERO_ADDRESS` would always be false.
+ */
+export const operators = {
+  add: binary("plus", (a, b) => a + b),
+  sub: binary("minus", (a, b) => a - b),
+  mul: binary("times", (a, b) => a * b),
+  div: binary("div", integerDivision),
+  rem: binary("mod", (a, b) => a % b),
+  eq: equals,
+  ne: (a: unknown, b: unknown) => !equals(a, b),
+  lt: binary("lt", (a, b) => a < b),
+  le: binary("le", (a, b) => a <= b),
+  gt: binary("gt", (a, b) => a > b),
+  ge: binary("ge", (a, b) => a >= b),
+  neg: (a: unknown) => {
+    const declared = overload(a, "neg");
+    return declared ? declared.call(a) : -(a as number);
+  },
+};