envio/src/sources/EventRouter.res.mjs

A latency and sync speed optimized, developer friendly blockchain data indexer.

// Generated by ReScript, PLEASE EDIT WITH CARE

import * as ChainMap from "../ChainMap.res.mjs";
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";
import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";

let EventDuplicate = /* @__PURE__ */Primitive_exceptions.create("EventRouter.EventDuplicate");

let WildcardCollision = /* @__PURE__ */Primitive_exceptions.create("EventRouter.WildcardCollision");

function empty() {
  return {
    wildcard: undefined,
    byContractName: {}
  };
}

function addOrThrow(group, event, contractName, isWildcard) {
  let wildcard = group.wildcard;
  let byContractName = group.byContractName;
  let match = byContractName[contractName];
  if (match !== undefined) {
    throw {
      RE_EXN_ID: EventDuplicate,
      Error: new Error()
    };
  }
  if (isWildcard && Stdlib_Option.isSome(wildcard)) {
    throw {
      RE_EXN_ID: WildcardCollision,
      Error: new Error()
    };
  }
  if (isWildcard) {
    group.wildcard = Primitive_option.some(event);
  }
  byContractName[contractName] = event;
}

function get(group, contractAddress, blockNumber, indexingAddresses) {
  let wildcard = group.wildcard;
  let indexingContract = indexingAddresses[contractAddress];
  if (indexingContract === undefined) {
    return wildcard;
  }
  if (indexingContract.effectiveStartBlock > blockNumber) {
    return;
  }
  let event = group.byContractName[indexingContract.contractName];
  if (event !== undefined) {
    return event;
  } else {
    return wildcard;
  }
}

let Group = {
  empty: empty,
  addOrThrow: addOrThrow,
  get: get
};

function empty$1() {
  return {};
}

function addOrThrow$1(router, eventId, event, contractName, isWildcard, eventName, chain) {
  let group = router[eventId];
  let group$1;
  if (group !== undefined) {
    group$1 = group;
  } else {
    let group$2 = {
      wildcard: undefined,
      byContractName: {}
    };
    router[eventId] = group$2;
    group$1 = group$2;
  }
  try {
    return addOrThrow(group$1, event, contractName, isWildcard);
  } catch (raw_exn) {
    let exn = Primitive_exceptions.internalToException(raw_exn);
    if (exn.RE_EXN_ID === EventDuplicate) {
      return Stdlib_JsError.throwWithMessage(`Duplicate event detected: ` + eventName + ` for contract ` + contractName + ` on chain ` + ChainMap.Chain.toString(chain));
    }
    if (exn.RE_EXN_ID === WildcardCollision) {
      return Stdlib_JsError.throwWithMessage(`Another event is already registered with the same signature that would interfer with wildcard filtering: ` + eventName + ` for contract ` + contractName + ` on chain ` + ChainMap.Chain.toString(chain));
    }
    throw exn;
  }
}

function get$1(router, tag, contractAddress, blockNumber, indexingAddresses) {
  let group = router[tag];
  if (group !== undefined) {
    return get(group, contractAddress, blockNumber, indexingAddresses);
  }
}

function getEvmEventId(sighash, topicCount) {
  return sighash + "_" + topicCount.toString();
}

function fromEvmEventModsOrThrow(events, chain) {
  let router = {};
  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,
  Group,
  empty$1 as empty,
  addOrThrow$1 as addOrThrow,
  get$1 as get,
  getEvmEventId,
  fromEvmEventModsOrThrow,
  getSvmEventId,
  fromSvmEventConfigsOrThrow,
}
/* ChainMap Not a pure module */