envio 3.13.0-alpha.0 → 3.13.0

package/src/Supervisor.res.mjs

@@ -19,11 +19,16 @@ import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Child_process from "child_process";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as CrossChainState from "./CrossChainState.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 
 function plan(chainIds, maxConnections) {
-  let workerCount = Primitive_int.min(chainIds.length, maxConnections / 2 | 0);
+  let workerCount = Stdlib_Array.reduce([
+    chainIds.length,
+    maxConnections / 2 | 0,
+    4
+  ], 4, Primitive_int.min);
   if (workerCount < 2) {
     return;
   }
@@ -94,18 +99,42 @@ function readLines(onLine) {
   ];
 }
 
-function fork(worker, workerIndex, holdRealtime, entryPathOpt, pipeOutputOpt, onOutputOpt) {
+function memoryBudgets(workerCount) {
+  return [
+    [
+      "ENVIO_INDEXING_MAX_BUFFER_SIZE",
+      CrossChainState.calculateTargetBufferSize()
+    ],
+    [
+      "ENVIO_IN_MEMORY_OBJECTS_TARGET",
+      Env.inMemoryObjectsTarget | 0
+    ]
+  ].map(param => [
+    param[0],
+    Primitive_int.max(1, Primitive_int.div(param[1], workerCount)).toString()
+  ]);
+}
+
+function fork(worker, workerIndex, workerCount, holdRealtime, isDev, entryPathOpt, pipeOutputOpt, onOutputOpt, onErrorOutputOpt, onSnapshotOpt) {
   let entryPath = entryPathOpt !== undefined ? entryPathOpt : process.argv[1];
   let pipeOutput = pipeOutputOpt !== undefined ? pipeOutputOpt : false;
   let onOutput = onOutputOpt !== undefined ? onOutputOpt : prim => {
       console.log(prim);
     };
+  let onErrorOutput = onErrorOutputOpt !== undefined ? onErrorOutputOpt : prim => {
+      console.error(prim);
+    };
+  let onSnapshot = onSnapshotOpt !== undefined ? onSnapshotOpt : () => {};
   let env = Object.assign({}, Process.env);
   env[Worker.envVar] = S$RescriptSchema.reverseConvertToJsonStringOrThrow({
     chainIds: worker.chainIds,
-    holdRealtime: holdRealtime
+    holdRealtime: holdRealtime,
+    isDev: isDev
   }, Worker.configSchema, undefined);
   env["ENVIO_PG_MAX_CONNECTIONS"] = worker.maxConnections.toString();
+  memoryBudgets(workerCount).forEach(param => {
+    env[param[0]] = param[1];
+  });
   env["LOG_FILE"] = logFilePath(workerIndex, undefined);
   if (pipeOutput && Stdlib_Option.getOr((process.stdout.isTTY == null) ? undefined : Primitive_option.some(process.stdout.isTTY), false)) {
     env["FORCE_COLOR"] = "1";
@@ -127,13 +156,20 @@ function fork(worker, workerIndex, holdRealtime, entryPathOpt, pipeOutputOpt, on
   });
   if (pipeOutput) {
     [
-      child.stdout,
-      child.stderr
-    ].forEach(stream => {
+      [
+        child.stdout,
+        onOutput
+      ],
+      [
+        child.stderr,
+        onErrorOutput
+      ]
+    ].forEach(param => {
+      let stream = param[0];
       if (stream === null) {
         return;
       }
-      let match = readLines(onOutput);
+      let match = readLines(param[1]);
       stream.setEncoding("utf8");
       stream.on("data", match[0]);
       stream.on("end", match[1]);
@@ -149,6 +185,7 @@ function fork(worker, workerIndex, holdRealtime, entryPathOpt, pipeOutputOpt, on
   child.on("message", message => {
     running.snapshot = message.metrics;
     running.runtime = message.runtime;
+    onSnapshot();
   });
   return running;
 }
@@ -183,6 +220,20 @@ function dumpCache(config) {
   });
 }
 
+function classifyExit(code, signal, stopping) {
+  if (stopping) {
+    return "Expected";
+  }
+  if (code === 0) {
+    return "Expected";
+  }
+  if (signal === "SIGTERM") {
+    return "Stopping";
+  } else {
+    return "Failed";
+  }
+}
+
 async function awaitExit(group) {
   let failed = {
     contents: false
@@ -191,30 +242,32 @@ async function awaitExit(group) {
     contents: group.running.length
   };
   await new Promise((resolve, param) => {
-    let onGone = (r, failure) => {
-      if (!r.settled) {
-        r.settled = true;
-        if (failure) {
+    let onGone = (r, ending) => {
+      if (r.settled) {
+        return;
+      }
+      r.settled = true;
+      switch (ending) {
+        case "Expected" :
+          break;
+        case "Stopping" :
+          stop(group);
+          break;
+        case "Failed" :
           failed.contents = true;
-          if (!group.stopping) {
-            stop(group);
-          }
-        }
-        alive.contents = alive.contents - 1 | 0;
-        if (alive.contents === 0) {
-          return resolve();
-        } else {
-          return;
-        }
+          stop(group);
+          break;
+      }
+      alive.contents = alive.contents - 1 | 0;
+      if (alive.contents === 0) {
+        return resolve();
       }
     };
     group.running.forEach(r => {
-      r.child.on("exit", (code, _signal) => onGone(r, !group.stopping && (
-        code === null ? undefined : Primitive_option.some(code)
-      ) !== 0));
+      r.child.on("exit", (code, signal) => onGone(r, classifyExit(code, signal, group.stopping)));
       r.child.on("error", exn => {
         Logging.errorWithExn(exn, label(r.worker) + ` failed to start`);
-        onGone(r, true);
+        onGone(r, "Failed");
       });
     });
   });
@@ -228,29 +281,112 @@ async function awaitExit(group) {
   }
 }
 
-function isRunAtHead(snapshots, workerCount) {
-  if (snapshots.length === workerCount) {
-    return snapshots.every(snapshot => snapshot.hasArrivedAtHead);
+function isRunAtHead(running) {
+  if (Utils.$$Array.notEmpty(running)) {
+    return running.every(r => {
+      if (r.child.connected) {
+        return Stdlib_Option.mapOr(r.snapshot, false, snapshot => snapshot.hasArrivedAtHead);
+      } else {
+        return false;
+      }
+    });
   } else {
     return false;
   }
 }
 
+function releaseIfAtHead(group) {
+  if (group.holdingRealtime && !group.stopping && isRunAtHead(group.running)) {
+    group.holdingRealtime = false;
+    group.running.forEach(r => {
+      r.child.send("release-realtime");
+    });
+    return;
+  }
+}
+
+function configuredChains(config) {
+  return ChainMap.values(config.chainMap).map(chain => {
+    let match = chain.sourceConfig;
+    let tmp;
+    switch (match.TAG) {
+      case "EvmSourceConfig" :
+        tmp = Stdlib_Option.isSome(match.hypersync);
+        break;
+      case "FuelSourceConfig" :
+      case "SvmSourceConfig" :
+        tmp = true;
+        break;
+      case "SimulateSourceConfig" :
+      case "CustomSources" :
+        tmp = false;
+        break;
+    }
+    let block = chain.startBlock;
+    let tmp$1;
+    tmp$1 = block === "latest" ? 0 : block;
+    return {
+      chainId: chain.id,
+      poweredByHyperSync: tmp,
+      firstEventBlockNumber: undefined,
+      latestProcessedBlock: undefined,
+      timestampCaughtUpToHeadOrEndblock: undefined,
+      numEventsProcessed: 0,
+      latestFetchedBlockNumber: 0,
+      knownHeight: 0,
+      numBatchesFetched: 0,
+      startBlock: tmp$1,
+      endBlock: chain.endBlock,
+      numAddresses: 0,
+      addressesByContract: [],
+      isReady: false,
+      sourceBlockNumber: 0,
+      progressBlockNumber: -1,
+      progressLatencyMs: undefined,
+      progressBlockTime: undefined,
+      concurrency: 0,
+      partitionsCount: 0,
+      bufferSize: 0,
+      bufferBlockNumber: -1,
+      idleSeconds: 0,
+      waitingForNewBlockSeconds: 0,
+      queryingSeconds: 0,
+      blockRangeFetchSeconds: 0,
+      blockRangeParseSeconds: 0,
+      blockRangeFetchCount: 0,
+      blockRangeFetchedEvents: 0,
+      blockRangeFetchedBlocks: 0,
+      reorgCount: 0,
+      reorgDetectedBlock: undefined,
+      rollbackTargetBlock: undefined,
+      rateLimitTimeMs: 0,
+      rateLimitResetInMs: undefined
+    };
+  });
+}
+
 async function run(config, workers, reset) {
   let persistence = PgStorage.makePersistenceFromConfig(config, undefined);
   await Persistence.initForRun(persistence, config, reset, config.isDev, false);
   await persistence.storage.close();
   let startTime = new Date();
   let startTimeRef = Performance.now();
-  Logging.info(`Splitting ` + ChainMap.values(config.chainMap).length.toString() + ` chains across ` + workers.length.toString() + ` processes, from a budget of ` + Env.Db.maxConnections.toString() + ` database connections.`);
-  let shouldUseTui = Tui.shouldUse(undefined);
+  Logging.info({
+    msg: "Indexing will be split across multiple processes for faster and more reliable indexing.",
+    chains: ChainMap.values(config.chainMap).length,
+    processes: workers.length,
+    maxConnections: Env.Db.maxConnections
+  });
+  let shouldUseTui = Tui.shouldUse(undefined, undefined);
   let holdRealtime = Persistence.getInitializedState(persistence).chains.some(chain => Stdlib_Option.isNone(chain.timestampCaughtUpToHeadOrEndblock));
   let group = {
-    running: workers.map((worker, workerIndex) => fork(worker, workerIndex, holdRealtime, undefined, shouldUseTui, undefined)),
-    stopping: false
+    running: [],
+    stopping: false,
+    holdingRealtime: holdRealtime
   };
+  group.running = workers.map((worker, workerIndex) => fork(worker, workerIndex, workers.length, holdRealtime, config.isDev, undefined, shouldUseTui, undefined, undefined, () => releaseIfAtHead(group)));
   let reported = () => Stdlib_Array.filterMap(group.running, r => r.snapshot);
-  let merge = snapshots => Metrics.merge(snapshots, startTime, new Date(), Performance.secondsSince(startTimeRef));
+  let merge = snapshots => Metrics.merge(snapshots, startTime, new Date(), Performance.secondsSince(startTimeRef), CrossChainState.calculateTargetBufferSize());
   Server.startServer(() => {
     let snapshots = reported();
     if (snapshots.length !== 0) {
@@ -260,33 +396,20 @@ async function run(config, workers, reset) {
     `worker="` + name(r.worker) + `"`,
     runtime
   ]))), config.isDev);
-  let releaseCheck = {
-    contents: undefined
-  };
-  let stopReleaseCheck = () => {
-    Stdlib_Option.forEach(releaseCheck.contents, prim => {
-      clearInterval(prim);
-    });
-    releaseCheck.contents = undefined;
-  };
-  if (holdRealtime) {
-    releaseCheck.contents = Primitive_option.some(setInterval(() => {
-      if (isRunAtHead(reported(), group.running.length)) {
-        stopReleaseCheck();
-        group.running.forEach(r => {
-          r.child.send("release-realtime");
-        });
-        return Logging.info("Every chain has reached the head. Switching the run to realtime.");
-      }
-    }, 500));
-  }
   if (shouldUseTui) {
-    Tui.start(config, () => merge(reported()));
+    Tui.start(config, () => {
+      let snapshots = reported();
+      if (snapshots.length !== 0) {
+        return merge(snapshots);
+      }
+      let newrecord = {...merge([])};
+      newrecord.chains = configuredChains(config);
+      return newrecord;
+    });
   }
   process.on("SIGTERM", () => stop(group));
   process.on("SIGINT", () => stop(group));
   let outcome = await awaitExit(group);
-  stopReleaseCheck();
   if (outcome === "Finished") {
     if (shouldUseTui) {
       process.on("SIGTERM", () => {
@@ -306,20 +429,27 @@ async function run(config, workers, reset) {
 
 let minConnectionsPerWorker = 2;
 
+let maxWorkers = 4;
+
 export {
   minConnectionsPerWorker,
+  maxWorkers,
   plan,
   planForRun,
   name,
   label,
   logFilePath,
   readLines,
+  memoryBudgets,
   fork,
   stop,
   syncCache,
   dumpCache,
+  classifyExit,
   awaitExit,
   isRunAtHead,
+  releaseIfAtHead,
+  configuredChains,
   run,
 }
 /* Env Not a pure module */

package/src/TestIndexer.res

@@ -254,13 +254,16 @@ let makeInitialState = (
       addressRowsByChain
       ->Utils.Dict.dangerouslyGetNonOption(chainIdStr)
       ->Option.getOr(AddressRows.emptySeedRows())
+    // The pinned startBlock resumes the chain rather than moving its start, so
+    // contract start blocks and onBlock intervals stay what config.yaml says.
+    // https://github.com/enviodev/hyperindex/issues/1656
     {
       Persistence.id: chain,
-      startBlock: processChainConfig.startBlock,
+      startBlock: config.chainMap->ChainMap.get(chain)->Config.startBlockOrZero,
       endBlock: processChainConfig.endBlock,
       sourceBlockNumber: processChainConfig.endBlock->Option.getOr(0),
       maxReorgDepth: 0, // No reorg support in test indexer
-      progressBlockNumber: -1,
+      progressBlockNumber: processChainConfig.startBlock - 1,
       progressBlockTime: None,
       numEventsProcessed: 0.,
       firstEventBlockNumber: None,
@@ -948,7 +951,7 @@ let createTestIndexer = (): t<'processConfig> => {
                 ~exitAfterFirstEventBlock,
                 ~onError=errHandler => {
                   errHandler->ErrorHandling.log
-                  reject(errHandler.exn->Utils.prettifyExn)
+                  reject(errHandler->ErrorHandling.toExn)
                 },
                 // Caught up: resolve the run instead of exiting the process.
                 ~onExit=() => resolve(),

package/src/TestIndexer.res.mjs

@@ -180,10 +180,10 @@ function makeInitialState(config, processConfigChains, addressRowsByChain, contr
     let addressRows = Stdlib_Option.getOr(addressRowsByChain[chainIdStr], AddressRows.emptySeedRows());
     return {
       id: chain,
-      startBlock: processChainConfig.startBlock,
+      startBlock: Config.startBlockOrZero(ChainMap.get(config.chainMap, chain)),
       endBlock: processChainConfig.endBlock,
       maxReorgDepth: 0,
-      progressBlockNumber: -1,
+      progressBlockNumber: processChainConfig.startBlock - 1 | 0,
       progressBlockTime: undefined,
       numEventsProcessed: 0,
       firstEventBlockNumber: undefined,
@@ -641,7 +641,7 @@ function createTestIndexer() {
         await new Promise((resolve, reject) => {
           let indexerState = IndexerState.makeFromDbState(runConfig, persistence, initialState, registrationsByChainId, undefined, undefined, exitAfterFirstEventBlock, undefined, undefined, undefined, errHandler => {
             ErrorHandling.log(errHandler);
-            reject(Utils.prettifyExn(errHandler.exn));
+            reject(ErrorHandling.toExn(errHandler));
           }, () => resolve());
           indexerStateRef.contents = Primitive_option.some(indexerState);
           IndexerLoop.start(indexerState);

package/src/Worker.res

@@ -17,11 +17,17 @@ type config = {
   // process are still backfilling, and an indexer goes realtime as a whole or
   // not at all. Cleared by the supervisor's `ReleaseRealtime`.
   holdRealtime: bool,
+  // Which command the run was started by. A worker re-parses the project's
+  // files, which say nothing about that, so it can only be told — and a worker
+  // that took a dev run for a plain one would exit at its end block and leave
+  // the console it was still serving with a chain missing.
+  isDev: bool,
 }
 
 let configSchema = S.object((s): config => {
   chainIds: s.field("chainIds", S.array(ChainId.schema)),
   holdRealtime: s.fieldOr("holdRealtime", S.bool, false),
+  isDev: s.field("isDev", S.bool),
 })
 
 // Read as this module loads, which is before anything that could catch a bare

package/src/Worker.res.mjs

@@ -14,7 +14,8 @@ let envVar = "ENVIO_INTERNAL_WORKER";
 
 let configSchema = S$RescriptSchema.object(s => ({
   chainIds: s.f("chainIds", S$RescriptSchema.array(ChainId.schema)),
-  holdRealtime: s.fieldOr("holdRealtime", S$RescriptSchema.bool, false)
+  holdRealtime: s.fieldOr("holdRealtime", S$RescriptSchema.bool, false),
+  isDev: s.f("isDev", S$RescriptSchema.bool)
 }));
 
 function detect(env, hasChannel) {

package/src/bindings/NodeJs.res

@@ -157,7 +157,30 @@ module ChildProcess = {
   @module("child_process")
   external execWithOptions: (string, execOptions, callback) => unit = "exec"
 
-  type child
+  // One of a child's stdio slots, present only for a slot the parent asked to
+  // pipe rather than inherit.
+  module Stream = {
+    type t
+    @send external setEncoding: (t, string) => unit = "setEncoding"
+    @send external onData: (t, @as("data") _, string => unit) => unit = "on"
+    @send external onEnd: (t, @as("end") _, unit => unit) => unit = "on"
+  }
+
+  module Child = {
+    type t
+    @send external send: (t, 'msg) => bool = "send"
+    @send external onMessage: (t, @as("message") _, 'msg => unit) => unit = "on"
+    @send
+    external onExit: (t, @as("exit") _, (Null.t<int>, Null.t<string>) => unit) => unit = "on"
+    @send external onError: (t, @as("error") _, exn => unit) => unit = "on"
+    @send external kill: (t, string) => bool = "kill"
+    // Whether the IPC channel is still open. Node closes it before it reports
+    // the exit, so this goes false while the child is still running.
+    @get external connected: t => bool = "connected"
+    @get external stdout: t => Null.t<Stream.t> = "stdout"
+    @get external stderr: t => Null.t<Stream.t> = "stderr"
+  }
+
   type forkOptions = {
     cwd?: string,
     env?: dict<string>,
@@ -167,21 +190,7 @@ module ChildProcess = {
     stdio?: array<string>,
   }
   @module("child_process")
-  external fork: (string, array<string>, forkOptions) => child = "fork"
-  @send external send: (child, 'msg) => bool = "send"
-  @send external onMessage: (child, @as("message") _, 'msg => unit) => unit = "on"
-  @send
-  external onExit: (child, @as("exit") _, (Null.t<int>, Null.t<string>) => unit) => unit = "on"
-  @send external onChildError: (child, @as("error") _, exn => unit) => unit = "on"
-  @send external kill: (child, string) => bool = "kill"
-
-  // Present only for a stdio slot the parent asked to pipe.
-  type stdioStream
-  @get external stdout: child => Null.t<stdioStream> = "stdout"
-  @get external stderr: child => Null.t<stdioStream> = "stderr"
-  @send external setEncoding: (stdioStream, string) => unit = "setEncoding"
-  @send external onData: (stdioStream, @as("data") _, string => unit) => unit = "on"
-  @send external onEnd: (stdioStream, @as("end") _, unit => unit) => unit = "on"
+  external fork: (string, array<string>, forkOptions) => Child.t = "fork"
 }
 
 module Url = {

package/src/bindings/NodeJs.res.mjs

@@ -28,7 +28,14 @@ let V8 = {};
 
 let PerfHooks = {};
 
-let ChildProcess = {};
+let Stream = {};
+
+let Child = {};
+
+let ChildProcess = {
+  Stream: Stream,
+  Child: Child
+};
 
 let Url$1 = {};
 

package/src/sources/AddressSet.res

@@ -20,8 +20,10 @@ type startBlockGroup = {startBlock: int, count: int}
 
 @send external merge: (t, t) => t = "merge"
 
-@send external addresses: t => array<Address.t> = "addresses"
-
-@send external entries: t => array<Internal.indexingContract> = "entries"
+// For assertions only - nothing in the indexer reads it. A query gets its
+// address filter from the set's cached per-contract slices and the runtime asks
+// `containsAt`; this is the only way a test can compare two sets by what they
+// hold rather than by handle identity.
+@send external addressesForTest: t => array<Address.t> = "addressesForTest"
 
 let isEmpty = (set: t) => set->size === 0

package/src/sources/AddressStore.res

@@ -45,15 +45,14 @@ type makeSetOptions = {
   limit?: int,
 }
 
-@send
-external newEvm: (Core.addressStoreCtor, bool, array<contract>) => t = "newEvm"
+@send external newEvm: (Core.addressStoreCtor, array<contract>) => t = "newEvm"
 @send external newSvm: (Core.addressStoreCtor, array<contract>) => t = "newSvm"
 @send external newFuel: (Core.addressStoreCtor, array<contract>) => t = "newFuel"
 
-let make = (~ecosystem: Ecosystem.name, ~shouldChecksum: bool, ~contracts: array<contract>): t => {
+let make = (~ecosystem: Ecosystem.name, ~contracts: array<contract>): t => {
   let ctor = Core.getAddon().addressStore
   switch ecosystem {
-  | Evm => ctor->newEvm(shouldChecksum, contracts)
+  | Evm => ctor->newEvm(contracts)
   | Svm => ctor->newSvm(contracts)
   | Fuel => ctor->newFuel(contracts)
   }
@@ -105,7 +104,6 @@ let contractsOf = (
 
 @send
 external registerBatchRaw: (t, array<registration>) => array<rawVerdict> = "registerBatch"
-@send external seedBatchRaw: (t, array<registration>) => array<rawVerdict> = "seedBatch"
 
 @send
 external seedRowsRaw: (
@@ -128,7 +126,12 @@ external drainForWrite: (t, int, array<int>) => array<drainedAddress> = "drainFo
 
 @send external pendingCount: t => int = "pendingCount"
 
-@send external pendingEntries: t => array<Internal.indexingContract> = "pendingEntries"
+// For assertions only - nothing in the indexer reads it. The write path drains
+// instead, and `pendingCount` is what the runtime asks; neither lets a test see
+// which registrations are queued without consuming them.
+@send
+external pendingEntriesForTest: t => array<Internal.indexingContract> = "pendingEntriesForTest"
+
 @send external makeSetRaw: (t, string, makeSetOptions) => AddressSet.t = "makeSet"
 @send external contractCount: (t, string) => int = "contractCount"
 
@@ -145,11 +148,19 @@ type rolledBackAddress = {address: NodeJs.Buffer.t, contractId: int}
 // still point at the right entries.
 @send external rollback: (t, int) => array<rolledBackAddress> = "rollback"
 
-@send external getAll: (t, Address.t) => array<Internal.indexingContract> = "getAll"
+// For assertions only - nothing in the indexer reads it. The runtime's gate is
+// `isIndexedAt` and the user sees `contractAddresses`; neither exposes an
+// entry's own start blocks or the order registrations sort into.
+@send
+external getAllForTest: (t, Address.t) => array<Internal.indexingContract> = "getAllForTest"
 
 @send external dynamicContractNames: t => array<string> = "dynamicContractNames"
 
-@send external contractAddresses: (t, string) => array<Address.t> = "contractAddresses"
+// The one place the store spells an address the way the chain shows it: the
+// setting comes from the caller, since the store keeps keys, not spellings.
+@send
+external contractAddresses: (t, string, ~shouldChecksum: bool) => array<Address.t> =
+  "contractAddresses"
 
 let toVerdict = (raw: rawVerdict): verdict =>
   switch raw.kind {
@@ -167,8 +178,5 @@ let toVerdict = (raw: rawVerdict): verdict =>
 let registerBatch = (store: t, registrations: array<registration>): array<verdict> =>
   store->registerBatchRaw(registrations)->Array.map(toVerdict)
 
-let seedBatch = (store: t, registrations: array<registration>): array<verdict> =>
-  store->seedBatchRaw(registrations)->Array.map(toVerdict)
-
 let makeSet = (store: t, ~contractName, ~options={}: makeSetOptions) =>
   store->makeSetRaw(contractName, options)

package/src/sources/AddressStore.res.mjs

@@ -6,11 +6,11 @@ import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as ContractMapping from "../ContractMapping.res.mjs";
 
-function make(ecosystem, shouldChecksum, contracts) {
+function make(ecosystem, contracts) {
   let ctor = Core.getAddon().AddressStore;
   switch (ecosystem) {
     case "evm" :
-      return ctor.newEvm(shouldChecksum, contracts);
+      return ctor.newEvm(contracts);
     case "fuel" :
       return ctor.newFuel(contracts);
     case "svm" :
@@ -74,10 +74,6 @@ function registerBatch(store, registrations) {
   return store.registerBatch(registrations).map(toVerdict);
 }
 
-function seedBatch(store, registrations) {
-  return store.seedBatch(registrations).map(toVerdict);
-}
-
 function makeSet(store, contractName, optionsOpt) {
   let options = optionsOpt !== undefined ? optionsOpt : ({});
   return store.makeSet(contractName, options);
@@ -89,7 +85,6 @@ export {
   seedRows,
   toVerdict,
   registerBatch,
-  seedBatch,
   makeSet,
 }
 /* Core Not a pure module */